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_atomic (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
)
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
);
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
)
1699 s1
= gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1707 /* Callback called when the "Show hidden files" toggle is pressed.
1708 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1711 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1713 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1715 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1716 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1720 /* Callback called when a property changes in a file chooser.
1721 GOBJECT is the file chooser dialog, ARG1 describes the property.
1722 USER_DATA is the toggle widget in the file chooser dialog.
1723 We use this to update the "Show hidden files" toggle when the user
1724 changes that property by right clicking in the file list. */
1727 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1729 if (strcmp (arg1
->name
, "show-hidden") == 0)
1731 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1732 gboolean visible
, toggle_on
;
1734 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1735 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1737 if (!!visible
!= !!toggle_on
)
1739 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1740 G_CALLBACK (xg_toggle_visibility_cb
),
1742 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1743 g_signal_handlers_unblock_by_func
1744 (G_OBJECT (wtoggle
),
1745 G_CALLBACK (xg_toggle_visibility_cb
),
1748 x_gtk_show_hidden_files
= visible
;
1752 /* Read a file name from the user using a file chooser dialog.
1753 F is the current frame.
1754 PROMPT is a prompt to show to the user. May not be NULL.
1755 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1756 If MUSTMATCH_P, the returned file name must be an existing
1757 file. (Actually, this only has cosmetic effects, the user can
1758 still enter a non-existing file.) *FUNC is set to a function that
1759 can be used to retrieve the selected file name from the returned widget.
1761 Returns the created widget. */
1764 xg_get_file_with_chooser (struct frame
*f
,
1766 char *default_filename
,
1767 bool mustmatch_p
, bool only_dir_p
,
1768 xg_get_file_func
*func
)
1772 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1773 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1774 GtkFileChooserAction action
= (mustmatch_p
?
1775 GTK_FILE_CHOOSER_ACTION_OPEN
:
1776 GTK_FILE_CHOOSER_ACTION_SAVE
);
1779 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1781 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1782 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1783 (mustmatch_p
|| only_dir_p
?
1784 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1787 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1789 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1790 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1791 gtk_widget_show (wbox
);
1792 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1794 if (x_gtk_show_hidden_files
)
1796 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1797 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1799 gtk_widget_show (wtoggle
);
1800 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1801 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1802 g_signal_connect (G_OBJECT (filewin
), "notify",
1803 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1805 if (x_gtk_file_dialog_help_text
)
1808 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1809 Show the C-l help text only for versions < 2.10. */
1810 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1811 strcat (msgbuf
, "\nType C-l to display a file name text entry box.\n");
1812 strcat (msgbuf
, "\nIf you don't like this file selector, use the "
1813 "corresponding\nkey binding or customize "
1814 "use-file-dialog to turn it off.");
1816 wmessage
= gtk_label_new (msgbuf
);
1817 gtk_widget_show (wmessage
);
1820 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1821 if (x_gtk_file_dialog_help_text
)
1822 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1823 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1825 if (default_filename
)
1828 struct gcpro gcpro1
;
1829 char *utf8_filename
;
1832 file
= build_string (default_filename
);
1834 /* File chooser does not understand ~/... in the file name. It must be
1835 an absolute name starting with /. */
1836 if (default_filename
[0] != '/')
1837 file
= Fexpand_file_name (file
, Qnil
);
1839 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1840 if (! NILP (Ffile_directory_p (file
)))
1841 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1845 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1847 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1849 char *cp
= strrchr (utf8_filename
, '/');
1851 else cp
= utf8_filename
;
1852 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1859 *func
= xg_get_file_name_from_chooser
;
1863 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1865 /* Return the selected file for file selector dialog W.
1866 The returned string must be free:d. */
1869 xg_get_file_name_from_selector (GtkWidget
*w
)
1871 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1872 return xstrdup (gtk_file_selection_get_filename (filesel
));
1875 /* Create a file selection dialog.
1876 F is the current frame.
1877 PROMPT is a prompt to show to the user. May not be NULL.
1878 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1879 If MUSTMATCH_P, the returned file name must be an existing
1880 file. *FUNC is set to a function that can be used to retrieve the
1881 selected file name from the returned widget.
1883 Returns the created widget. */
1886 xg_get_file_with_selection (struct frame
*f
,
1888 char *default_filename
,
1889 bool mustmatch_p
, bool only_dir_p
,
1890 xg_get_file_func
*func
)
1893 GtkFileSelection
*filesel
;
1895 filewin
= gtk_file_selection_new (prompt
);
1896 filesel
= GTK_FILE_SELECTION (filewin
);
1898 if (default_filename
)
1899 gtk_file_selection_set_filename (filesel
, default_filename
);
1903 /* The selection_entry part of filesel is not documented. */
1904 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1905 gtk_file_selection_hide_fileop_buttons (filesel
);
1908 *func
= xg_get_file_name_from_selector
;
1912 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1914 /* Read a file name from the user using a file dialog, either the old
1915 file selection dialog, or the new file chooser dialog. Which to use
1916 depends on what the GTK version used has, and what the value of
1917 gtk-use-old-file-dialog.
1918 F is the current frame.
1919 PROMPT is a prompt to show to the user. May not be NULL.
1920 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1921 If MUSTMATCH_P, the returned file name must be an existing
1924 Returns a file name or NULL if no file was selected.
1925 The returned string must be freed by the caller. */
1928 xg_get_file_name (struct frame
*f
,
1930 char *default_filename
,
1936 int filesel_done
= 0;
1937 xg_get_file_func func
;
1939 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1941 if (xg_uses_old_file_dialog ())
1942 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1943 mustmatch_p
, only_dir_p
, &func
);
1945 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1946 mustmatch_p
, only_dir_p
, &func
);
1948 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1949 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1950 mustmatch_p
, only_dir_p
, &func
);
1951 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1953 gtk_widget_set_name (w
, "emacs-filedialog");
1955 filesel_done
= xg_dialog_run (f
, w
);
1956 if (filesel_done
== GTK_RESPONSE_OK
)
1959 gtk_widget_destroy (w
);
1963 /***********************************************************************
1965 ***********************************************************************/
1967 #ifdef HAVE_FREETYPE
1969 #if USE_NEW_GTK_FONT_CHOOSER
1971 #define XG_WEIGHT_TO_SYMBOL(w) \
1972 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
1973 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
1974 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
1975 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
1976 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
1977 : w <= PANGO_WEIGHT_BOLD ? Qbold \
1978 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
1981 #define XG_STYLE_TO_SYMBOL(s) \
1982 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
1983 : s == PANGO_STYLE_ITALIC ? Qitalic \
1986 #endif /* USE_NEW_GTK_FONT_CHOOSER */
1989 static char *x_last_font_name
;
1991 /* Pop up a GTK font selector and return the name of the font the user
1992 selects, as a C string. The returned font name follows GTK's own
1995 `FAMILY [VALUE1 VALUE2] SIZE'
1997 This can be parsed using font_parse_fcname in font.c.
1998 DEFAULT_NAME, if non-zero, is the default font name. */
2001 xg_get_font (struct frame
*f
, const char *default_name
)
2005 Lisp_Object font
= Qnil
;
2007 w
= gtk_font_chooser_dialog_new
2008 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2012 /* Convert fontconfig names to Gtk names, i.e. remove - before
2014 char *p
= strrchr (default_name
, '-');
2018 while (c_isdigit (*ep
))
2020 if (*ep
== '\0') *p
= ' ';
2023 else if (x_last_font_name
)
2024 default_name
= x_last_font_name
;
2027 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2029 gtk_widget_set_name (w
, "emacs-fontdialog");
2030 done
= xg_dialog_run (f
, w
);
2031 if (done
== GTK_RESPONSE_OK
)
2033 #if USE_NEW_GTK_FONT_CHOOSER
2034 /* Use the GTK3 font chooser. */
2035 PangoFontDescription
*desc
2036 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2040 Lisp_Object args
[10];
2041 const char *name
= pango_font_description_get_family (desc
);
2042 gint size
= pango_font_description_get_size (desc
);
2043 PangoWeight weight
= pango_font_description_get_weight (desc
);
2044 PangoStyle style
= pango_font_description_get_style (desc
);
2047 args
[1] = build_string (name
);
2050 args
[3] = make_float (pango_units_to_double (size
));
2053 args
[5] = XG_WEIGHT_TO_SYMBOL (weight
);
2056 args
[7] = XG_STYLE_TO_SYMBOL (style
);
2061 font
= Ffont_spec (8, args
);
2063 pango_font_description_free (desc
);
2064 dupstring (&x_last_font_name
, name
);
2067 #else /* Use old font selector, which just returns the font name. */
2070 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2074 font
= build_string (font_name
);
2075 g_free (x_last_font_name
);
2076 x_last_font_name
= font_name
;
2078 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2081 gtk_widget_destroy (w
);
2084 #endif /* HAVE_FREETYPE */
2088 /***********************************************************************
2090 ***********************************************************************/
2092 /* The name of menu items that can be used for customization. Since GTK
2093 RC files are very crude and primitive, we have to set this on all
2094 menu item names so a user can easily customize menu items. */
2096 #define MENU_ITEM_NAME "emacs-menuitem"
2099 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2100 during GC. The next member points to the items. */
2101 static xg_list_node xg_menu_cb_list
;
2103 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2104 during GC. The next member points to the items. */
2105 static xg_list_node xg_menu_item_cb_list
;
2107 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2108 F is the frame CL_DATA will be initialized for.
2109 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2111 The menu bar and all sub menus under the menu bar in a frame
2112 share the same structure, hence the reference count.
2114 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2115 allocated xg_menu_cb_data if CL_DATA is NULL. */
2117 static xg_menu_cb_data
*
2118 make_cl_data (xg_menu_cb_data
*cl_data
, struct frame
*f
, GCallback highlight_cb
)
2122 cl_data
= xmalloc_uncollectable (sizeof *cl_data
);
2124 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2125 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2126 cl_data
->highlight_cb
= highlight_cb
;
2127 cl_data
->ref_count
= 0;
2129 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2132 cl_data
->ref_count
++;
2137 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2138 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2140 When the menu bar is updated, menu items may have been added and/or
2141 removed, so menu_bar_vector and menu_bar_items_used change. We must
2142 then update CL_DATA since it is used to determine which menu
2143 item that is invoked in the menu.
2144 HIGHLIGHT_CB could change, there is no check that the same
2145 function is given when modifying a menu bar as was given when
2146 creating the menu bar. */
2149 update_cl_data (xg_menu_cb_data
*cl_data
,
2151 GCallback highlight_cb
)
2156 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2157 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2158 cl_data
->highlight_cb
= highlight_cb
;
2162 /* Decrease reference count for CL_DATA.
2163 If reference count is zero, free CL_DATA. */
2166 unref_cl_data (xg_menu_cb_data
*cl_data
)
2168 if (cl_data
&& cl_data
->ref_count
> 0)
2170 cl_data
->ref_count
--;
2171 if (cl_data
->ref_count
== 0)
2173 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2179 /* Callback called when a menu item is destroyed. Used to free data.
2180 W is the widget that is being destroyed (not used).
2181 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2184 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2188 xg_menu_item_cb_data
*data
= client_data
;
2189 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2194 /* Callback called when the pointer enters/leaves a menu item.
2195 W is the parent of the menu item.
2196 EVENT is either an enter event or leave event.
2197 CLIENT_DATA is not used.
2199 Returns FALSE to tell GTK to keep processing this event. */
2202 menuitem_highlight_callback (GtkWidget
*w
,
2203 GdkEventCrossing
*event
,
2204 gpointer client_data
)
2207 GtkWidget
*subwidget
;
2208 xg_menu_item_cb_data
*data
;
2210 ev
.crossing
= *event
;
2211 subwidget
= gtk_get_event_widget (&ev
);
2212 data
= g_object_get_data (G_OBJECT (subwidget
), XG_ITEM_DATA
);
2215 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2217 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2218 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2219 (*func
) (subwidget
, call_data
);
2226 /* Callback called when a menu is destroyed. Used to free data.
2227 W is the widget that is being destroyed (not used).
2228 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2231 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2233 unref_cl_data (client_data
);
2236 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2237 must be non-NULL) and can be inserted into a menu item.
2239 Returns the GtkHBox. */
2242 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2248 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2249 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2250 wlbl
= gtk_label_new (utf8_label
);
2251 wkey
= gtk_label_new (utf8_key
);
2253 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2254 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2256 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2257 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2259 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2260 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2261 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2266 /* Make and return a menu item widget with the key to the right.
2267 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2268 UTF8_KEY is the text representing the key binding.
2269 ITEM is the widget_value describing the menu item.
2271 GROUP is an in/out parameter. If the menu item to be created is not
2272 part of any radio menu group, *GROUP contains NULL on entry and exit.
2273 If the menu item to be created is part of a radio menu group, on entry
2274 *GROUP contains the group to use, or NULL if this is the first item
2275 in the group. On exit, *GROUP contains the radio item group.
2277 Unfortunately, keys don't line up as nicely as in Motif,
2278 but the MacOS X version doesn't either, so I guess that is OK. */
2281 make_menu_item (const char *utf8_label
,
2282 const char *utf8_key
,
2287 GtkWidget
*wtoadd
= 0;
2289 /* It has been observed that some menu items have a NULL name field.
2290 This will lead to this function being called with a NULL utf8_label.
2291 GTK crashes on that so we set a blank label. Why there is a NULL
2292 name remains to be investigated. */
2293 if (! utf8_label
) utf8_label
= " ";
2296 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2298 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2301 if (utf8_key
) w
= gtk_check_menu_item_new ();
2302 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2303 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2305 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2307 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2308 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2309 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2311 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2316 if (utf8_key
) w
= gtk_menu_item_new ();
2317 else w
= gtk_menu_item_new_with_label (utf8_label
);
2320 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2321 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2326 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2328 static int xg_detached_menus
;
2330 /* Return true if there are detached menus. */
2333 xg_have_tear_offs (struct frame
*f
)
2335 /* If the frame's menubar height is zero, the menu bar is probably
2336 being redirected outside the window to some kind of global menu;
2337 this situation is the moral equivalent of a tear-off. */
2338 return FRAME_MENUBAR_HEIGHT (f
) == 0 || xg_detached_menus
> 0;
2341 /* Callback invoked when a detached menu window is removed. Here we
2342 decrease the xg_detached_menus count.
2343 WIDGET is the top level window that is removed (the parent of the menu).
2344 CLIENT_DATA is not used. */
2347 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2349 if (xg_detached_menus
> 0) --xg_detached_menus
;
2352 /* Callback invoked when a menu is detached. It increases the
2353 xg_detached_menus count.
2354 WIDGET is the GtkTearoffMenuItem.
2355 CLIENT_DATA is not used. */
2358 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2360 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2361 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2363 ++xg_detached_menus
;
2364 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2366 G_CALLBACK (tearoff_remove
), 0);
2369 #else /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2371 xg_have_tear_offs (struct frame
*f
)
2373 return FRAME_MENUBAR_HEIGHT (f
) == 0;
2375 #endif /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2377 /* Create a menu item widget, and connect the callbacks.
2378 ITEM describes the menu item.
2379 F is the frame the created menu belongs to.
2380 SELECT_CB is the callback to use when a menu item is selected.
2381 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2382 CL_DATA points to the callback data to be used for this menu.
2383 GROUP is an in/out parameter. If the menu item to be created is not
2384 part of any radio menu group, *GROUP contains NULL on entry and exit.
2385 If the menu item to be created is part of a radio menu group, on entry
2386 *GROUP contains the group to use, or NULL if this is the first item
2387 in the group. On exit, *GROUP contains the radio item group.
2389 Returns the created GtkWidget. */
2392 xg_create_one_menuitem (widget_value
*item
,
2394 GCallback select_cb
,
2395 GCallback highlight_cb
,
2396 xg_menu_cb_data
*cl_data
,
2402 xg_menu_item_cb_data
*cb_data
;
2404 utf8_label
= get_utf8_string (item
->name
);
2405 utf8_key
= get_utf8_string (item
->key
);
2407 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2409 if (utf8_label
) g_free (utf8_label
);
2410 if (utf8_key
) g_free (utf8_key
);
2412 cb_data
= xmalloc (sizeof *cb_data
);
2414 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2416 cb_data
->select_id
= 0;
2417 cb_data
->help
= item
->help
;
2418 cb_data
->cl_data
= cl_data
;
2419 cb_data
->call_data
= item
->call_data
;
2421 g_signal_connect (G_OBJECT (w
),
2423 G_CALLBACK (menuitem_destroy_callback
),
2426 /* Put cb_data in widget, so we can get at it when modifying menubar */
2427 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2429 /* final item, not a submenu */
2430 if (item
->call_data
&& ! item
->contents
)
2434 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2440 /* Create a full menu tree specified by DATA.
2441 F is the frame the created menu belongs to.
2442 SELECT_CB is the callback to use when a menu item is selected.
2443 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2444 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2445 If POP_UP_P, create a popup menu.
2446 If MENU_BAR_P, create a menu bar.
2447 If ADD_TEAROFF_P, add a tearoff menu item. Ignored if MENU_BAR_P or
2448 the Gtk+ version used does not have tearoffs.
2449 TOPMENU is the topmost GtkWidget that others shall be placed under.
2450 It may be NULL, in that case we create the appropriate widget
2451 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2452 CL_DATA is the callback data we shall use for this menu, or NULL
2453 if we haven't set the first callback yet.
2454 NAME is the name to give to the top level menu if this function
2455 creates it. May be NULL to not set any name.
2457 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2460 This function calls itself to create submenus. */
2463 create_menus (widget_value
*data
,
2465 GCallback select_cb
,
2466 GCallback deactivate_cb
,
2467 GCallback highlight_cb
,
2472 xg_menu_cb_data
*cl_data
,
2476 GtkWidget
*wmenu
= topmenu
;
2477 GSList
*group
= NULL
;
2483 wmenu
= gtk_menu_new ();
2484 xg_set_screen (wmenu
, f
);
2485 /* Connect this to the menu instead of items so we get enter/leave for
2486 disabled items also. TODO: Still does not get enter/leave for
2487 disabled items in detached menus. */
2488 g_signal_connect (G_OBJECT (wmenu
),
2489 "enter-notify-event",
2490 G_CALLBACK (menuitem_highlight_callback
),
2492 g_signal_connect (G_OBJECT (wmenu
),
2493 "leave-notify-event",
2494 G_CALLBACK (menuitem_highlight_callback
),
2499 wmenu
= gtk_menu_bar_new ();
2500 /* Set width of menu bar to a small value so it doesn't enlarge
2501 a small initial frame size. The width will be set to the
2502 width of the frame later on when it is added to a container.
2503 height -1: Natural height. */
2504 gtk_widget_set_size_request (wmenu
, 1, -1);
2507 /* Put cl_data on the top menu for easier access. */
2508 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2509 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2510 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2511 G_CALLBACK (menu_destroy_callback
), cl_data
);
2514 gtk_widget_set_name (wmenu
, name
);
2517 g_signal_connect (G_OBJECT (wmenu
),
2518 "selection-done", deactivate_cb
, 0);
2521 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2522 if (! menu_bar_p
&& add_tearoff_p
)
2524 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2525 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2527 g_signal_connect (G_OBJECT (tearoff
), "activate",
2528 G_CALLBACK (tearoff_activate
), 0);
2532 for (item
= data
; item
; item
= item
->next
)
2536 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2537 && !menu_separator_name_p (item
->name
))
2540 /* A title for a popup. We do the same as GTK does when
2541 creating titles, but it does not look good. */
2543 utf8_label
= get_utf8_string (item
->name
);
2545 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2546 w
= gtk_menu_item_new_with_label (utf8_label
);
2547 gtk_widget_set_sensitive (w
, FALSE
);
2548 if (utf8_label
) g_free (utf8_label
);
2550 else if (menu_separator_name_p (item
->name
))
2553 /* GTK only have one separator type. */
2554 w
= gtk_separator_menu_item_new ();
2558 w
= xg_create_one_menuitem (item
,
2560 item
->contents
? 0 : select_cb
,
2565 /* Create a possibly empty submenu for menu bar items, since some
2566 themes don't highlight items correctly without it. */
2567 if (item
->contents
|| menu_bar_p
)
2569 GtkWidget
*submenu
= create_menus (item
->contents
,
2580 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2584 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2585 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2591 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2592 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2593 with some text and buttons.
2594 F is the frame the created item belongs to.
2595 NAME is the name to use for the top widget.
2596 VAL is a widget_value structure describing items to be created.
2597 SELECT_CB is the callback to use when a menu item is selected or
2598 a dialog button is pressed.
2599 DEACTIVATE_CB is the callback to use when an item is deactivated.
2600 For a menu, when a sub menu is not shown anymore, for a dialog it is
2601 called when the dialog is popped down.
2602 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2604 Returns the widget created. */
2607 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2608 widget_value
*val
, GCallback select_cb
,
2609 GCallback deactivate_cb
, GCallback highlight_cb
)
2612 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2613 bool pop_up_p
= strcmp (type
, "popup") == 0;
2615 if (strcmp (type
, "dialog") == 0)
2617 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2618 xg_set_screen (w
, f
);
2619 gtk_window_set_transient_for (GTK_WINDOW (w
),
2620 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2621 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2622 gtk_widget_set_name (w
, "emacs-dialog");
2623 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2625 else if (menu_bar_p
|| pop_up_p
)
2627 w
= create_menus (val
->contents
,
2639 /* Set the cursor to an arrow for popup menus when they are mapped.
2640 This is done by default for menu bar menus. */
2643 /* Must realize so the GdkWindow inside the widget is created. */
2644 gtk_widget_realize (w
);
2645 xg_set_cursor (w
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
2650 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2657 /* Return the label for menu item WITEM. */
2660 xg_get_menu_item_label (GtkMenuItem
*witem
)
2662 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2663 return gtk_label_get_label (wlabel
);
2666 /* Return true if the menu item WITEM has the text LABEL. */
2669 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2672 char *utf8_label
= get_utf8_string (label
);
2673 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2675 if (! old_label
&& ! utf8_label
)
2677 else if (old_label
&& utf8_label
)
2678 is_same
= strcmp (utf8_label
, old_label
) == 0;
2680 if (utf8_label
) g_free (utf8_label
);
2685 /* Destroy widgets in LIST. */
2688 xg_destroy_widgets (GList
*list
)
2692 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2694 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2696 /* Destroying the widget will remove it from the container it is in. */
2697 gtk_widget_destroy (w
);
2701 /* Update the top level names in MENUBAR (i.e. not submenus).
2702 F is the frame the menu bar belongs to.
2703 *LIST is a list with the current menu bar names (menu item widgets).
2704 ITER is the item within *LIST that shall be updated.
2705 POS is the numerical position, starting at 0, of ITER in *LIST.
2706 VAL describes what the menu bar shall look like after the update.
2707 SELECT_CB is the callback to use when a menu item is selected.
2708 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2709 CL_DATA points to the callback data to be used for this menu bar.
2711 This function calls itself to walk through the menu bar names. */
2714 xg_update_menubar (GtkWidget
*menubar
,
2720 GCallback select_cb
,
2721 GCallback deactivate_cb
,
2722 GCallback highlight_cb
,
2723 xg_menu_cb_data
*cl_data
)
2725 if (! iter
&& ! val
)
2727 else if (iter
&& ! val
)
2729 /* Item(s) have been removed. Remove all remaining items. */
2730 xg_destroy_widgets (iter
);
2732 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2733 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2734 gtk_menu_item_new_with_label (""),
2740 else if (! iter
&& val
)
2742 /* Item(s) added. Add all new items in one call. */
2743 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2744 0, 1, 0, menubar
, cl_data
, 0);
2750 /* Below this neither iter or val is NULL */
2751 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2753 /* This item is still the same, check next item. */
2755 iter
= g_list_next (iter
);
2758 else /* This item is changed. */
2760 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2761 GtkMenuItem
*witem2
= 0;
2762 bool val_in_menubar
= 0;
2763 bool iter_in_new_menubar
= 0;
2767 /* See if the changed entry (val) is present later in the menu bar */
2769 iter2
&& ! val_in_menubar
;
2770 iter2
= g_list_next (iter2
))
2772 witem2
= GTK_MENU_ITEM (iter2
->data
);
2773 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2776 /* See if the current entry (iter) is present later in the
2777 specification for the new menu bar. */
2778 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2779 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2781 if (val_in_menubar
&& ! iter_in_new_menubar
)
2785 /* This corresponds to:
2790 g_object_ref (G_OBJECT (witem
));
2791 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2792 gtk_widget_destroy (GTK_WIDGET (witem
));
2794 /* Must get new list since the old changed. */
2795 g_list_free (*list
);
2796 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2797 while (nr
-- > 0) iter
= g_list_next (iter
);
2799 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2801 /* This corresponds to:
2804 Rename B to X. This might seem to be a strange thing to do,
2805 since if there is a menu under B it will be totally wrong for X.
2806 But consider editing a C file. Then there is a C-mode menu
2807 (corresponds to B above).
2808 If then doing C-x C-f the minibuf menu (X above) replaces the
2809 C-mode menu. When returning from the minibuffer, we get
2810 back the C-mode menu. Thus we do:
2811 Rename B to X (C-mode to minibuf menu)
2812 Rename X to B (minibuf to C-mode menu).
2813 If the X menu hasn't been invoked, the menu under B
2814 is up to date when leaving the minibuffer. */
2815 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2816 char *utf8_label
= get_utf8_string (val
->name
);
2817 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2819 /* GTK menu items don't notice when their labels have been
2820 changed from underneath them, so we have to explicitly
2821 use g_object_notify to tell listeners (e.g., a GMenuModel
2822 bridge that might be loaded) that the item's label has
2824 gtk_label_set_text (wlabel
, utf8_label
);
2825 g_object_notify (G_OBJECT (witem
), "label");
2827 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2828 /* If this item has a submenu that has been detached, change
2829 the title in the WM decorations also. */
2830 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2831 /* Set the title of the detached window. */
2832 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2835 if (utf8_label
) g_free (utf8_label
);
2836 iter
= g_list_next (iter
);
2840 else if (! val_in_menubar
&& iter_in_new_menubar
)
2842 /* This corresponds to:
2849 GtkWidget
*w
= xg_create_one_menuitem (val
,
2856 /* Create a possibly empty submenu for menu bar items, since some
2857 themes don't highlight items correctly without it. */
2858 GtkWidget
*submenu
= create_menus (NULL
, f
,
2859 select_cb
, deactivate_cb
,
2861 0, 0, 0, 0, cl_data
, 0);
2863 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2864 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2865 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2867 g_list_free (*list
);
2868 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2869 while (nr
-- > 0) iter
= g_list_next (iter
);
2870 iter
= g_list_next (iter
);
2874 else /* if (val_in_menubar && iter_in_new_menubar) */
2877 /* This corresponds to:
2882 g_object_ref (G_OBJECT (witem2
));
2883 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2884 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2885 GTK_WIDGET (witem2
), pos
);
2886 g_object_unref (G_OBJECT (witem2
));
2888 g_list_free (*list
);
2889 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2890 while (nr
-- > 0) iter
= g_list_next (iter
);
2891 if (iter
) iter
= g_list_next (iter
);
2897 /* Update the rest of the menu bar. */
2898 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2899 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2902 /* Update the menu item W so it corresponds to VAL.
2903 SELECT_CB is the callback to use when a menu item is selected.
2904 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2905 CL_DATA is the data to set in the widget for menu invocation. */
2908 xg_update_menu_item (widget_value
*val
,
2910 GCallback select_cb
,
2911 GCallback highlight_cb
,
2912 xg_menu_cb_data
*cl_data
)
2919 const char *old_label
= 0;
2920 const char *old_key
= 0;
2921 xg_menu_item_cb_data
*cb_data
;
2922 bool label_changed
= false;
2924 wchild
= XG_BIN_CHILD (w
);
2925 utf8_label
= get_utf8_string (val
->name
);
2926 utf8_key
= get_utf8_string (val
->key
);
2928 /* See if W is a menu item with a key. See make_menu_item above. */
2929 if (GTK_IS_BOX (wchild
))
2931 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2933 wlbl
= GTK_LABEL (list
->data
);
2934 wkey
= GTK_LABEL (list
->next
->data
);
2939 /* Remove the key and keep just the label. */
2940 g_object_ref (G_OBJECT (wlbl
));
2941 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2942 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2943 g_object_unref (G_OBJECT (wlbl
));
2948 else /* Just a label. */
2950 wlbl
= GTK_LABEL (wchild
);
2952 /* Check if there is now a key. */
2955 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2956 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2958 wlbl
= GTK_LABEL (list
->data
);
2959 wkey
= GTK_LABEL (list
->next
->data
);
2962 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2963 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2967 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2968 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2970 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2972 label_changed
= true;
2973 gtk_label_set_text (wkey
, utf8_key
);
2976 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2978 label_changed
= true;
2979 gtk_label_set_text (wlbl
, utf8_label
);
2982 if (utf8_key
) g_free (utf8_key
);
2983 if (utf8_label
) g_free (utf8_label
);
2985 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2986 gtk_widget_set_sensitive (w
, FALSE
);
2987 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2988 gtk_widget_set_sensitive (w
, TRUE
);
2990 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
2993 cb_data
->call_data
= val
->call_data
;
2994 cb_data
->help
= val
->help
;
2995 cb_data
->cl_data
= cl_data
;
2997 /* We assume the callback functions don't change. */
2998 if (val
->call_data
&& ! val
->contents
)
3000 /* This item shall have a select callback. */
3001 if (! cb_data
->select_id
)
3003 = g_signal_connect (G_OBJECT (w
), "activate",
3004 select_cb
, cb_data
);
3006 else if (cb_data
->select_id
)
3008 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3009 cb_data
->select_id
= 0;
3013 if (label_changed
) /* See comment in xg_update_menubar. */
3014 g_object_notify (G_OBJECT (w
), "label");
3017 /* Update the toggle menu item W so it corresponds to VAL. */
3020 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3022 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3025 /* Update the radio menu item W so it corresponds to VAL. */
3028 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3030 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3033 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3034 SUBMENU may be NULL, in that case a new menu is created.
3035 F is the frame the menu bar belongs to.
3036 VAL describes the contents of the menu bar.
3037 SELECT_CB is the callback to use when a menu item is selected.
3038 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3039 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3040 CL_DATA is the call back data to use for any newly created items.
3042 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3046 xg_update_submenu (GtkWidget
*submenu
,
3049 GCallback select_cb
,
3050 GCallback deactivate_cb
,
3051 GCallback highlight_cb
,
3052 xg_menu_cb_data
*cl_data
)
3054 GtkWidget
*newsub
= submenu
;
3058 bool has_tearoff_p
= 0;
3059 GList
*first_radio
= 0;
3062 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3064 for (cur
= val
, iter
= list
;
3066 iter
= g_list_next (iter
), cur
= cur
->next
)
3068 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3070 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
3071 /* Skip tearoff items, they have no counterpart in val. */
3072 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
3075 iter
= g_list_next (iter
);
3076 if (iter
) w
= GTK_WIDGET (iter
->data
);
3081 /* Remember first radio button in a group. If we get a mismatch in
3082 a radio group we must rebuild the whole group so that the connections
3083 in GTK becomes correct. */
3084 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3086 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3087 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3090 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3092 if (! menu_separator_name_p (cur
->name
))
3095 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3097 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3099 xg_update_toggle_item (cur
, w
);
3100 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3102 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3104 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3106 xg_update_radio_item (cur
, w
);
3107 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3109 else if (GTK_IS_MENU_ITEM (w
))
3111 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3114 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3115 menu_separator_name_p (cur
->name
))
3118 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3120 sub
= gtk_menu_item_get_submenu (witem
);
3121 if (sub
&& ! cur
->contents
)
3123 /* Not a submenu anymore. */
3124 g_object_ref (G_OBJECT (sub
));
3125 remove_submenu (witem
);
3126 gtk_widget_destroy (sub
);
3128 else if (cur
->contents
)
3132 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3133 select_cb
, deactivate_cb
,
3134 highlight_cb
, cl_data
);
3136 /* If this item just became a submenu, we must set it. */
3138 gtk_menu_item_set_submenu (witem
, nsub
);
3143 /* Structural difference. Remove everything from here and down
3149 /* Remove widgets from first structural change. */
3152 /* If we are adding new menu items below, we must remove from
3153 first radio button so that radio groups become correct. */
3154 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3155 else xg_destroy_widgets (iter
);
3160 /* More items added. Create them. */
3161 newsub
= create_menus (cur
,
3174 if (list
) g_list_free (list
);
3179 /* Update the MENUBAR.
3180 F is the frame the menu bar belongs to.
3181 VAL describes the contents of the menu bar.
3182 If DEEP_P, rebuild all but the top level menu names in
3183 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3184 SELECT_CB is the callback to use when a menu item is selected.
3185 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3186 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3189 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3190 widget_value
*val
, bool deep_p
,
3191 GCallback select_cb
, GCallback deactivate_cb
,
3192 GCallback highlight_cb
)
3194 xg_menu_cb_data
*cl_data
;
3195 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3199 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3201 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3202 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3208 /* Update all sub menus.
3209 We must keep the submenus (GTK menu item widgets) since the
3210 X Window in the XEvent that activates the menu are those widgets. */
3212 /* Update cl_data, menu_item things in F may have changed. */
3213 update_cl_data (cl_data
, f
, highlight_cb
);
3215 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3220 GtkMenuItem
*witem
= 0;
3222 /* Find sub menu that corresponds to val and update it. */
3223 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3225 witem
= GTK_MENU_ITEM (iter
->data
);
3226 if (xg_item_label_same_p (witem
, cur
->name
))
3228 sub
= gtk_menu_item_get_submenu (witem
);
3233 newsub
= xg_update_submenu (sub
,
3240 /* sub may still be NULL. If we just updated non deep and added
3241 a new menu bar item, it has no sub menu yet. So we set the
3242 newly created sub menu under witem. */
3243 if (newsub
!= sub
&& witem
!= 0)
3245 xg_set_screen (newsub
, f
);
3246 gtk_menu_item_set_submenu (witem
, newsub
);
3252 gtk_widget_show_all (menubar
);
3255 /* Callback called when the menu bar W is mapped.
3256 Used to find the height of the menu bar if we didn't get it
3257 after showing the widget. */
3260 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3263 struct frame
*f
= user_data
;
3264 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3265 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3267 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3268 xg_height_or_width_changed (f
);
3272 /* Recompute all the widgets of frame F, when the menu bar has been
3276 xg_update_frame_menubar (struct frame
*f
)
3278 struct x_output
*x
= f
->output_data
.x
;
3281 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3284 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3285 return; /* Already done this, happens for frames created invisible. */
3289 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3291 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3293 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3294 gtk_widget_show_all (x
->menubar_widget
);
3295 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3297 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3299 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3300 xg_height_or_width_changed (f
);
3305 /* Get rid of the menu bar of frame F, and free its storage.
3306 This is used when deleting a frame, and when turning off the menu bar. */
3309 free_frame_menubar (struct frame
*f
)
3311 struct x_output
*x
= f
->output_data
.x
;
3313 if (x
->menubar_widget
)
3317 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3318 /* The menubar and its children shall be deleted when removed from
3320 x
->menubar_widget
= 0;
3321 FRAME_MENUBAR_HEIGHT (f
) = 0;
3322 xg_height_or_width_changed (f
);
3328 xg_event_is_for_menubar (struct frame
*f
, const XEvent
*event
)
3330 struct x_output
*x
= f
->output_data
.x
;
3339 if (! x
->menubar_widget
) return 0;
3341 if (! (event
->xbutton
.x
>= 0
3342 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3343 && event
->xbutton
.y
>= 0
3344 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3345 && event
->xbutton
.same_screen
))
3348 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3349 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3351 gevent
.any
.window
= gw
;
3352 gevent
.any
.type
= GDK_NOTHING
;
3353 gwdesc
= gtk_get_event_widget (&gevent
);
3354 if (! gwdesc
) return 0;
3355 if (! GTK_IS_MENU_BAR (gwdesc
)
3356 && ! GTK_IS_MENU_ITEM (gwdesc
)
3357 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3360 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3361 if (! list
) return 0;
3362 rec
.x
= event
->xbutton
.x
;
3363 rec
.y
= event
->xbutton
.y
;
3367 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3369 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3370 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3379 /***********************************************************************
3380 Scroll bar functions
3381 ***********************************************************************/
3384 /* Setting scroll bar values invokes the callback. Use this variable
3385 to indicate that callback should do nothing. */
3387 bool xg_ignore_gtk_scrollbar
;
3389 /* The width of the scroll bar for the current theme. */
3391 static int scroll_bar_width_for_theme
;
3393 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3394 may be larger than 32 bits. Keep a mapping from integer index to widget
3395 pointers to get around the 32 bit limitation. */
3399 GtkWidget
**widgets
;
3404 /* Grow this much every time we need to allocate more */
3406 #define ID_TO_WIDGET_INCR 32
3408 /* Store the widget pointer W in id_to_widget and return the integer index. */
3411 xg_store_widget_in_map (GtkWidget
*w
)
3415 if (id_to_widget
.max_size
== id_to_widget
.used
)
3418 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3419 memory_full (SIZE_MAX
);
3421 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3422 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3423 new_size
, sizeof (GtkWidget
*));
3425 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3426 id_to_widget
.widgets
[i
] = 0;
3427 id_to_widget
.max_size
= new_size
;
3430 /* Just loop over the array and find a free place. After all,
3431 how many scroll bars are we creating? Should be a small number.
3432 The check above guarantees we will find a free place. */
3433 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3435 if (! id_to_widget
.widgets
[i
])
3437 id_to_widget
.widgets
[i
] = w
;
3438 ++id_to_widget
.used
;
3444 /* Should never end up here */
3448 /* Remove pointer at IDX from id_to_widget.
3449 Called when scroll bar is destroyed. */
3452 xg_remove_widget_from_map (ptrdiff_t idx
)
3454 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3456 id_to_widget
.widgets
[idx
] = 0;
3457 --id_to_widget
.used
;
3461 /* Get the widget pointer at IDX from id_to_widget. */
3464 xg_get_widget_from_map (ptrdiff_t idx
)
3466 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3467 return id_to_widget
.widgets
[idx
];
3473 update_theme_scrollbar_width (void)
3476 GtkAdjustment
*vadj
;
3483 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3484 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3485 g_object_ref_sink (G_OBJECT (wscroll
));
3486 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3487 gtk_widget_destroy (wscroll
);
3488 g_object_unref (G_OBJECT (wscroll
));
3491 scroll_bar_width_for_theme
= w
;
3495 xg_get_default_scrollbar_width (void)
3497 return scroll_bar_width_for_theme
;
3500 /* Return the scrollbar id for X Window WID on display DPY.
3501 Return -1 if WID not in id_to_widget. */
3504 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3509 w
= xg_win_to_widget (dpy
, wid
);
3513 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3514 if (id_to_widget
.widgets
[idx
] == w
)
3521 /* Callback invoked when scroll bar WIDGET is destroyed.
3522 DATA is the index into id_to_widget for WIDGET.
3523 We free pointer to last scroll bar values here and remove the index. */
3526 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3528 intptr_t id
= (intptr_t) data
;
3529 xg_remove_widget_from_map (id
);
3532 /* Create a scroll bar widget for frame F. Store the scroll bar
3534 SCROLL_CALLBACK is the callback to invoke when the value of the
3536 END_CALLBACK is the callback to invoke when scrolling ends.
3537 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3538 to set resources for the widget. */
3541 xg_create_scroll_bar (struct frame
*f
,
3542 struct scroll_bar
*bar
,
3543 GCallback scroll_callback
,
3544 GCallback end_callback
,
3545 const char *scroll_bar_name
)
3551 GtkAdjustment
*vadj
;
3556 /* Page, step increment values are not so important here, they
3557 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3558 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3561 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3562 webox
= gtk_event_box_new ();
3563 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3565 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3567 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3569 scroll_id
= xg_store_widget_in_map (wscroll
);
3571 g_signal_connect (G_OBJECT (wscroll
),
3573 G_CALLBACK (xg_gtk_scroll_destroy
),
3574 (gpointer
) scroll_id
);
3575 g_signal_connect (G_OBJECT (wscroll
),
3579 g_signal_connect (G_OBJECT (wscroll
),
3580 "button-release-event",
3584 /* The scroll bar widget does not draw on a window of its own. Instead
3585 it draws on the parent window, in this case the edit widget. So
3586 whenever the edit widget is cleared, the scroll bar needs to redraw
3587 also, which causes flicker. Put an event box between the edit widget
3588 and the scroll bar, so the scroll bar instead draws itself on the
3589 event box window. */
3590 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3591 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3594 /* Set the cursor to an arrow. */
3595 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3597 bar
->x_window
= scroll_id
;
3600 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3603 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3605 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3608 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3609 gtk_widget_destroy (w
);
3610 gtk_widget_destroy (wparent
);
3611 SET_FRAME_GARBAGED (f
);
3615 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3617 TOP/LEFT are the new pixel positions where the bar shall appear.
3618 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3621 xg_update_scrollbar_pos (struct frame
*f
,
3622 ptrdiff_t scrollbar_id
,
3629 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3633 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3634 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3637 /* Clear out old position. */
3638 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3639 if (gtk_widget_get_parent (wparent
) == wfixed
)
3641 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3642 "x", &oldx
, "y", &oldy
, NULL
);
3643 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3646 /* Move and resize to new values. */
3647 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3648 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3651 /* No room. Hide scroll bar as some themes output a warning if
3652 the height is less than the min size. */
3653 gtk_widget_hide (wparent
);
3654 gtk_widget_hide (wscroll
);
3658 gtk_widget_show_all (wparent
);
3659 gtk_widget_set_size_request (wscroll
, width
, height
);
3661 gtk_widget_queue_draw (wfixed
);
3662 gdk_window_process_all_updates ();
3663 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3664 /* Clear under old scroll bar position. This must be done after
3665 the gtk_widget_queue_draw and gdk_window_process_all_updates
3667 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3668 oldx
, oldy
, oldw
, oldh
);
3670 /* GTK does not redraw until the main loop is entered again, but
3671 if there are no X events pending we will not enter it. So we sync
3672 here to get some events. */
3675 SET_FRAME_GARBAGED (f
);
3676 cancel_mouse_face (f
);
3680 /* Get the current value of the range, truncated to an integer. */
3683 int_gtk_range_get_value (GtkRange
*range
)
3685 return gtk_range_get_value (range
);
3689 /* Set the thumb size and position of scroll bar BAR. We are currently
3690 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3693 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3698 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3700 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3702 if (wscroll
&& bar
->dragging
== -1)
3712 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3714 if (scroll_bar_adjust_thumb_portion_p
)
3716 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3717 line rather than the real portion value. This makes the
3718 thumb less likely to resize and that looks better. */
3719 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3721 /* When the thumb is at the bottom, position == whole.
3722 So we need to increase `whole' to make space for the thumb. */
3730 top
= (gdouble
) position
/ whole
;
3731 shown
= (gdouble
) portion
/ whole
;
3734 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
3735 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
3737 /* Assume all lines are of equal size. */
3738 new_step
= size
/ max (1, FRAME_LINES (f
));
3740 old_size
= gtk_adjustment_get_page_size (adj
);
3741 if (old_size
!= size
)
3743 int old_step
= gtk_adjustment_get_step_increment (adj
);
3744 if (old_step
!= new_step
)
3746 gtk_adjustment_set_page_size (adj
, size
);
3747 gtk_adjustment_set_step_increment (adj
, new_step
);
3748 /* Assume a page increment is about 95% of the page size */
3749 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3754 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3758 /* gtk_range_set_value invokes the callback. Set
3759 ignore_gtk_scrollbar to make the callback do nothing */
3760 xg_ignore_gtk_scrollbar
= 1;
3762 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3763 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3765 gtk_adjustment_changed (adj
);
3767 xg_ignore_gtk_scrollbar
= 0;
3774 /* Return true if EVENT is for a scroll bar in frame F.
3775 When the same X window is used for several Gtk+ widgets, we cannot
3776 say for sure based on the X window alone if an event is for the
3777 frame. This function does additional checks. */
3780 xg_event_is_for_scrollbar (struct frame
*f
, const XEvent
*event
)
3784 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3786 /* Check if press occurred outside the edit widget. */
3787 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3790 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
3791 (gdk_display_get_device_manager (gdpy
));
3792 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
3794 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
3796 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3799 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3800 || event
->type
== MotionNotify
))
3802 /* If we are releasing or moving the scroll bar, it has the grab. */
3803 GtkWidget
*w
= gtk_grab_get_current ();
3804 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3812 /***********************************************************************
3814 ***********************************************************************/
3815 /* The key for the data we put in the GtkImage widgets. The data is
3816 the image used by Emacs. We use this to see if we need to update
3817 the GtkImage with a new image. */
3818 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3820 /* The key for storing the latest modifiers so the activate callback can
3822 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3824 /* The key for storing the button widget in its proxy menu item. */
3825 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3827 /* The key for the data we put in the GtkImage widgets. The data is
3828 the stock name used by Emacs. We use this to see if we need to update
3829 the GtkImage with a new image. */
3830 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3832 /* As above, but this is used for named theme widgets, as opposed to
3834 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3836 /* Callback function invoked when a tool bar item is pressed.
3837 W is the button widget in the tool bar that got pressed,
3838 CLIENT_DATA is an integer that is the index of the button in the
3839 tool bar. 0 is the first button. */
3842 xg_tool_bar_button_cb (GtkWidget
*widget
,
3843 GdkEventButton
*event
,
3846 intptr_t state
= event
->state
;
3847 gpointer ptr
= (gpointer
) state
;
3848 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3853 /* Callback function invoked when a tool bar item is pressed.
3854 W is the button widget in the tool bar that got pressed,
3855 CLIENT_DATA is an integer that is the index of the button in the
3856 tool bar. 0 is the first button. */
3859 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3861 intptr_t idx
= (intptr_t) client_data
;
3862 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3863 intptr_t mod
= (intptr_t) gmod
;
3865 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3866 Lisp_Object key
, frame
;
3867 struct input_event event
;
3870 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3873 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3875 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3876 XSETFRAME (frame
, f
);
3878 /* We generate two events here. The first one is to set the prefix
3879 to `(tool_bar)', see keyboard.c. */
3880 event
.kind
= TOOL_BAR_EVENT
;
3881 event
.frame_or_window
= frame
;
3883 kbd_buffer_store_event (&event
);
3885 event
.kind
= TOOL_BAR_EVENT
;
3886 event
.frame_or_window
= frame
;
3888 /* Convert between the modifier bits GDK uses and the modifier bits
3889 Emacs uses. This assumes GDK and X masks are the same, which they are when
3891 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), mod
);
3892 kbd_buffer_store_event (&event
);
3894 /* Return focus to the frame after we have clicked on a detached
3899 /* Callback function invoked when a tool bar item is pressed in a detached
3900 tool bar or the overflow drop down menu.
3901 We just call xg_tool_bar_callback.
3902 W is the menu item widget that got pressed,
3903 CLIENT_DATA is an integer that is the index of the button in the
3904 tool bar. 0 is the first button. */
3907 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3909 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3910 XG_TOOL_BAR_PROXY_BUTTON
));
3911 xg_tool_bar_callback (wbutton
, client_data
);
3916 xg_tool_bar_help_callback (GtkWidget
*w
,
3917 GdkEventCrossing
*event
,
3918 gpointer client_data
);
3920 /* This callback is called when a help is to be shown for an item in
3921 the detached tool bar when the detached tool bar it is not expanded. */
3924 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3925 GdkEventCrossing
*event
,
3926 gpointer client_data
)
3928 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3929 XG_TOOL_BAR_PROXY_BUTTON
));
3931 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3935 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3937 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3938 GtkWidget
*c1
= clist
->data
;
3939 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
3941 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3942 g_list_free (clist
);
3943 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3947 /* This callback is called when a tool item should create a proxy item,
3948 such as for the overflow menu. Also called when the tool bar is detached.
3949 If we don't create a proxy menu item, the detached tool bar will be
3953 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3955 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
3956 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
3958 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3959 GtkImage
*wimage
= GTK_IMAGE (c1
);
3960 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3961 (wlbl
? gtk_label_get_text (wlbl
) : "");
3962 GtkWidget
*wmenuimage
;
3965 if (gtk_button_get_use_stock (wbutton
))
3966 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3967 GTK_ICON_SIZE_MENU
);
3970 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3971 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3973 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
3975 if (store_type
== GTK_IMAGE_STOCK
)
3978 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3979 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3981 else if (store_type
== GTK_IMAGE_ICON_SET
)
3983 GtkIconSet
*icon_set
;
3984 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3985 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3986 GTK_ICON_SIZE_MENU
);
3988 else if (store_type
== GTK_IMAGE_PIXBUF
)
3993 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3996 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3998 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3999 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
4000 GDK_INTERP_BILINEAR
);
4002 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
4006 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
4010 else if (store_type
== GTK_IMAGE_ICON_NAME
)
4012 const gchar
*icon_name
;
4013 GtkIconSize icon_size
;
4015 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
4016 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
4017 GTK_ICON_SIZE_MENU
);
4021 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
4026 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
4028 g_signal_connect (G_OBJECT (wmenuitem
),
4030 G_CALLBACK (xg_tool_bar_proxy_callback
),
4034 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
4035 (gpointer
) wbutton
);
4036 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
4037 gtk_widget_set_sensitive (wmenuitem
,
4038 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
4040 /* Use enter/leave notify to show help. We use the events
4041 rather than the GtkButton specific signals "enter" and
4042 "leave", so we can have only one callback. The event
4043 will tell us what kind of event it is. */
4044 g_signal_connect (G_OBJECT (wmenuitem
),
4045 "enter-notify-event",
4046 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4048 g_signal_connect (G_OBJECT (wmenuitem
),
4049 "leave-notify-event",
4050 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4056 /* This callback is called when a tool bar is detached. We must set
4057 the height of the tool bar to zero when this happens so frame sizes
4058 are correctly calculated.
4059 WBOX is the handle box widget that enables detach/attach of the tool bar.
4060 W is the tool bar widget.
4061 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4064 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
4066 gpointer client_data
)
4068 struct frame
*f
= client_data
;
4070 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
4075 GtkRequisition req
, req2
;
4077 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4078 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4079 req
.width
-= req2
.width
;
4080 req
.height
-= req2
.height
;
4081 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4082 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4083 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4084 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4085 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4086 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4087 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4088 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4089 xg_height_or_width_changed (f
);
4093 /* This callback is called when a tool bar is reattached. We must set
4094 the height of the tool bar when this happens so frame sizes
4095 are correctly calculated.
4096 WBOX is the handle box widget that enables detach/attach of the tool bar.
4097 W is the tool bar widget.
4098 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4101 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
4103 gpointer client_data
)
4105 struct frame
*f
= client_data
;
4106 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4110 GtkRequisition req
, req2
;
4112 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4113 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4114 req
.width
+= req2
.width
;
4115 req
.height
+= req2
.height
;
4116 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4117 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4118 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4119 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4120 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4121 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4122 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4123 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4124 xg_height_or_width_changed (f
);
4128 /* This callback is called when the mouse enters or leaves a tool bar item.
4129 It is used for displaying and hiding the help text.
4130 W is the tool bar item, a button.
4131 EVENT is either an enter event or leave event.
4132 CLIENT_DATA is an integer that is the index of the button in the
4133 tool bar. 0 is the first button.
4135 Returns FALSE to tell GTK to keep processing this event. */
4138 xg_tool_bar_help_callback (GtkWidget
*w
,
4139 GdkEventCrossing
*event
,
4140 gpointer client_data
)
4142 intptr_t idx
= (intptr_t) client_data
;
4143 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4144 Lisp_Object help
, frame
;
4146 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4149 if (event
->type
== GDK_ENTER_NOTIFY
)
4151 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4152 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4155 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4160 XSETFRAME (frame
, f
);
4161 kbd_buffer_store_help_event (frame
, help
);
4167 /* This callback is called when a tool bar item shall be redrawn.
4168 It modifies the expose event so that the GtkImage widget redraws the
4169 whole image. This to overcome a bug that makes GtkImage draw the image
4170 in the wrong place when it tries to redraw just a part of the image.
4171 W is the GtkImage to be redrawn.
4172 EVENT is the expose event for W.
4173 CLIENT_DATA is unused.
4175 Returns FALSE to tell GTK to keep processing this event. */
4179 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4180 GdkEventExpose
*event
,
4181 gpointer client_data
)
4185 gdk_drawable_get_size (event
->window
, &width
, &height
);
4186 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4187 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4189 event
->area
.x
= max (0, event
->area
.x
);
4190 event
->area
.y
= max (0, event
->area
.y
);
4192 event
->area
.width
= max (width
, event
->area
.width
);
4193 event
->area
.height
= max (height
, event
->area
.height
);
4199 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4200 #define toolbar_set_orientation(w, o) \
4201 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4203 #define toolbar_set_orientation(w, o) \
4204 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4207 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4208 #define TOOLBAR_TOP_WIDGET(x) ((x)->handlebox_widget)
4210 #define TOOLBAR_TOP_WIDGET(x) ((x)->toolbar_widget)
4213 /* Attach a tool bar to frame F. */
4216 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4218 struct x_output
*x
= f
->output_data
.x
;
4219 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4220 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4222 toolbar_set_orientation (x
->toolbar_widget
,
4224 ? GTK_ORIENTATION_VERTICAL
4225 : GTK_ORIENTATION_HORIZONTAL
);
4226 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4227 if (!x
->handlebox_widget
)
4229 top_widget
= x
->handlebox_widget
= gtk_handle_box_new ();
4230 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4231 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4232 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4233 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4234 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4241 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4242 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4245 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4248 if (EQ (pos
, Qleft
))
4249 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4252 x
->toolbar_in_hbox
= true;
4256 bool vbox_pos
= x
->menubar_widget
!= 0;
4257 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4258 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4261 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4265 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4268 x
->toolbar_in_hbox
= false;
4270 x
->toolbar_is_packed
= true;
4273 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4276 tb_size_cb (GtkWidget
*widget
,
4277 GdkRectangle
*allocation
,
4280 /* When tool bar is created it has one preferred size. But when size is
4281 allocated between widgets, it may get another. So we must update
4282 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4283 struct frame
*f
= user_data
;
4284 if (xg_update_tool_bar_sizes (f
))
4285 xg_height_or_width_changed (f
);
4288 /* Create a tool bar for frame F. */
4291 xg_create_tool_bar (struct frame
*f
)
4293 struct x_output
*x
= f
->output_data
.x
;
4294 #if GTK_CHECK_VERSION (3, 3, 6)
4295 GtkStyleContext
*gsty
;
4297 struct xg_frame_tb_info
*tbinfo
4298 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4302 tbinfo
= xmalloc (sizeof (*tbinfo
));
4303 tbinfo
->last_tool_bar
= Qnil
;
4304 tbinfo
->style
= Qnil
;
4305 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4306 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4307 tbinfo
->n_last_items
= 0;
4308 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4313 x
->toolbar_widget
= gtk_toolbar_new ();
4315 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4317 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4318 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4319 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4320 G_CALLBACK (tb_size_cb
), f
);
4321 #if GTK_CHECK_VERSION (3, 3, 6)
4322 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4323 gtk_style_context_add_class (gsty
, "primary-toolbar");
4328 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4330 /* Find the right-to-left image named by RTL in the tool bar images for F.
4331 Returns IMAGE if RTL is not found. */
4334 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4337 Lisp_Object file
, rtl_name
;
4338 struct gcpro gcpro1
, gcpro2
;
4339 GCPRO2 (file
, rtl_name
);
4341 rtl_name
= Ffile_name_nondirectory (rtl
);
4343 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4345 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4346 if (!NILP (file
= file_for_image (rtl_image
)))
4348 file
= call1 (intern ("file-name-sans-extension"),
4349 Ffile_name_nondirectory (file
));
4350 if (! NILP (Fequal (file
, rtl_name
)))
4361 static GtkToolItem
*
4362 xg_make_tool_item (struct frame
*f
,
4364 GtkWidget
**wbutton
,
4366 int i
, bool horiz
, bool text_image
)
4368 GtkToolItem
*ti
= gtk_tool_item_new ();
4369 GtkWidget
*vb
= gtk_box_new (horiz
4370 ? GTK_ORIENTATION_HORIZONTAL
4371 : GTK_ORIENTATION_VERTICAL
,
4373 GtkWidget
*wb
= gtk_button_new ();
4374 /* The eventbox is here so we can have tooltips on disabled items. */
4375 GtkWidget
*weventbox
= gtk_event_box_new ();
4376 #if GTK_CHECK_VERSION (3, 3, 6)
4377 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4378 GtkStyleContext
*gsty
;
4380 gtk_css_provider_load_from_data (css_prov
,
4382 " background-color: transparent;"
4386 gsty
= gtk_widget_get_style_context (weventbox
);
4387 gtk_style_context_add_provider (gsty
,
4388 GTK_STYLE_PROVIDER (css_prov
),
4389 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4390 g_object_unref (css_prov
);
4393 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4395 if (wimage
&& !text_image
)
4396 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4398 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4399 if (wimage
&& text_image
)
4400 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4402 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4403 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4404 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4405 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4406 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4408 if (wimage
|| label
)
4411 gpointer gi
= (gpointer
) ii
;
4413 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4414 G_CALLBACK (xg_tool_bar_menu_proxy
),
4417 g_signal_connect (G_OBJECT (wb
), "clicked",
4418 G_CALLBACK (xg_tool_bar_callback
),
4421 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4424 /* Catch expose events to overcome an annoying redraw bug, see
4425 comment for xg_tool_bar_item_expose_callback. */
4426 g_signal_connect (G_OBJECT (ti
),
4428 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4431 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4433 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4434 no distinction based on modifiers in the activate callback,
4435 so we have to do it ourselves. */
4436 g_signal_connect (wb
, "button-release-event",
4437 G_CALLBACK (xg_tool_bar_button_cb
),
4440 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4442 /* Use enter/leave notify to show help. We use the events
4443 rather than the GtkButton specific signals "enter" and
4444 "leave", so we can have only one callback. The event
4445 will tell us what kind of event it is. */
4446 g_signal_connect (G_OBJECT (weventbox
),
4447 "enter-notify-event",
4448 G_CALLBACK (xg_tool_bar_help_callback
),
4450 g_signal_connect (G_OBJECT (weventbox
),
4451 "leave-notify-event",
4452 G_CALLBACK (xg_tool_bar_help_callback
),
4456 if (wbutton
) *wbutton
= wb
;
4462 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4466 if (GTK_IS_BOX (vb
))
4468 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4469 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4470 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4474 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4480 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4481 const char *icon_name
, const struct image
*img
,
4482 const char *label
, bool horiz
)
4486 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4487 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4489 /* Check if the tool icon matches. */
4490 if (stock_name
&& wimage
)
4492 old
= g_object_get_data (G_OBJECT (wimage
),
4493 XG_TOOL_BAR_STOCK_NAME
);
4494 if (!old
|| strcmp (old
, stock_name
))
4497 else if (icon_name
&& wimage
)
4499 old
= g_object_get_data (G_OBJECT (wimage
),
4500 XG_TOOL_BAR_ICON_NAME
);
4501 if (!old
|| strcmp (old
, icon_name
))
4506 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4507 XG_TOOL_BAR_IMAGE_DATA
);
4508 Pixmap old_img
= (Pixmap
) gold_img
;
4509 if (old_img
!= img
->pixmap
)
4513 /* Check button configuration and label. */
4514 if (is_box_type (vb
, horiz
)
4515 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4518 /* Ensure label is correct. */
4520 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4525 xg_update_tool_bar_sizes (struct frame
*f
)
4527 struct x_output
*x
= f
->output_data
.x
;
4529 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4530 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4532 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4533 if (x
->toolbar_in_hbox
)
4536 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4538 "position", &pos
, NULL
);
4539 if (pos
== 0) nl
= req
.width
;
4540 else nr
= req
.width
;
4545 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4547 "position", &pos
, NULL
);
4548 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4549 else nb
= req
.height
;
4552 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4553 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4554 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4555 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4557 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4558 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4559 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4560 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4561 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4562 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4570 /* Update the tool bar for frame F. Add new buttons and remove old. */
4573 update_frame_tool_bar (struct frame
*f
)
4576 struct x_output
*x
= f
->output_data
.x
;
4577 int hmargin
= 0, vmargin
= 0;
4578 GtkToolbar
*wtoolbar
;
4580 GtkTextDirection dir
;
4582 bool text_image
, horiz
;
4583 struct xg_frame_tb_info
*tbinfo
;
4585 if (! FRAME_GTK_WIDGET (f
))
4590 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4592 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4593 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4595 else if (CONSP (Vtool_bar_button_margin
))
4597 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4598 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4600 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4601 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4604 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4605 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4606 i.e. zero. This means that margins less than
4607 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4608 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4609 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4611 if (! x
->toolbar_widget
)
4612 xg_create_tool_bar (f
);
4614 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4615 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4617 style
= Ftool_bar_get_system_style ();
4619 /* Are we up to date? */
4620 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4623 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4624 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4625 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4626 && tbinfo
->dir
== dir
4627 && ! NILP (Fequal (tbinfo
->style
, style
))
4628 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4634 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4635 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4636 tbinfo
->style
= style
;
4637 tbinfo
->hmargin
= hmargin
;
4638 tbinfo
->vmargin
= vmargin
;
4641 text_image
= EQ (style
, Qtext_image_horiz
);
4642 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4644 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4646 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4647 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4651 struct image
*img
= NULL
;
4653 Lisp_Object stock
= Qnil
;
4654 GtkStockItem stock_item
;
4655 char *stock_name
= NULL
;
4656 char *icon_name
= NULL
;
4658 GtkWidget
*wbutton
= NULL
;
4659 Lisp_Object specified_file
;
4660 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4662 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4663 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4664 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4667 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4669 /* If this is a separator, use a gtk separator item. */
4670 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4672 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4675 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4677 ti
= gtk_separator_tool_item_new ();
4678 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4684 /* Otherwise, the tool-bar item is an ordinary button. */
4686 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4688 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4692 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4694 /* Ignore invalid image specifications. */
4695 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4696 if (!valid_image_p (image
))
4699 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4704 specified_file
= file_for_image (image
);
4705 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4706 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4708 if (STRINGP (stock
))
4710 stock_name
= SSDATA (stock
);
4711 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4713 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4714 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4716 icon_name
= stock_name
+ 2;
4720 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4723 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4725 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4726 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4734 if (stock_name
== NULL
&& icon_name
== NULL
)
4736 /* No stock image, or stock item not known. Try regular
4737 image. If image is a vector, choose it according to the
4739 if (dir
== GTK_TEXT_DIR_RTL
4740 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4742 image
= find_rtl_image (f
, image
, rtl
);
4744 if (VECTORP (image
))
4748 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4749 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4752 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4753 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4755 eassert (ASIZE (image
) >= idx
);
4756 image
= AREF (image
, idx
);
4761 img_id
= lookup_image (f
, image
);
4762 img
= IMAGE_FROM_ID (f
, img_id
);
4763 prepare_image_for_display (f
, img
);
4765 if (img
->load_failed_p
|| img
->pixmap
== None
)
4768 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4774 /* If there is an existing widget, check if it's stale; if so,
4775 remove it and make a new tool item from scratch. */
4776 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4779 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4788 /* Save the image so we can see if an update is needed the
4789 next time we call xg_tool_item_match_p. */
4790 if (EQ (style
, Qtext
))
4792 else if (stock_name
)
4794 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4795 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4796 (gpointer
) g_strdup (stock_name
),
4797 (GDestroyNotify
) g_free
);
4801 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4802 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4803 (gpointer
) g_strdup (icon_name
),
4804 (GDestroyNotify
) g_free
);
4808 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4809 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4810 (gpointer
)img
->pixmap
);
4813 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4814 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4815 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4820 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4824 /* Remove buttons not longer needed. */
4827 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4829 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4830 } while (ti
!= NULL
);
4832 if (f
->n_tool_bar_items
!= 0)
4834 if (! x
->toolbar_is_packed
)
4835 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4836 gtk_widget_show_all (TOOLBAR_TOP_WIDGET (x
));
4837 if (xg_update_tool_bar_sizes (f
))
4838 xg_height_or_width_changed (f
);
4844 /* Deallocate all resources for the tool bar on frame F.
4845 Remove the tool bar. */
4848 free_frame_tool_bar (struct frame
*f
)
4850 struct x_output
*x
= f
->output_data
.x
;
4852 if (x
->toolbar_widget
)
4854 struct xg_frame_tb_info
*tbinfo
;
4855 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4858 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4859 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4860 if (x
->toolbar_is_packed
)
4862 if (x
->toolbar_in_hbox
)
4863 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4866 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4870 gtk_widget_destroy (x
->toolbar_widget
);
4872 x
->toolbar_widget
= 0;
4873 TOOLBAR_TOP_WIDGET (x
) = 0;
4874 x
->toolbar_is_packed
= false;
4875 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4876 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4878 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4883 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4888 xg_height_or_width_changed (f
);
4895 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
4897 struct x_output
*x
= f
->output_data
.x
;
4898 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4900 if (! x
->toolbar_widget
|| ! top_widget
)
4904 g_object_ref (top_widget
);
4905 if (x
->toolbar_is_packed
)
4907 if (x
->toolbar_in_hbox
)
4908 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4911 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4915 xg_pack_tool_bar (f
, pos
);
4916 g_object_unref (top_widget
);
4917 if (xg_update_tool_bar_sizes (f
))
4918 xg_height_or_width_changed (f
);
4925 /***********************************************************************
4927 ***********************************************************************/
4929 xg_initialize (void)
4931 GtkBindingSet
*binding_set
;
4932 GtkSettings
*settings
;
4935 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4936 we keep it permanently linked in. */
4941 xg_ignore_gtk_scrollbar
= 0;
4942 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
4943 xg_detached_menus
= 0;
4945 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4946 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4948 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4949 id_to_widget
.widgets
= 0;
4951 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
4952 (gdk_display_get_default ()));
4953 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4954 bindings. It doesn't seem to be any way to remove properties,
4955 so we set it to "" which in means "no key". */
4956 gtk_settings_set_string_property (settings
,
4957 "gtk-menu-bar-accel",
4961 /* Make GTK text input widgets use Emacs style keybindings. This is
4963 gtk_settings_set_string_property (settings
,
4964 "gtk-key-theme-name",
4968 /* Make dialogs close on C-g. Since file dialog inherits from
4969 dialog, this works for them also. */
4970 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4971 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4974 /* Make menus close on C-g. */
4975 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4976 (GTK_TYPE_MENU_SHELL
));
4977 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4979 update_theme_scrollbar_width ();
4981 #ifdef HAVE_FREETYPE
4982 x_last_font_name
= NULL
;
4986 #endif /* USE_GTK */