1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2017 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 (at
10 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/>. */
29 #include "dispextern.h"
33 #include "blockinput.h"
36 #include "termhooks.h"
40 #include <gdk/gdkkeysyms.h>
43 #include <X11/Xft/Xft.h>
48 #include "emacsgtkfixed.h"
52 #include <X11/extensions/Xdbe.h>
55 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
56 #define gtk_widget_set_has_window(w, b) \
57 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
59 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
60 #define gtk_dialog_get_action_area(w) ((w)->action_area)
61 #define gtk_dialog_get_content_area(w) ((w)->vbox)
63 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
64 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
66 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
67 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
68 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
69 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
70 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
72 #if GTK_CHECK_VERSION (2, 12, 0)
73 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
75 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
78 #if ! GTK_CHECK_VERSION (2, 14, 0)
79 #define gtk_adjustment_configure(adj, xvalue, xlower, \
80 xupper, xstep_increment, \
81 xpage_increment, xpagesize) \
83 adj->lower = xlower; \
84 adj->upper = xupper; \
85 adj->page_size = xpagesize; \
86 gtk_adjustment_set_value (adj, xvalue); \
87 adj->page_increment = xpage_increment; \
88 adj->step_increment = xstep_increment; \
90 #endif /* < Gtk+ 2.14 */
93 #if GTK_CHECK_VERSION (3, 2, 0)
94 #define USE_NEW_GTK_FONT_CHOOSER 1
96 #define USE_NEW_GTK_FONT_CHOOSER 0
97 #define gtk_font_chooser_dialog_new(x, y) \
98 gtk_font_selection_dialog_new (x)
99 #undef GTK_FONT_CHOOSER
100 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
101 #define gtk_font_chooser_set_font(x, y) \
102 gtk_font_selection_dialog_set_font_name (x, y)
104 #endif /* HAVE_FREETYPE */
106 #if GTK_CHECK_VERSION (3, 10, 0)
107 #define XG_TEXT_CANCEL "Cancel"
108 #define XG_TEXT_OK "OK"
109 #define XG_TEXT_OPEN "Open"
111 #define XG_TEXT_CANCEL GTK_STOCK_CANCEL
112 #define XG_TEXT_OK GTK_STOCK_OK
113 #define XG_TEXT_OPEN GTK_STOCK_OPEN
117 #ifdef USE_GTK_TOOLTIP
118 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
120 #define gdk_window_get_geometry(w, a, b, c, d) \
121 gdk_window_get_geometry (w, a, b, c, d, 0)
122 #define gdk_x11_window_lookup_for_display(d, w) \
123 gdk_xid_table_lookup_for_display (d, w)
124 #define gtk_box_new(ori, spacing) \
125 ((ori) == GTK_ORIENTATION_HORIZONTAL \
126 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
127 #define gtk_scrollbar_new(ori, spacing) \
128 ((ori) == GTK_ORIENTATION_HORIZONTAL \
129 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
131 #define GDK_KEY_g GDK_g
133 #endif /* HAVE_GTK3 */
135 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
137 static void update_theme_scrollbar_width (void);
138 static void update_theme_scrollbar_height (void);
140 #define TB_INFO_KEY "xg_frame_tb_info"
141 struct xg_frame_tb_info
143 Lisp_Object last_tool_bar
;
146 int hmargin
, vmargin
;
147 GtkTextDirection dir
;
150 static GtkWidget
* xg_get_widget_from_map (ptrdiff_t idx
);
153 /***********************************************************************
154 Display handling functions
155 ***********************************************************************/
157 /* Keep track of the default display, or NULL if there is none. Emacs
158 may close all its displays. */
160 static GdkDisplay
*gdpy_def
;
162 /* When the GTK widget W is to be created on a display for F that
163 is not the default display, set the display for W.
164 W can be a GtkMenu or a GtkWindow widget. */
167 xg_set_screen (GtkWidget
*w
, struct frame
*f
)
169 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
171 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
172 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
175 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
177 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
182 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
183 *DPY is set to NULL if the display can't be opened.
185 Returns non-zero if display could be opened, zero if display could not
186 be opened, and less than zero if the GTK version doesn't support
187 multiple displays. */
190 xg_display_open (char *display_name
, Display
**dpy
)
194 unrequest_sigio (); /* See comment in x_display_ok, xterm.c. */
195 gdpy
= gdk_display_open (display_name
);
197 if (!gdpy_def
&& gdpy
)
200 gdk_display_manager_set_default_display (gdk_display_manager_get (),
204 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
208 /* Close display DPY. */
211 xg_display_close (Display
*dpy
)
213 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
215 /* If this is the default display, try to change it before closing.
216 If there is no other display to use, gdpy_def is set to NULL, and
217 the next call to xg_display_open resets the default display. */
218 if (gdk_display_get_default () == gdpy
)
220 struct x_display_info
*dpyinfo
;
221 GdkDisplay
*gdpy_new
= NULL
;
223 /* Find another display. */
224 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
225 if (dpyinfo
->display
!= dpy
)
227 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
228 gdk_display_manager_set_default_display (gdk_display_manager_get (),
235 #if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
236 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
237 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
238 can continue running, but there will be memory leaks. */
239 g_object_run_dispose (G_OBJECT (gdpy
));
241 /* This seems to be fixed in GTK 2.10. */
242 gdk_display_close (gdpy
);
247 /***********************************************************************
249 ***********************************************************************/
251 /* Create and return the cursor to be used for popup menus and
252 scroll bars on display DPY. */
255 xg_create_default_cursor (Display
*dpy
)
257 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
258 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
261 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
264 xg_get_pixbuf_from_pix_and_mask (struct frame
*f
,
268 GdkPixbuf
*icon_buf
= 0;
271 unsigned int width
, height
, depth
, uunused
;
273 if (FRAME_DISPLAY_INFO (f
)->red_bits
!= 8)
275 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
276 &width
, &height
, &uunused
, &depth
);
279 XImage
*xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
283 XImage
*xmm
= (! mask
? 0
284 : XGetImage (FRAME_X_DISPLAY (f
), mask
, 0, 0,
285 width
, height
, ~0, XYPixmap
));
286 icon_buf
= gdk_pixbuf_new (GDK_COLORSPACE_RGB
, TRUE
, 8, width
, height
);
289 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
290 int rowjunkwidth
= gdk_pixbuf_get_rowstride (icon_buf
) - width
* 4;
291 for (int y
= 0; y
< height
; y
++, pixels
+= rowjunkwidth
)
292 for (int x
= 0; x
< width
; x
++)
294 unsigned long rgb
= XGetPixel (xim
, x
, y
);
295 *pixels
++ = (rgb
>> 16) & 255;
296 *pixels
++ = (rgb
>> 8) & 255;
297 *pixels
++ = rgb
& 255;
298 *pixels
++ = xmm
&& !XGetPixel (xmm
, x
, y
) ? 0 : 255;
311 file_for_image (Lisp_Object image
)
313 Lisp_Object specified_file
= Qnil
;
316 for (tail
= XCDR (image
);
317 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
318 tail
= XCDR (XCDR (tail
)))
319 if (EQ (XCAR (tail
), QCfile
))
320 specified_file
= XCAR (XCDR (tail
));
322 return specified_file
;
325 /* For the image defined in IMG, make and return a GtkImage. For displays with
326 8 planes or less we must make a GdkPixbuf and apply the mask manually.
327 Otherwise the highlighting and dimming the tool bar code in GTK does
328 will look bad. For display with more than 8 planes we just use the
329 pixmap and mask directly. For monochrome displays, GTK doesn't seem
330 able to use external pixmaps, it looks bad whatever we do.
331 The image is defined on the display where frame F is.
332 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
333 If OLD_WIDGET is NULL, a new widget is constructed and returned.
334 If OLD_WIDGET is not NULL, that widget is modified. */
337 xg_get_image_for_pixmap (struct frame
*f
,
340 GtkImage
*old_widget
)
344 /* If we have a file, let GTK do all the image handling.
345 This seems to be the only way to make insensitive and activated icons
346 look good in all cases. */
347 Lisp_Object specified_file
= file_for_image (img
->spec
);
350 /* We already loaded the image once before calling this
351 function, so this only fails if the image file has been removed.
352 In that case, use the pixmap already loaded. */
354 if (STRINGP (specified_file
)
355 && STRINGP (file
= x_find_image_file (specified_file
)))
357 char *encoded_file
= SSDATA (ENCODE_FILE (file
));
359 old_widget
= GTK_IMAGE (gtk_image_new_from_file (encoded_file
));
361 gtk_image_set_from_file (old_widget
, encoded_file
);
363 return GTK_WIDGET (old_widget
);
366 /* No file, do the image handling ourselves. This will look very bad
367 on a monochrome display, and sometimes bad on all displays with
370 /* This is a workaround to make icons look good on pseudo color
371 displays. Apparently GTK expects the images to have an alpha
372 channel. If they don't, insensitive and activated icons will
373 look bad. This workaround does not work on monochrome displays,
374 and is strictly not needed on true color/static color displays (i.e.
375 16 bits and higher). But we do it anyway so we get a pixbuf that is
376 not associated with the img->pixmap. The img->pixmap may be removed
377 by clearing the image cache and then the tool bar redraw fails, since
378 Gtk+ assumes the pixmap is always there. */
379 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
384 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
386 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
388 g_object_unref (G_OBJECT (icon_buf
));
391 return GTK_WIDGET (old_widget
);
395 /* Set CURSOR on W and all widgets W contain. We must do like this
396 for scroll bars and menu because they create widgets internally,
397 and it is those widgets that are visible. */
400 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
402 GdkWindow
*window
= gtk_widget_get_window (w
);
403 GList
*children
= gdk_window_peek_children (window
);
405 gdk_window_set_cursor (window
, cursor
);
407 /* The scroll bar widget has more than one GDK window (had to look at
408 the source to figure this out), and there is no way to set cursor
409 on widgets in GTK. So we must set the cursor for all GDK windows.
412 for ( ; children
; children
= g_list_next (children
))
413 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
416 /* Insert NODE into linked LIST. */
419 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
421 xg_list_node
*list_start
= list
->next
;
423 if (list_start
) list_start
->prev
= node
;
424 node
->next
= list_start
;
429 /* Remove NODE from linked LIST. */
432 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
434 xg_list_node
*list_start
= list
->next
;
435 if (node
== list_start
)
437 list
->next
= node
->next
;
438 if (list
->next
) list
->next
->prev
= 0;
442 node
->prev
->next
= node
->next
;
443 if (node
->next
) node
->next
->prev
= node
->prev
;
447 /* Allocate and return a utf8 version of STR. If STR is already
448 utf8 or NULL, just return a copy of STR.
449 A new string is allocated and the caller must free the result
453 get_utf8_string (const char *str
)
457 if (!str
) return NULL
;
459 /* If not UTF-8, try current locale. */
460 if (!g_utf8_validate (str
, -1, NULL
))
461 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
463 return g_strdup (str
);
467 /* Probably some control characters in str. Escape them. */
469 ptrdiff_t nr_bad
= 0;
472 unsigned char *p
= (unsigned char *)str
;
476 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
477 &bytes_written
, &err
))
478 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
481 p
+= bytes_written
+1;
495 if (INT_MULTIPLY_WRAPV (nr_bad
, 4, &alloc
)
496 || INT_ADD_WRAPV (len
+ 1, alloc
, &alloc
)
498 memory_full (SIZE_MAX
);
499 up
= utf8_str
= xmalloc (alloc
);
500 p
= (unsigned char *)str
;
502 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
503 &bytes_written
, &err
))
504 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
506 memcpy (up
, p
, bytes_written
);
508 up
+= sprintf (up
, "\\%03o", p
[bytes_written
]);
509 p
+= bytes_written
+ 1;
528 /* Check for special colors used in face spec for region face.
529 The colors are fetched from the Gtk+ theme.
530 Return true if color was found, false if not. */
533 xg_check_special_colors (struct frame
*f
,
534 const char *color_name
,
538 bool get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
539 bool get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
541 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
547 GtkStyleContext
*gsty
548 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
550 char buf
[sizeof "rgb://rrrr/gggg/bbbb"];
551 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
553 gtk_style_context_get_color (gsty
, state
, &col
);
555 gtk_style_context_get_background_color (gsty
, state
, &col
);
559 g
= col
.green
* 65535,
560 b
= col
.blue
* 65535;
561 sprintf (buf
, "rgb:%04x/%04x/%04x", r
, g
, b
);
562 success_p
= x_parse_color (f
, buf
, color
) != 0;
564 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
565 GdkColor
*grgb
= get_bg
566 ? &gsty
->bg
[GTK_STATE_SELECTED
]
567 : &gsty
->fg
[GTK_STATE_SELECTED
];
569 color
->red
= grgb
->red
;
570 color
->green
= grgb
->green
;
571 color
->blue
= grgb
->blue
;
572 color
->pixel
= grgb
->pixel
;
583 /***********************************************************************
585 ***********************************************************************/
586 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
587 We use that to pop down the tooltip. This happens if Gtk+ for some
588 reason wants to change or hide the tooltip. */
590 #ifdef USE_GTK_TOOLTIP
593 hierarchy_ch_cb (GtkWidget
*widget
,
594 GtkWidget
*previous_toplevel
,
597 struct frame
*f
= user_data
;
598 struct x_output
*x
= f
->output_data
.x
;
599 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
601 if (! top
|| ! GTK_IS_WINDOW (top
))
602 gtk_widget_hide (previous_toplevel
);
605 /* Callback called when Gtk+ thinks a tooltip should be displayed.
606 We use it to get the tooltip window and the tooltip widget so
607 we can manipulate the ourselves.
609 Return FALSE ensures that the tooltip is not shown. */
612 qttip_cb (GtkWidget
*widget
,
615 gboolean keyboard_mode
,
619 struct frame
*f
= user_data
;
620 struct x_output
*x
= f
->output_data
.x
;
621 if (x
->ttip_widget
== NULL
)
626 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
627 x
->ttip_widget
= tooltip
;
628 g_object_ref (G_OBJECT (tooltip
));
629 x
->ttip_lbl
= gtk_label_new ("");
630 g_object_ref (G_OBJECT (x
->ttip_lbl
));
631 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
632 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
634 /* Change stupid Gtk+ default line wrapping. */
635 p
= gtk_widget_get_parent (x
->ttip_lbl
);
636 list
= gtk_container_get_children (GTK_CONTAINER (p
));
637 for (iter
= list
; iter
; iter
= g_list_next (iter
))
639 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
640 if (GTK_IS_LABEL (w
))
641 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
645 /* ATK needs an empty title for some reason. */
646 gtk_window_set_title (x
->ttip_window
, "");
647 /* Realize so we can safely get screen later on. */
648 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
649 gtk_widget_realize (x
->ttip_lbl
);
651 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
652 G_CALLBACK (hierarchy_ch_cb
), f
);
657 #endif /* USE_GTK_TOOLTIP */
659 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
660 Return true if a system tooltip is available. */
663 xg_prepare_tooltip (struct frame
*f
,
668 #ifndef USE_GTK_TOOLTIP
671 struct x_output
*x
= f
->output_data
.x
;
675 GtkSettings
*settings
;
676 gboolean tt_enabled
= TRUE
;
678 Lisp_Object encoded_string
;
680 if (!x
->ttip_lbl
) return 0;
683 encoded_string
= ENCODE_UTF_8 (string
);
684 widget
= GTK_WIDGET (x
->ttip_lbl
);
685 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
686 screen
= gdk_window_get_screen (gwin
);
687 settings
= gtk_settings_get_for_screen (screen
);
688 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
691 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
692 /* Record that we disabled it so it can be enabled again. */
693 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
697 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
698 g_object_set_data (G_OBJECT
699 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
700 "gdk-display-current-tooltip", NULL
);
702 /* Put our dummy widget in so we can get callbacks for unrealize and
703 hierarchy-changed. */
704 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
705 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
706 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
707 if (width
) *width
= req
.width
;
708 if (height
) *height
= req
.height
;
713 #endif /* USE_GTK_TOOLTIP */
716 /* Show the tooltip at ROOT_X and ROOT_Y.
717 xg_prepare_tooltip must have been called before this function. */
720 xg_show_tooltip (struct frame
*f
, int root_x
, int root_y
)
722 #ifdef USE_GTK_TOOLTIP
723 struct x_output
*x
= f
->output_data
.x
;
727 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
728 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
734 /* Hide tooltip if shown. Do nothing if not shown.
735 Return true if tip was hidden, false if not (i.e. not using
739 xg_hide_tooltip (struct frame
*f
)
742 #ifdef USE_GTK_TOOLTIP
743 if (f
->output_data
.x
->ttip_window
)
745 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
747 gtk_widget_hide (GTK_WIDGET (win
));
749 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
751 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
752 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
753 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
754 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
765 /***********************************************************************
766 General functions for creating widgets, resizing, events, e.t.c.
767 ***********************************************************************/
770 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
771 const gchar
*msg
, gpointer user_data
)
773 if (!strstr (msg
, "visible children"))
774 fprintf (stderr
, "XX %s-WARNING **: %s\n", log_domain
, msg
);
777 /* Make a geometry string and pass that to GTK. It seems this is the
778 only way to get geometry position right if the user explicitly
779 asked for a position when starting Emacs.
780 F is the frame we shall set geometry for. */
783 xg_set_geometry (struct frame
*f
)
785 if (f
->size_hint_flags
& (USPosition
| PPosition
))
787 if (x_gtk_use_window_move
)
789 /* Handle negative positions without consulting
790 gtk_window_parse_geometry (Bug#25851). The position will
791 be off by scrollbar width + window manager decorations. */
792 if (f
->size_hint_flags
& XNegative
)
793 f
->left_pos
= (x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
794 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
);
796 if (f
->size_hint_flags
& YNegative
)
797 f
->top_pos
= (x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
798 - FRAME_PIXEL_HEIGHT (f
) + f
->top_pos
);
800 gtk_window_move (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
801 f
->left_pos
, f
->top_pos
);
803 /* Reset size hint flags. */
804 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
808 int left
= f
->left_pos
;
809 int xneg
= f
->size_hint_flags
& XNegative
;
810 int top
= f
->top_pos
;
811 int yneg
= f
->size_hint_flags
& YNegative
;
812 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
820 sprintf (geom_str
, "=%dx%d%c%d%c%d",
821 FRAME_PIXEL_WIDTH (f
),
822 FRAME_PIXEL_HEIGHT (f
),
823 (xneg
? '-' : '+'), left
,
824 (yneg
? '-' : '+'), top
);
826 /* Silence warning about visible children. */
827 id
= g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
828 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
830 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
832 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
834 g_log_remove_handler ("Gtk", id
);
840 xg_get_gdk_scale (void)
842 const char *sscale
= getenv ("GDK_SCALE");
846 long scale
= atol (sscale
);
848 return min (scale
, INT_MAX
);
854 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
855 and a Gtk+ menu bar, we get resize events for the edit part of the
856 frame only. We let Gtk+ deal with the Gtk+ parts.
857 F is the frame to resize.
858 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
861 xg_frame_resized (struct frame
*f
, int pixelwidth
, int pixelheight
)
865 if (pixelwidth
== -1 && pixelheight
== -1)
867 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
868 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
869 0, 0, &pixelwidth
, &pixelheight
);
874 width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
);
875 height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
);
877 frame_size_history_add
878 (f
, Qxg_frame_resized
, width
, height
, Qnil
);
880 if (width
!= FRAME_TEXT_WIDTH (f
)
881 || height
!= FRAME_TEXT_HEIGHT (f
)
882 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
883 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
885 x_clear_under_internal_border (f
);
886 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
887 SET_FRAME_GARBAGED (f
);
888 cancel_mouse_face (f
);
892 /* Resize the outer window of frame F after changing the height.
893 COLUMNS/ROWS is the size the edit area shall have after the resize. */
896 xg_frame_set_char_size (struct frame
*f
, int width
, int height
)
898 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
899 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
900 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
901 gint gwidth
, gheight
;
903 = pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
) + FRAME_MENUBAR_HEIGHT (f
);
904 int totalwidth
= pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
);
906 if (FRAME_PIXEL_HEIGHT (f
) == 0)
909 gtk_window_get_size (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
912 /* Do this before resize, as we don't know yet if we will be resized. */
913 x_clear_under_internal_border (f
);
915 if (FRAME_VISIBLE_P (f
))
917 int scale
= xg_get_gdk_scale ();
918 totalheight
/= scale
;
922 x_wm_set_size_hint (f
, 0, 0);
924 /* Resize the top level widget so rows and columns remain constant.
926 When the frame is fullheight and we only want to change the width
927 or it is fullwidth and we only want to change the height we should
928 be able to preserve the fullscreen property. However, due to the
929 fact that we have to send a resize request anyway, the window
930 manager will abolish it. At least the respective size should
931 remain unchanged but giving the frame back its normal size will
933 if (EQ (fullscreen
, Qfullwidth
) && width
== FRAME_TEXT_WIDTH (f
))
935 frame_size_history_add
936 (f
, Qxg_frame_set_char_size_1
, width
, height
,
937 list2 (make_number (gheight
), make_number (totalheight
)));
939 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
940 gwidth
, totalheight
);
942 else if (EQ (fullscreen
, Qfullheight
) && height
== FRAME_TEXT_HEIGHT (f
))
944 frame_size_history_add
945 (f
, Qxg_frame_set_char_size_2
, width
, height
,
946 list2 (make_number (gwidth
), make_number (totalwidth
)));
948 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
949 totalwidth
, gheight
);
953 frame_size_history_add
954 (f
, Qxg_frame_set_char_size_3
, width
, height
,
955 list2 (make_number (totalwidth
), make_number (totalheight
)));
957 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
958 totalwidth
, totalheight
);
962 SET_FRAME_GARBAGED (f
);
963 cancel_mouse_face (f
);
965 /* We can not call change_frame_size for a mapped frame,
966 we can not set pixel width/height either. The window manager may
967 override our resize request, XMonad does this all the time.
968 The best we can do is try to sync, so lisp code sees the updated
969 size as fast as possible.
970 For unmapped windows, we can set rows/cols. When
971 the frame is mapped again we will (hopefully) get the correct size. */
972 if (FRAME_VISIBLE_P (f
))
974 /* Must call this to flush out events */
975 (void)gtk_events_pending ();
977 x_wait_for_event (f
, ConfigureNotify
);
979 if (!NILP (fullscreen
))
980 /* Try to restore fullscreen state. */
982 store_frame_param (f
, Qfullscreen
, fullscreen
);
983 x_set_fullscreen (f
, fullscreen
, fullscreen
);
987 adjust_frame_size (f
, width
, height
, 5, 0, Qxg_frame_set_char_size
);
991 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
992 The policy is to keep the number of editable lines. */
996 xg_height_or_width_changed (struct frame
*f
)
998 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
999 FRAME_TOTAL_PIXEL_WIDTH (f
),
1000 FRAME_TOTAL_PIXEL_HEIGHT (f
));
1001 f
->output_data
.x
->hint_flags
= 0;
1002 x_wm_set_size_hint (f
, 0, 0);
1006 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
1007 Must be done like this, because GtkWidget:s can have "hidden"
1008 X Window that aren't accessible.
1010 Return 0 if no widget match WDESC. */
1013 xg_win_to_widget (Display
*dpy
, Window wdesc
)
1016 GtkWidget
*gwdesc
= 0;
1020 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
1025 event
.any
.window
= gdkwin
;
1026 event
.any
.type
= GDK_NOTHING
;
1027 gwdesc
= gtk_get_event_widget (&event
);
1034 /* Set the background of widget W to PIXEL. */
1037 xg_set_widget_bg (struct frame
*f
, GtkWidget
*w
, unsigned long pixel
)
1043 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1045 bg
.red
= (double)xbg
.red
/65535.0;
1046 bg
.green
= (double)xbg
.green
/65535.0;
1047 bg
.blue
= (double)xbg
.blue
/65535.0;
1049 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1053 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1054 gdk_colormap_query_color (map
, pixel
, &bg
);
1055 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1059 /* Callback called when the gtk theme changes.
1060 We notify lisp code so it can fix faces used for region for example. */
1063 style_changed_cb (GObject
*go
,
1067 struct input_event event
;
1068 GdkDisplay
*gdpy
= user_data
;
1069 const char *display_name
= gdk_display_get_name (gdpy
);
1070 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1073 event
.kind
= CONFIG_CHANGED_EVENT
;
1074 event
.frame_or_window
= build_string (display_name
);
1075 /* Theme doesn't change often, so intern is called seldom. */
1076 event
.arg
= intern ("theme-name");
1077 kbd_buffer_store_event (&event
);
1079 update_theme_scrollbar_width ();
1080 update_theme_scrollbar_height ();
1082 /* If scroll bar width changed, we need set the new size on all frames
1086 Lisp_Object rest
, frame
;
1087 FOR_EACH_FRAME (rest
, frame
)
1089 struct frame
*f
= XFRAME (frame
);
1090 if (FRAME_LIVE_P (f
)
1092 && FRAME_X_DISPLAY (f
) == dpy
)
1094 x_set_scroll_bar_default_width (f
);
1095 x_set_scroll_bar_default_height (f
);
1096 xg_frame_set_char_size (f
, FRAME_TEXT_WIDTH (f
), FRAME_TEXT_HEIGHT (f
));
1102 /* Called when a delete-event occurs on WIDGET. */
1105 delete_cb (GtkWidget
*widget
,
1112 /* Create and set up the GTK widgets for frame F.
1113 Return true if creation succeeded. */
1116 xg_create_frame_widgets (struct frame
*f
)
1119 GtkWidget
*wvbox
, *whbox
;
1128 if (FRAME_X_EMBEDDED_P (f
))
1130 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1131 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1134 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1136 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1137 has backported it to Gtk+ 2.0 and they add the resize grip for
1138 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1139 forever, so disable the grip. */
1140 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1141 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1142 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1145 xg_set_screen (wtop
, f
);
1147 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1148 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1149 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1150 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1153 wfixed
= emacs_fixed_new (f
);
1155 wfixed
= gtk_fixed_new ();
1158 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1160 if (wtop
) gtk_widget_destroy (wtop
);
1161 if (wvbox
) gtk_widget_destroy (wvbox
);
1162 if (whbox
) gtk_widget_destroy (whbox
);
1163 if (wfixed
) gtk_widget_destroy (wfixed
);
1169 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1170 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1171 gtk_widget_set_name (wvbox
, "pane");
1172 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1174 /* If this frame has a title or name, set it in the title bar. */
1175 if (! NILP (f
->title
))
1176 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1177 else if (! NILP (f
->name
))
1178 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1181 gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1183 if (FRAME_UNDECORATED (f
))
1185 gtk_window_set_decorated (GTK_WINDOW (wtop
), FALSE
);
1186 store_frame_param (f
, Qundecorated
, Qt
);
1189 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1190 FRAME_GTK_WIDGET (f
) = wfixed
;
1191 f
->output_data
.x
->vbox_widget
= wvbox
;
1192 f
->output_data
.x
->hbox_widget
= whbox
;
1194 gtk_widget_set_has_window (wfixed
, TRUE
);
1196 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1197 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1198 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1200 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1201 update_frame_tool_bar (f
);
1203 /* We don't want this widget double buffered, because we draw on it
1204 with regular X drawing primitives, so from a GTK/GDK point of
1205 view, the widget is totally blank. When an expose comes, this
1206 will make the widget blank, and then Emacs redraws it. This flickers
1207 a lot, so we turn off double buffering. */
1208 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1210 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1211 SSDATA (Vx_resource_name
),
1212 SSDATA (Vx_resource_class
));
1214 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1215 GTK is to destroy the widget. We want Emacs to do that instead. */
1216 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1217 G_CALLBACK (delete_cb
), f
);
1219 /* Convert our geometry parameters into a geometry string
1221 GTK will itself handle calculating the real position this way. */
1222 xg_set_geometry (f
);
1224 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1226 gtk_widget_add_events (wfixed
,
1227 GDK_POINTER_MOTION_MASK
1229 | GDK_BUTTON_PRESS_MASK
1230 | GDK_BUTTON_RELEASE_MASK
1231 | GDK_KEY_PRESS_MASK
1232 | GDK_ENTER_NOTIFY_MASK
1233 | GDK_LEAVE_NOTIFY_MASK
1234 | GDK_FOCUS_CHANGE_MASK
1235 | GDK_STRUCTURE_MASK
1236 | GDK_VISIBILITY_NOTIFY_MASK
);
1238 /* Must realize the windows so the X window gets created. It is used
1239 by callers of this function. */
1240 gtk_widget_realize (wfixed
);
1241 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1242 initial_set_up_x_back_buffer (f
);
1244 /* Since GTK clears its window by filling with the background color,
1245 we must keep X and GTK background in sync. */
1246 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1249 /* Also, do not let any background pixmap to be set, this looks very
1250 bad as Emacs overwrites the background pixmap with its own idea
1251 of background color. */
1252 style
= gtk_widget_get_modifier_style (wfixed
);
1254 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1255 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1256 gtk_widget_modify_style (wfixed
, style
);
1258 gtk_widget_set_can_focus (wfixed
, TRUE
);
1259 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1262 if (FRAME_OVERRIDE_REDIRECT (f
))
1264 GdkWindow
*gwin
= gtk_widget_get_window (wtop
);
1267 gdk_window_set_override_redirect (gwin
, TRUE
);
1270 #ifdef USE_GTK_TOOLTIP
1271 /* Steal a tool tip window we can move ourselves. */
1272 f
->output_data
.x
->ttip_widget
= 0;
1273 f
->output_data
.x
->ttip_lbl
= 0;
1274 f
->output_data
.x
->ttip_window
= 0;
1275 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1276 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1280 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1281 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1282 /* Only connect this signal once per screen. */
1283 if (! g_signal_handler_find (G_OBJECT (gs
),
1284 G_SIGNAL_MATCH_FUNC
,
1286 (gpointer
) G_CALLBACK (style_changed_cb
),
1289 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1290 G_CALLBACK (style_changed_cb
),
1291 gdk_screen_get_display (screen
));
1301 xg_free_frame_widgets (struct frame
*f
)
1303 if (FRAME_GTK_OUTER_WIDGET (f
))
1305 #ifdef USE_GTK_TOOLTIP
1306 struct x_output
*x
= f
->output_data
.x
;
1308 struct xg_frame_tb_info
*tbinfo
1309 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1314 /* x_free_frame_resources should have taken care of it */
1315 eassert (!FRAME_X_DOUBLE_BUFFERED_P (f
));
1316 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1317 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1318 FRAME_X_RAW_DRAWABLE (f
) = 0;
1319 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1320 #ifdef USE_GTK_TOOLTIP
1322 gtk_widget_destroy (x
->ttip_lbl
);
1324 g_object_unref (G_OBJECT (x
->ttip_widget
));
1329 /* Set the normal size hints for the window manager, for frame F.
1330 FLAGS is the flags word to use--or 0 meaning preserve the flags
1331 that the window now has.
1332 If USER_POSITION, set the User Position
1333 flag (this is useful when FLAGS is 0). */
1336 x_wm_set_size_hint (struct frame
*f
, long int flags
, bool user_position
)
1338 /* Must use GTK routines here, otherwise GTK resets the size hints
1339 to its own defaults. */
1340 GdkGeometry size_hints
;
1341 gint hint_flags
= 0;
1342 int base_width
, base_height
;
1343 int min_rows
= 0, min_cols
= 0;
1344 int win_gravity
= f
->win_gravity
;
1345 Lisp_Object fs_state
, frame
;
1346 int scale
= xg_get_gdk_scale ();
1348 /* Don't set size hints during initialization; that apparently leads
1349 to a race condition. See the thread at
1350 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1351 if (NILP (Vafter_init_time
)
1352 || !FRAME_GTK_OUTER_WIDGET (f
)
1353 || FRAME_PARENT_FRAME (f
))
1356 XSETFRAME (frame
, f
);
1357 fs_state
= Fframe_parameter (frame
, Qfullscreen
);
1358 if ((EQ (fs_state
, Qmaximized
) || EQ (fs_state
, Qfullboth
)) &&
1359 (x_wm_supports (f
, FRAME_DISPLAY_INFO (f
)->Xatom_net_wm_state
) ||
1360 x_wm_supports (f
, FRAME_DISPLAY_INFO (f
)->Xatom_net_wm_state_fullscreen
)))
1362 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1363 Gtk3 don't get along and the frame shrinks (!).
1370 memset (&size_hints
, 0, sizeof (size_hints
));
1371 f
->output_data
.x
->size_hints
= size_hints
;
1372 f
->output_data
.x
->hint_flags
= hint_flags
;
1375 flags
= f
->size_hint_flags
;
1377 size_hints
= f
->output_data
.x
->size_hints
;
1378 hint_flags
= f
->output_data
.x
->hint_flags
;
1380 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1381 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
1382 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
1384 hint_flags
|= GDK_HINT_BASE_SIZE
;
1385 /* Use one row/col here so base_height/width does not become zero.
1386 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it.
1387 Obviously this makes the row/col value displayed off by 1. */
1388 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1389 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1390 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1392 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1393 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1395 size_hints
.base_width
= base_width
;
1396 size_hints
.base_height
= base_height
;
1397 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);
1398 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
1400 /* These currently have a one to one mapping with the X values, but I
1401 don't think we should rely on that. */
1402 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1403 size_hints
.win_gravity
= 0;
1404 if (win_gravity
== NorthWestGravity
)
1405 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1406 else if (win_gravity
== NorthGravity
)
1407 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1408 else if (win_gravity
== NorthEastGravity
)
1409 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1410 else if (win_gravity
== WestGravity
)
1411 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1412 else if (win_gravity
== CenterGravity
)
1413 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1414 else if (win_gravity
== EastGravity
)
1415 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1416 else if (win_gravity
== SouthWestGravity
)
1417 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1418 else if (win_gravity
== SouthGravity
)
1419 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1420 else if (win_gravity
== SouthEastGravity
)
1421 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1422 else if (win_gravity
== StaticGravity
)
1423 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1425 if (x_gtk_use_window_move
)
1427 if (flags
& PPosition
) hint_flags
|= GDK_HINT_POS
;
1428 if (flags
& USPosition
) hint_flags
|= GDK_HINT_USER_POS
;
1429 if (flags
& USSize
) hint_flags
|= GDK_HINT_USER_SIZE
;
1434 hint_flags
&= ~GDK_HINT_POS
;
1435 hint_flags
|= GDK_HINT_USER_POS
;
1438 size_hints
.base_width
/= scale
;
1439 size_hints
.base_height
/= scale
;
1440 size_hints
.width_inc
/= scale
;
1441 size_hints
.height_inc
/= scale
;
1443 if (hint_flags
!= f
->output_data
.x
->hint_flags
1444 || memcmp (&size_hints
,
1445 &f
->output_data
.x
->size_hints
,
1446 sizeof (size_hints
)) != 0)
1449 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1450 NULL
, &size_hints
, hint_flags
);
1451 f
->output_data
.x
->size_hints
= size_hints
;
1452 f
->output_data
.x
->hint_flags
= hint_flags
;
1457 /* Change background color of a frame.
1458 Since GTK uses the background color to clear the window, we must
1459 keep the GTK and X colors in sync.
1460 F is the frame to change,
1461 BG is the pixel value to change to. */
1464 xg_set_background_color (struct frame
*f
, unsigned long bg
)
1466 if (FRAME_GTK_WIDGET (f
))
1469 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1472 for (bar
= FRAME_SCROLL_BARS (f
);
1474 bar
= XSCROLL_BAR (bar
)->next
)
1476 GtkWidget
*scrollbar
=
1477 xg_get_widget_from_map (XSCROLL_BAR (bar
)->x_window
);
1478 GtkWidget
*webox
= gtk_widget_get_parent (scrollbar
);
1479 xg_set_widget_bg (f
, webox
, FRAME_BACKGROUND_PIXEL (f
));
1486 /* Change the frame's decoration (title bar + resize borders). This
1487 might not work with all window managers. */
1489 xg_set_undecorated (struct frame
*f
, Lisp_Object undecorated
)
1491 if (FRAME_GTK_WIDGET (f
))
1494 gtk_window_set_decorated (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1495 NILP (undecorated
) ? TRUE
: FALSE
);
1501 /* Restack F1 below F2, above if ABOVE_FLAG is true. This might not
1502 work with all window managers. */
1504 xg_frame_restack (struct frame
*f1
, struct frame
*f2
, bool above_flag
)
1507 if (FRAME_GTK_OUTER_WIDGET (f1
) && FRAME_GTK_OUTER_WIDGET (f2
))
1509 GdkWindow
*gwin1
= gtk_widget_get_window (FRAME_GTK_OUTER_WIDGET (f1
));
1510 GdkWindow
*gwin2
= gtk_widget_get_window (FRAME_GTK_OUTER_WIDGET (f2
));
1511 Lisp_Object frame1
, frame2
;
1513 XSETFRAME (frame1
, f1
);
1514 XSETFRAME (frame2
, f2
);
1516 gdk_window_restack (gwin1
, gwin2
, above_flag
);
1523 /* Don't show frame in taskbar, don't ALT-TAB to it. */
1525 xg_set_skip_taskbar (struct frame
*f
, Lisp_Object skip_taskbar
)
1528 if (FRAME_GTK_WIDGET (f
))
1529 gdk_window_set_skip_taskbar_hint
1530 (gtk_widget_get_window (FRAME_GTK_OUTER_WIDGET (f
)),
1531 NILP (skip_taskbar
) ? FALSE
: TRUE
);
1536 /* Don't give frame focus. */
1538 xg_set_no_focus_on_map (struct frame
*f
, Lisp_Object no_focus_on_map
)
1541 if (FRAME_GTK_WIDGET (f
))
1543 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1544 gboolean g_no_focus_on_map
= NILP (no_focus_on_map
) ? TRUE
: FALSE
;
1546 gtk_window_set_focus_on_map (gwin
, g_no_focus_on_map
);
1553 xg_set_no_accept_focus (struct frame
*f
, Lisp_Object no_accept_focus
)
1556 if (FRAME_GTK_WIDGET (f
))
1558 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1559 gboolean g_no_accept_focus
= NILP (no_accept_focus
) ? TRUE
: FALSE
;
1561 gtk_window_set_accept_focus (gwin
, g_no_accept_focus
);
1567 xg_set_override_redirect (struct frame
*f
, Lisp_Object override_redirect
)
1571 if (FRAME_GTK_OUTER_WIDGET (f
))
1573 GdkWindow
*gwin
= gtk_widget_get_window (FRAME_GTK_OUTER_WIDGET (f
));
1575 gdk_window_set_override_redirect (gwin
, NILP (override_redirect
) ? FALSE
: TRUE
);
1581 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1582 functions so GTK does not overwrite the icon. */
1585 xg_set_frame_icon (struct frame
*f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1587 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1591 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1596 /***********************************************************************
1598 ***********************************************************************/
1599 /* Return the dialog title to use for a dialog of type KEY.
1600 This is the encoding used by lwlib. We use the same for GTK. */
1603 get_dialog_title (char key
)
1605 const char *title
= "";
1613 title
= "Information";
1632 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1633 the dialog, but return TRUE so the event does not propagate further
1634 in GTK. This prevents GTK from destroying the dialog widget automatically
1635 and we can always destroy the widget manually, regardless of how
1636 it was popped down (button press or WM_DELETE_WINDOW).
1637 W is the dialog widget.
1638 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1639 user_data is NULL (not used).
1641 Returns TRUE to end propagation of event. */
1644 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1646 gtk_widget_unmap (w
);
1650 /* Create a popup dialog window. See also xg_create_widget below.
1651 WV is a widget_value describing the dialog.
1652 SELECT_CB is the callback to use when a button has been pressed.
1653 DEACTIVATE_CB is the callback to use when the dialog pops down.
1655 Returns the GTK dialog widget. */
1658 create_dialog (widget_value
*wv
,
1659 GCallback select_cb
,
1660 GCallback deactivate_cb
)
1662 const char *title
= get_dialog_title (wv
->name
[0]);
1663 int total_buttons
= wv
->name
[1] - '0';
1664 int right_buttons
= wv
->name
[4] - '0';
1667 int button_spacing
= 10;
1668 GtkWidget
*wdialog
= gtk_dialog_new ();
1669 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1671 GtkWidget
*whbox_down
;
1673 /* If the number of buttons is greater than 4, make two rows of buttons
1674 instead. This looks better. */
1675 bool make_two_rows
= total_buttons
> 4;
1677 #if GTK_CHECK_VERSION (3, 12, 0)
1678 GtkBuilder
*gbld
= gtk_builder_new ();
1679 GObject
*go
= gtk_buildable_get_internal_child (GTK_BUILDABLE (wd
),
1682 GtkBox
*cur_box
= GTK_BOX (go
);
1683 g_object_unref (G_OBJECT (gbld
));
1685 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1688 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1689 left_buttons
= total_buttons
- right_buttons
;
1691 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1692 gtk_widget_set_name (wdialog
, "emacs-dialog");
1697 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1698 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1699 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1700 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1701 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1702 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1704 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1705 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1706 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1708 cur_box
= GTK_BOX (whbox_up
);
1711 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1712 G_CALLBACK (dialog_delete_callback
), 0);
1716 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1717 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1720 for (item
= wv
->contents
; item
; item
= item
->next
)
1722 char *utf8_label
= get_utf8_string (item
->value
);
1726 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1728 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1729 /* This is the text part of the dialog. */
1730 w
= gtk_label_new (utf8_label
);
1731 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1732 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1733 #if GTK_CHECK_VERSION (3, 14, 0)
1734 gtk_widget_set_halign (w
, GTK_ALIGN_START
);
1735 gtk_widget_set_valign (w
, GTK_ALIGN_CENTER
);
1737 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1739 /* Try to make dialog look better. Must realize first so
1740 the widget can calculate the size it needs. */
1741 gtk_widget_realize (w
);
1742 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1743 gtk_box_set_spacing (wvbox
, req
.height
);
1744 if (item
->value
&& strlen (item
->value
) > 0)
1745 button_spacing
= 2*req
.width
/strlen (item
->value
);
1746 if (button_spacing
< 10) button_spacing
= 10;
1750 /* This is one button to add to the dialog. */
1751 w
= gtk_button_new_with_label (utf8_label
);
1752 if (! item
->enabled
)
1753 gtk_widget_set_sensitive (w
, FALSE
);
1755 g_signal_connect (G_OBJECT (w
), "clicked",
1756 select_cb
, item
->call_data
);
1758 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1759 if (++button_nr
== left_buttons
)
1762 cur_box
= GTK_BOX (whbox_down
);
1767 g_free (utf8_label
);
1773 struct xg_dialog_data
1781 /* Function that is called when the file or font dialogs pop down.
1782 W is the dialog widget, RESPONSE is the response code.
1783 USER_DATA is what we passed in to g_signal_connect. */
1786 xg_dialog_response_cb (GtkDialog
*w
,
1790 struct xg_dialog_data
*dd
= user_data
;
1791 dd
->response
= response
;
1792 g_main_loop_quit (dd
->loop
);
1796 /* Destroy the dialog. This makes it pop down. */
1799 pop_down_dialog (void *arg
)
1801 struct xg_dialog_data
*dd
= arg
;
1804 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1805 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1807 g_main_loop_quit (dd
->loop
);
1808 g_main_loop_unref (dd
->loop
);
1813 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1814 Pass DATA as gpointer so we can use this as a callback. */
1817 xg_maybe_add_timer (gpointer data
)
1819 struct xg_dialog_data
*dd
= data
;
1820 struct timespec next_time
= timer_check ();
1824 if (timespec_valid_p (next_time
))
1826 time_t s
= next_time
.tv_sec
;
1827 int per_ms
= TIMESPEC_RESOLUTION
/ 1000;
1828 int ms
= (next_time
.tv_nsec
+ per_ms
- 1) / per_ms
;
1829 if (s
<= ((guint
) -1 - ms
) / 1000)
1830 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1836 /* Pops up a modal dialog W and waits for response.
1837 We don't use gtk_dialog_run because we want to process emacs timers.
1838 The dialog W is not destroyed when this function returns. */
1841 xg_dialog_run (struct frame
*f
, GtkWidget
*w
)
1843 ptrdiff_t count
= SPECPDL_INDEX ();
1844 struct xg_dialog_data dd
;
1846 xg_set_screen (w
, f
);
1847 gtk_window_set_transient_for (GTK_WINDOW (w
),
1848 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1849 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1850 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1852 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1853 dd
.response
= GTK_RESPONSE_CANCEL
;
1857 g_signal_connect (G_OBJECT (w
),
1859 G_CALLBACK (xg_dialog_response_cb
),
1861 /* Don't destroy the widget if closed by the window manager close button. */
1862 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1863 gtk_widget_show (w
);
1865 record_unwind_protect_ptr (pop_down_dialog
, &dd
);
1867 (void) xg_maybe_add_timer (&dd
);
1868 g_main_loop_run (dd
.loop
);
1871 unbind_to (count
, Qnil
);
1877 /***********************************************************************
1878 File dialog functions
1879 ***********************************************************************/
1880 /* Return true if the old file selection dialog is being used. */
1883 xg_uses_old_file_dialog (void)
1885 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1886 return x_gtk_use_old_file_dialog
;
1893 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1895 /* Return the selected file for file chooser dialog W.
1896 The returned string must be free:d. */
1899 xg_get_file_name_from_chooser (GtkWidget
*w
)
1901 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1904 /* Callback called when the "Show hidden files" toggle is pressed.
1905 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1908 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1910 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1912 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1913 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1917 /* Callback called when a property changes in a file chooser.
1918 GOBJECT is the file chooser dialog, ARG1 describes the property.
1919 USER_DATA is the toggle widget in the file chooser dialog.
1920 We use this to update the "Show hidden files" toggle when the user
1921 changes that property by right clicking in the file list. */
1924 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1926 if (strcmp (arg1
->name
, "show-hidden") == 0)
1928 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1929 gboolean visible
, toggle_on
;
1931 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1932 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1934 if (!!visible
!= !!toggle_on
)
1936 gpointer cb
= (gpointer
) G_CALLBACK (xg_toggle_visibility_cb
);
1937 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
), cb
, gobject
);
1938 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1939 g_signal_handlers_unblock_by_func (G_OBJECT (wtoggle
), cb
, gobject
);
1941 x_gtk_show_hidden_files
= visible
;
1945 /* Read a file name from the user using a file chooser dialog.
1946 F is the current frame.
1947 PROMPT is a prompt to show to the user. May not be NULL.
1948 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1949 If MUSTMATCH_P, the returned file name must be an existing
1950 file. (Actually, this only has cosmetic effects, the user can
1951 still enter a non-existing file.) *FUNC is set to a function that
1952 can be used to retrieve the selected file name from the returned widget.
1954 Returns the created widget. */
1957 xg_get_file_with_chooser (struct frame
*f
,
1959 char *default_filename
,
1960 bool mustmatch_p
, bool only_dir_p
,
1961 xg_get_file_func
*func
)
1965 GtkWidget
*filewin
, *wtoggle
, *wbox
;
1966 GtkWidget
*wmessage UNINIT
;
1967 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1968 GtkFileChooserAction action
= (mustmatch_p
?
1969 GTK_FILE_CHOOSER_ACTION_OPEN
:
1970 GTK_FILE_CHOOSER_ACTION_SAVE
);
1973 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1975 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1976 XG_TEXT_CANCEL
, GTK_RESPONSE_CANCEL
,
1977 (mustmatch_p
|| only_dir_p
?
1978 XG_TEXT_OPEN
: XG_TEXT_OK
),
1981 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1983 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1984 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1985 gtk_widget_show (wbox
);
1986 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1988 if (x_gtk_show_hidden_files
)
1990 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1991 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1993 gtk_widget_show (wtoggle
);
1994 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1995 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1996 g_signal_connect (G_OBJECT (filewin
), "notify",
1997 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1999 if (x_gtk_file_dialog_help_text
)
2002 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
2003 Show the C-l help text only for versions < 2.10. */
2004 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
2005 z
= stpcpy (z
, "\nType C-l to display a file name text entry box.\n");
2006 strcpy (z
, "\nIf you don't like this file selector, use the "
2007 "corresponding\nkey binding or customize "
2008 "use-file-dialog to turn it off.");
2010 wmessage
= gtk_label_new (msgbuf
);
2011 gtk_widget_show (wmessage
);
2014 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
2015 if (x_gtk_file_dialog_help_text
)
2016 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
2017 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
2019 if (default_filename
)
2022 char *utf8_filename
;
2024 file
= build_string (default_filename
);
2026 /* File chooser does not understand ~/... in the file name. It must be
2027 an absolute name starting with /. */
2028 if (default_filename
[0] != '/')
2029 file
= Fexpand_file_name (file
, Qnil
);
2031 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
2032 if (! NILP (Ffile_directory_p (file
)))
2033 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
2037 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
2039 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
2041 char *cp
= strrchr (utf8_filename
, '/');
2043 else cp
= utf8_filename
;
2044 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
2049 *func
= xg_get_file_name_from_chooser
;
2053 #ifdef HAVE_GTK_FILE_SELECTION_NEW
2055 /* Return the selected file for file selector dialog W.
2056 The returned string must be free:d. */
2059 xg_get_file_name_from_selector (GtkWidget
*w
)
2061 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
2062 return xstrdup (gtk_file_selection_get_filename (filesel
));
2065 /* Create a file selection dialog.
2066 F is the current frame.
2067 PROMPT is a prompt to show to the user. May not be NULL.
2068 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
2069 If MUSTMATCH_P, the returned file name must be an existing
2070 file. *FUNC is set to a function that can be used to retrieve the
2071 selected file name from the returned widget.
2073 Returns the created widget. */
2076 xg_get_file_with_selection (struct frame
*f
,
2078 char *default_filename
,
2079 bool mustmatch_p
, bool only_dir_p
,
2080 xg_get_file_func
*func
)
2083 GtkFileSelection
*filesel
;
2085 filewin
= gtk_file_selection_new (prompt
);
2086 filesel
= GTK_FILE_SELECTION (filewin
);
2088 if (default_filename
)
2089 gtk_file_selection_set_filename (filesel
, default_filename
);
2093 /* The selection_entry part of filesel is not documented. */
2094 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
2095 gtk_file_selection_hide_fileop_buttons (filesel
);
2098 *func
= xg_get_file_name_from_selector
;
2102 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
2104 /* Read a file name from the user using a file dialog, either the old
2105 file selection dialog, or the new file chooser dialog. Which to use
2106 depends on what the GTK version used has, and what the value of
2107 gtk-use-old-file-dialog.
2108 F is the current frame.
2109 PROMPT is a prompt to show to the user. May not be NULL.
2110 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
2111 If MUSTMATCH_P, the returned file name must be an existing
2114 Returns a file name or NULL if no file was selected.
2115 The returned string must be freed by the caller. */
2118 xg_get_file_name (struct frame
*f
,
2120 char *default_filename
,
2126 int filesel_done
= 0;
2127 xg_get_file_func func
;
2129 #ifdef HAVE_GTK_FILE_SELECTION_NEW
2131 if (xg_uses_old_file_dialog ())
2132 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
2133 mustmatch_p
, only_dir_p
, &func
);
2135 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2136 mustmatch_p
, only_dir_p
, &func
);
2138 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
2139 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2140 mustmatch_p
, only_dir_p
, &func
);
2141 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
2143 gtk_widget_set_name (w
, "emacs-filedialog");
2145 filesel_done
= xg_dialog_run (f
, w
);
2146 if (filesel_done
== GTK_RESPONSE_OK
)
2149 gtk_widget_destroy (w
);
2153 /***********************************************************************
2155 ***********************************************************************/
2157 #ifdef HAVE_FREETYPE
2159 #if USE_NEW_GTK_FONT_CHOOSER
2161 #define XG_WEIGHT_TO_SYMBOL(w) \
2162 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
2163 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
2164 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
2165 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
2166 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
2167 : w <= PANGO_WEIGHT_BOLD ? Qbold \
2168 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
2171 #define XG_STYLE_TO_SYMBOL(s) \
2172 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
2173 : s == PANGO_STYLE_ITALIC ? Qitalic \
2176 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2179 static char *x_last_font_name
;
2181 /* Pop up a GTK font selector and return the name of the font the user
2182 selects, as a C string. The returned font name follows GTK's own
2185 `FAMILY [VALUE1 VALUE2] SIZE'
2187 This can be parsed using font_parse_fcname in font.c.
2188 DEFAULT_NAME, if non-zero, is the default font name. */
2191 xg_get_font (struct frame
*f
, const char *default_name
)
2195 Lisp_Object font
= Qnil
;
2197 w
= gtk_font_chooser_dialog_new
2198 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2202 /* Convert fontconfig names to Gtk names, i.e. remove - before
2204 char *p
= strrchr (default_name
, '-');
2208 while (c_isdigit (*ep
))
2210 if (*ep
== '\0') *p
= ' ';
2213 else if (x_last_font_name
)
2214 default_name
= x_last_font_name
;
2217 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2219 gtk_widget_set_name (w
, "emacs-fontdialog");
2220 done
= xg_dialog_run (f
, w
);
2221 if (done
== GTK_RESPONSE_OK
)
2223 #if USE_NEW_GTK_FONT_CHOOSER
2224 /* Use the GTK3 font chooser. */
2225 PangoFontDescription
*desc
2226 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2230 const char *name
= pango_font_description_get_family (desc
);
2231 gint size
= pango_font_description_get_size (desc
);
2232 PangoWeight weight
= pango_font_description_get_weight (desc
);
2233 PangoStyle style
= pango_font_description_get_style (desc
);
2236 #define FONT_TYPE_WANTED (Qftcr)
2238 #define FONT_TYPE_WANTED (Qxft)
2240 font
= CALLN (Ffont_spec
,
2241 QCname
, build_string (name
),
2242 QCsize
, make_float (pango_units_to_double (size
)),
2243 QCweight
, XG_WEIGHT_TO_SYMBOL (weight
),
2244 QCslant
, XG_STYLE_TO_SYMBOL (style
),
2248 pango_font_description_free (desc
);
2249 dupstring (&x_last_font_name
, name
);
2252 #else /* Use old font selector, which just returns the font name. */
2255 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2259 font
= build_string (font_name
);
2260 g_free (x_last_font_name
);
2261 x_last_font_name
= font_name
;
2263 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2266 gtk_widget_destroy (w
);
2269 #endif /* HAVE_FREETYPE */
2273 /***********************************************************************
2275 ***********************************************************************/
2277 /* The name of menu items that can be used for customization. Since GTK
2278 RC files are very crude and primitive, we have to set this on all
2279 menu item names so a user can easily customize menu items. */
2281 #define MENU_ITEM_NAME "emacs-menuitem"
2284 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2285 during GC. The next member points to the items. */
2286 static xg_list_node xg_menu_cb_list
;
2288 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2289 during GC. The next member points to the items. */
2290 static xg_list_node xg_menu_item_cb_list
;
2292 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2293 F is the frame CL_DATA will be initialized for.
2294 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2296 The menu bar and all sub menus under the menu bar in a frame
2297 share the same structure, hence the reference count.
2299 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2300 allocated xg_menu_cb_data if CL_DATA is NULL. */
2302 static xg_menu_cb_data
*
2303 make_cl_data (xg_menu_cb_data
*cl_data
, struct frame
*f
, GCallback highlight_cb
)
2307 cl_data
= xmalloc (sizeof *cl_data
);
2309 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2310 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2311 cl_data
->highlight_cb
= highlight_cb
;
2312 cl_data
->ref_count
= 0;
2314 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2317 cl_data
->ref_count
++;
2322 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2323 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2325 When the menu bar is updated, menu items may have been added and/or
2326 removed, so menu_bar_vector and menu_bar_items_used change. We must
2327 then update CL_DATA since it is used to determine which menu
2328 item that is invoked in the menu.
2329 HIGHLIGHT_CB could change, there is no check that the same
2330 function is given when modifying a menu bar as was given when
2331 creating the menu bar. */
2334 update_cl_data (xg_menu_cb_data
*cl_data
,
2336 GCallback highlight_cb
)
2341 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2342 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2343 cl_data
->highlight_cb
= highlight_cb
;
2347 /* Decrease reference count for CL_DATA.
2348 If reference count is zero, free CL_DATA. */
2351 unref_cl_data (xg_menu_cb_data
*cl_data
)
2353 if (cl_data
&& cl_data
->ref_count
> 0)
2355 cl_data
->ref_count
--;
2356 if (cl_data
->ref_count
== 0)
2358 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2364 /* Function that marks all lisp data during GC. */
2370 Lisp_Object rest
, frame
;
2372 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2373 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2375 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2377 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2379 if (! NILP (cb_data
->help
))
2380 mark_object (cb_data
->help
);
2383 FOR_EACH_FRAME (rest
, frame
)
2385 struct frame
*f
= XFRAME (frame
);
2387 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2389 struct xg_frame_tb_info
*tbinfo
2390 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2394 mark_object (tbinfo
->last_tool_bar
);
2395 mark_object (tbinfo
->style
);
2401 /* Callback called when a menu item is destroyed. Used to free data.
2402 W is the widget that is being destroyed (not used).
2403 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2406 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2410 xg_menu_item_cb_data
*data
= client_data
;
2411 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2416 /* Callback called when the pointer enters/leaves a menu item.
2417 W is the parent of the menu item.
2418 EVENT is either an enter event or leave event.
2419 CLIENT_DATA is not used.
2421 Returns FALSE to tell GTK to keep processing this event. */
2424 menuitem_highlight_callback (GtkWidget
*w
,
2425 GdkEventCrossing
*event
,
2426 gpointer client_data
)
2429 GtkWidget
*subwidget
;
2430 xg_menu_item_cb_data
*data
;
2432 ev
.crossing
= *event
;
2433 subwidget
= gtk_get_event_widget (&ev
);
2434 data
= g_object_get_data (G_OBJECT (subwidget
), XG_ITEM_DATA
);
2437 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2439 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2440 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2441 (*func
) (subwidget
, call_data
);
2448 /* Callback called when a menu is destroyed. Used to free data.
2449 W is the widget that is being destroyed (not used).
2450 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2453 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2455 unref_cl_data (client_data
);
2458 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2459 must be non-NULL) and can be inserted into a menu item.
2461 Returns the GtkHBox. */
2464 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2470 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2471 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2472 wlbl
= gtk_label_new (utf8_label
);
2473 wkey
= gtk_label_new (utf8_key
);
2475 #if GTK_CHECK_VERSION (3, 14, 0)
2476 gtk_widget_set_halign (wlbl
, GTK_ALIGN_START
);
2477 gtk_widget_set_valign (wlbl
, GTK_ALIGN_CENTER
);
2478 gtk_widget_set_halign (wkey
, GTK_ALIGN_START
);
2479 gtk_widget_set_valign (wkey
, GTK_ALIGN_CENTER
);
2481 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2482 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2484 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2485 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2487 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2488 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2489 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2494 /* Make and return a menu item widget with the key to the right.
2495 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2496 UTF8_KEY is the text representing the key binding.
2497 ITEM is the widget_value describing the menu item.
2499 GROUP is an in/out parameter. If the menu item to be created is not
2500 part of any radio menu group, *GROUP contains NULL on entry and exit.
2501 If the menu item to be created is part of a radio menu group, on entry
2502 *GROUP contains the group to use, or NULL if this is the first item
2503 in the group. On exit, *GROUP contains the radio item group.
2505 Unfortunately, keys don't line up as nicely as in Motif,
2506 but the macOS version doesn't either, so I guess that is OK. */
2509 make_menu_item (const char *utf8_label
,
2510 const char *utf8_key
,
2515 GtkWidget
*wtoadd
= 0;
2517 /* It has been observed that some menu items have a NULL name field.
2518 This will lead to this function being called with a NULL utf8_label.
2519 GTK crashes on that so we set a blank label. Why there is a NULL
2520 name remains to be investigated. */
2521 if (! utf8_label
) utf8_label
= " ";
2524 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2526 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2529 if (utf8_key
) w
= gtk_check_menu_item_new ();
2530 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2531 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2533 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2535 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2536 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2537 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2539 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2544 if (utf8_key
) w
= gtk_menu_item_new ();
2545 else w
= gtk_menu_item_new_with_label (utf8_label
);
2548 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2549 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2554 /* Create a menu item widget, and connect the callbacks.
2555 ITEM describes the menu item.
2556 F is the frame the created menu belongs to.
2557 SELECT_CB is the callback to use when a menu item is selected.
2558 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2559 CL_DATA points to the callback data to be used for this menu.
2560 GROUP is an in/out parameter. If the menu item to be created is not
2561 part of any radio menu group, *GROUP contains NULL on entry and exit.
2562 If the menu item to be created is part of a radio menu group, on entry
2563 *GROUP contains the group to use, or NULL if this is the first item
2564 in the group. On exit, *GROUP contains the radio item group.
2566 Returns the created GtkWidget. */
2569 xg_create_one_menuitem (widget_value
*item
,
2571 GCallback select_cb
,
2572 GCallback highlight_cb
,
2573 xg_menu_cb_data
*cl_data
,
2579 xg_menu_item_cb_data
*cb_data
;
2581 utf8_label
= get_utf8_string (item
->name
);
2582 utf8_key
= get_utf8_string (item
->key
);
2584 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2586 if (utf8_label
) g_free (utf8_label
);
2587 if (utf8_key
) g_free (utf8_key
);
2589 cb_data
= xmalloc (sizeof *cb_data
);
2591 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2593 cb_data
->select_id
= 0;
2594 cb_data
->help
= item
->help
;
2595 cb_data
->cl_data
= cl_data
;
2596 cb_data
->call_data
= item
->call_data
;
2598 g_signal_connect (G_OBJECT (w
),
2600 G_CALLBACK (menuitem_destroy_callback
),
2603 /* Put cb_data in widget, so we can get at it when modifying menubar */
2604 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2606 /* final item, not a submenu */
2607 if (item
->call_data
&& ! item
->contents
)
2611 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2617 /* Create a full menu tree specified by DATA.
2618 F is the frame the created menu belongs to.
2619 SELECT_CB is the callback to use when a menu item is selected.
2620 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2621 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2622 If POP_UP_P, create a popup menu.
2623 If MENU_BAR_P, create a menu bar.
2624 TOPMENU is the topmost GtkWidget that others shall be placed under.
2625 It may be NULL, in that case we create the appropriate widget
2626 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2627 CL_DATA is the callback data we shall use for this menu, or NULL
2628 if we haven't set the first callback yet.
2629 NAME is the name to give to the top level menu if this function
2630 creates it. May be NULL to not set any name.
2632 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2635 This function calls itself to create submenus. */
2638 create_menus (widget_value
*data
,
2640 GCallback select_cb
,
2641 GCallback deactivate_cb
,
2642 GCallback highlight_cb
,
2646 xg_menu_cb_data
*cl_data
,
2650 GtkWidget
*wmenu
= topmenu
;
2651 GSList
*group
= NULL
;
2657 wmenu
= gtk_menu_new ();
2658 xg_set_screen (wmenu
, f
);
2659 /* Connect this to the menu instead of items so we get enter/leave for
2660 disabled items also. TODO: Still does not get enter/leave for
2661 disabled items in detached menus. */
2662 g_signal_connect (G_OBJECT (wmenu
),
2663 "enter-notify-event",
2664 G_CALLBACK (menuitem_highlight_callback
),
2666 g_signal_connect (G_OBJECT (wmenu
),
2667 "leave-notify-event",
2668 G_CALLBACK (menuitem_highlight_callback
),
2673 wmenu
= gtk_menu_bar_new ();
2674 /* Set width of menu bar to a small value so it doesn't enlarge
2675 a small initial frame size. The width will be set to the
2676 width of the frame later on when it is added to a container.
2677 height -1: Natural height. */
2678 gtk_widget_set_size_request (wmenu
, 1, -1);
2681 /* Put cl_data on the top menu for easier access. */
2682 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2683 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2684 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2685 G_CALLBACK (menu_destroy_callback
), cl_data
);
2688 gtk_widget_set_name (wmenu
, name
);
2691 g_signal_connect (G_OBJECT (wmenu
),
2692 "selection-done", deactivate_cb
, 0);
2695 for (item
= data
; item
; item
= item
->next
)
2699 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2700 && !menu_separator_name_p (item
->name
))
2703 /* A title for a popup. We do the same as GTK does when
2704 creating titles, but it does not look good. */
2706 utf8_label
= get_utf8_string (item
->name
);
2708 w
= gtk_menu_item_new_with_label (utf8_label
);
2709 gtk_widget_set_sensitive (w
, FALSE
);
2710 if (utf8_label
) g_free (utf8_label
);
2712 else if (menu_separator_name_p (item
->name
))
2715 /* GTK only have one separator type. */
2716 w
= gtk_separator_menu_item_new ();
2720 w
= xg_create_one_menuitem (item
,
2722 item
->contents
? 0 : select_cb
,
2727 /* Create a possibly empty submenu for menu bar items, since some
2728 themes don't highlight items correctly without it. */
2729 if (item
->contents
|| menu_bar_p
)
2731 GtkWidget
*submenu
= create_menus (item
->contents
,
2741 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2745 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2746 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2752 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2753 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2754 with some text and buttons.
2755 F is the frame the created item belongs to.
2756 NAME is the name to use for the top widget.
2757 VAL is a widget_value structure describing items to be created.
2758 SELECT_CB is the callback to use when a menu item is selected or
2759 a dialog button is pressed.
2760 DEACTIVATE_CB is the callback to use when an item is deactivated.
2761 For a menu, when a sub menu is not shown anymore, for a dialog it is
2762 called when the dialog is popped down.
2763 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2765 Returns the widget created. */
2768 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2769 widget_value
*val
, GCallback select_cb
,
2770 GCallback deactivate_cb
, GCallback highlight_cb
)
2773 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2774 bool pop_up_p
= strcmp (type
, "popup") == 0;
2776 if (strcmp (type
, "dialog") == 0)
2778 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2779 xg_set_screen (w
, f
);
2780 gtk_window_set_transient_for (GTK_WINDOW (w
),
2781 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2782 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2783 gtk_widget_set_name (w
, "emacs-dialog");
2784 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2786 else if (menu_bar_p
|| pop_up_p
)
2788 w
= create_menus (val
->contents
,
2799 /* Set the cursor to an arrow for popup menus when they are mapped.
2800 This is done by default for menu bar menus. */
2803 /* Must realize so the GdkWindow inside the widget is created. */
2804 gtk_widget_realize (w
);
2805 xg_set_cursor (w
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
2810 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2817 /* Return the label for menu item WITEM. */
2820 xg_get_menu_item_label (GtkMenuItem
*witem
)
2822 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2823 return gtk_label_get_label (wlabel
);
2826 /* Return true if the menu item WITEM has the text LABEL. */
2829 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2832 char *utf8_label
= get_utf8_string (label
);
2833 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2835 if (! old_label
&& ! utf8_label
)
2837 else if (old_label
&& utf8_label
)
2838 is_same
= strcmp (utf8_label
, old_label
) == 0;
2840 if (utf8_label
) g_free (utf8_label
);
2845 /* Destroy widgets in LIST. */
2848 xg_destroy_widgets (GList
*list
)
2852 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2854 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2856 /* Destroying the widget will remove it from the container it is in. */
2857 gtk_widget_destroy (w
);
2861 /* Update the top level names in MENUBAR (i.e. not submenus).
2862 F is the frame the menu bar belongs to.
2863 *LIST is a list with the current menu bar names (menu item widgets).
2864 ITER is the item within *LIST that shall be updated.
2865 POS is the numerical position, starting at 0, of ITER in *LIST.
2866 VAL describes what the menu bar shall look like after the update.
2867 SELECT_CB is the callback to use when a menu item is selected.
2868 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2869 CL_DATA points to the callback data to be used for this menu bar.
2871 This function calls itself to walk through the menu bar names. */
2874 xg_update_menubar (GtkWidget
*menubar
,
2880 GCallback select_cb
,
2881 GCallback deactivate_cb
,
2882 GCallback highlight_cb
,
2883 xg_menu_cb_data
*cl_data
)
2885 if (! iter
&& ! val
)
2887 else if (iter
&& ! val
)
2889 /* Item(s) have been removed. Remove all remaining items. */
2890 xg_destroy_widgets (iter
);
2892 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2893 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2894 gtk_menu_item_new_with_label (""),
2900 else if (! iter
&& val
)
2902 /* Item(s) added. Add all new items in one call. */
2903 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2904 0, 1, menubar
, cl_data
, 0);
2910 /* Below this neither iter or val is NULL */
2911 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2913 /* This item is still the same, check next item. */
2915 iter
= g_list_next (iter
);
2918 else /* This item is changed. */
2920 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2921 GtkMenuItem
*witem2
= 0;
2922 bool val_in_menubar
= 0;
2923 bool iter_in_new_menubar
= 0;
2927 /* See if the changed entry (val) is present later in the menu bar */
2929 iter2
&& ! val_in_menubar
;
2930 iter2
= g_list_next (iter2
))
2932 witem2
= GTK_MENU_ITEM (iter2
->data
);
2933 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2936 /* See if the current entry (iter) is present later in the
2937 specification for the new menu bar. */
2938 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2939 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2941 if (val_in_menubar
&& ! iter_in_new_menubar
)
2945 /* This corresponds to:
2950 g_object_ref (G_OBJECT (witem
));
2951 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2952 gtk_widget_destroy (GTK_WIDGET (witem
));
2954 /* Must get new list since the old changed. */
2955 g_list_free (*list
);
2956 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2957 while (nr
-- > 0) iter
= g_list_next (iter
);
2959 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2961 /* This corresponds to:
2964 Rename B to X. This might seem to be a strange thing to do,
2965 since if there is a menu under B it will be totally wrong for X.
2966 But consider editing a C file. Then there is a C-mode menu
2967 (corresponds to B above).
2968 If then doing C-x C-f the minibuf menu (X above) replaces the
2969 C-mode menu. When returning from the minibuffer, we get
2970 back the C-mode menu. Thus we do:
2971 Rename B to X (C-mode to minibuf menu)
2972 Rename X to B (minibuf to C-mode menu).
2973 If the X menu hasn't been invoked, the menu under B
2974 is up to date when leaving the minibuffer. */
2975 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2976 char *utf8_label
= get_utf8_string (val
->name
);
2978 /* GTK menu items don't notice when their labels have been
2979 changed from underneath them, so we have to explicitly
2980 use g_object_notify to tell listeners (e.g., a GMenuModel
2981 bridge that might be loaded) that the item's label has
2983 gtk_label_set_text (wlabel
, utf8_label
);
2984 #if GTK_CHECK_VERSION (2, 16, 0)
2985 g_object_notify (G_OBJECT (witem
), "label");
2987 if (utf8_label
) g_free (utf8_label
);
2988 iter
= g_list_next (iter
);
2992 else if (! val_in_menubar
&& iter_in_new_menubar
)
2994 /* This corresponds to:
3001 GtkWidget
*w
= xg_create_one_menuitem (val
,
3008 /* Create a possibly empty submenu for menu bar items, since some
3009 themes don't highlight items correctly without it. */
3010 GtkWidget
*submenu
= create_menus (NULL
, f
,
3011 select_cb
, deactivate_cb
,
3013 0, 0, 0, cl_data
, 0);
3015 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
3016 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
3017 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
3019 g_list_free (*list
);
3020 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3021 while (nr
-- > 0) iter
= g_list_next (iter
);
3022 iter
= g_list_next (iter
);
3026 else /* if (val_in_menubar && iter_in_new_menubar) */
3029 /* This corresponds to:
3034 g_object_ref (G_OBJECT (witem2
));
3035 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
3036 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
3037 GTK_WIDGET (witem2
), pos
);
3038 g_object_unref (G_OBJECT (witem2
));
3040 g_list_free (*list
);
3041 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3042 while (nr
-- > 0) iter
= g_list_next (iter
);
3043 if (iter
) iter
= g_list_next (iter
);
3049 /* Update the rest of the menu bar. */
3050 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
3051 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3054 /* Update the menu item W so it corresponds to VAL.
3055 SELECT_CB is the callback to use when a menu item is selected.
3056 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3057 CL_DATA is the data to set in the widget for menu invocation. */
3060 xg_update_menu_item (widget_value
*val
,
3062 GCallback select_cb
,
3063 GCallback highlight_cb
,
3064 xg_menu_cb_data
*cl_data
)
3071 const char *old_label
= 0;
3072 const char *old_key
= 0;
3073 xg_menu_item_cb_data
*cb_data
;
3074 bool label_changed
= false;
3076 wchild
= XG_BIN_CHILD (w
);
3077 utf8_label
= get_utf8_string (val
->name
);
3078 utf8_key
= get_utf8_string (val
->key
);
3080 /* See if W is a menu item with a key. See make_menu_item above. */
3081 if (GTK_IS_BOX (wchild
))
3083 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
3085 wlbl
= GTK_LABEL (list
->data
);
3086 wkey
= GTK_LABEL (list
->next
->data
);
3091 /* Remove the key and keep just the label. */
3092 g_object_ref (G_OBJECT (wlbl
));
3093 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3094 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
3095 g_object_unref (G_OBJECT (wlbl
));
3100 else /* Just a label. */
3102 wlbl
= GTK_LABEL (wchild
);
3104 /* Check if there is now a key. */
3107 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
3108 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
3110 wlbl
= GTK_LABEL (list
->data
);
3111 wkey
= GTK_LABEL (list
->next
->data
);
3114 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3115 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3119 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3120 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3122 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3124 label_changed
= true;
3125 gtk_label_set_text (wkey
, utf8_key
);
3128 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3130 label_changed
= true;
3131 gtk_label_set_text (wlbl
, utf8_label
);
3134 if (utf8_key
) g_free (utf8_key
);
3135 if (utf8_label
) g_free (utf8_label
);
3137 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3138 gtk_widget_set_sensitive (w
, FALSE
);
3139 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3140 gtk_widget_set_sensitive (w
, TRUE
);
3142 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
3145 cb_data
->call_data
= val
->call_data
;
3146 cb_data
->help
= val
->help
;
3147 cb_data
->cl_data
= cl_data
;
3149 /* We assume the callback functions don't change. */
3150 if (val
->call_data
&& ! val
->contents
)
3152 /* This item shall have a select callback. */
3153 if (! cb_data
->select_id
)
3155 = g_signal_connect (G_OBJECT (w
), "activate",
3156 select_cb
, cb_data
);
3158 else if (cb_data
->select_id
)
3160 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3161 cb_data
->select_id
= 0;
3165 #if GTK_CHECK_VERSION (2, 16, 0)
3166 if (label_changed
) /* See comment in xg_update_menubar. */
3167 g_object_notify (G_OBJECT (w
), "label");
3171 /* Update the toggle menu item W so it corresponds to VAL. */
3174 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3176 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3179 /* Update the radio menu item W so it corresponds to VAL. */
3182 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3184 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3187 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3188 SUBMENU may be NULL, in that case a new menu is created.
3189 F is the frame the menu bar belongs to.
3190 VAL describes the contents of the menu bar.
3191 SELECT_CB is the callback to use when a menu item is selected.
3192 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3193 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3194 CL_DATA is the call back data to use for any newly created items.
3196 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3200 xg_update_submenu (GtkWidget
*submenu
,
3203 GCallback select_cb
,
3204 GCallback deactivate_cb
,
3205 GCallback highlight_cb
,
3206 xg_menu_cb_data
*cl_data
)
3208 GtkWidget
*newsub
= submenu
;
3212 GList
*first_radio
= 0;
3215 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3217 for (cur
= val
, iter
= list
;
3219 iter
= g_list_next (iter
), cur
= cur
->next
)
3221 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3223 /* Remember first radio button in a group. If we get a mismatch in
3224 a radio group we must rebuild the whole group so that the connections
3225 in GTK becomes correct. */
3226 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3228 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3229 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3232 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3234 if (! menu_separator_name_p (cur
->name
))
3237 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3239 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3241 xg_update_toggle_item (cur
, w
);
3242 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3244 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3246 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3248 xg_update_radio_item (cur
, w
);
3249 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3251 else if (GTK_IS_MENU_ITEM (w
))
3253 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3256 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3257 menu_separator_name_p (cur
->name
))
3260 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3262 sub
= gtk_menu_item_get_submenu (witem
);
3263 if (sub
&& ! cur
->contents
)
3265 /* Not a submenu anymore. */
3266 g_object_ref (G_OBJECT (sub
));
3267 remove_submenu (witem
);
3268 gtk_widget_destroy (sub
);
3270 else if (cur
->contents
)
3274 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3275 select_cb
, deactivate_cb
,
3276 highlight_cb
, cl_data
);
3278 /* If this item just became a submenu, we must set it. */
3280 gtk_menu_item_set_submenu (witem
, nsub
);
3285 /* Structural difference. Remove everything from here and down
3291 /* Remove widgets from first structural change. */
3294 /* If we are adding new menu items below, we must remove from
3295 first radio button so that radio groups become correct. */
3296 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3297 else xg_destroy_widgets (iter
);
3302 /* More items added. Create them. */
3303 newsub
= create_menus (cur
,
3315 if (list
) g_list_free (list
);
3320 /* Update the MENUBAR.
3321 F is the frame the menu bar belongs to.
3322 VAL describes the contents of the menu bar.
3323 If DEEP_P, rebuild all but the top level menu names in
3324 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3325 SELECT_CB is the callback to use when a menu item is selected.
3326 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3327 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3330 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3331 widget_value
*val
, bool deep_p
,
3332 GCallback select_cb
, GCallback deactivate_cb
,
3333 GCallback highlight_cb
)
3335 xg_menu_cb_data
*cl_data
;
3336 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3340 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3342 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3343 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3349 /* Update all sub menus.
3350 We must keep the submenus (GTK menu item widgets) since the
3351 X Window in the XEvent that activates the menu are those widgets. */
3353 /* Update cl_data, menu_item things in F may have changed. */
3354 update_cl_data (cl_data
, f
, highlight_cb
);
3356 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3361 GtkMenuItem
*witem
= 0;
3363 /* Find sub menu that corresponds to val and update it. */
3364 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3366 witem
= GTK_MENU_ITEM (iter
->data
);
3367 if (xg_item_label_same_p (witem
, cur
->name
))
3369 sub
= gtk_menu_item_get_submenu (witem
);
3374 newsub
= xg_update_submenu (sub
,
3381 /* sub may still be NULL. If we just updated non deep and added
3382 a new menu bar item, it has no sub menu yet. So we set the
3383 newly created sub menu under witem. */
3384 if (newsub
!= sub
&& witem
!= 0)
3386 xg_set_screen (newsub
, f
);
3387 gtk_menu_item_set_submenu (witem
, newsub
);
3393 gtk_widget_show_all (menubar
);
3396 /* Callback called when the menu bar W is mapped.
3397 Used to find the height of the menu bar if we didn't get it
3398 after showing the widget. */
3401 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3404 struct frame
*f
= user_data
;
3405 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3406 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3408 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3409 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3413 /* Recompute all the widgets of frame F, when the menu bar has been
3417 xg_update_frame_menubar (struct frame
*f
)
3419 struct x_output
*x
= f
->output_data
.x
;
3422 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3425 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3426 return; /* Already done this, happens for frames created invisible. */
3430 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3432 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3434 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3435 gtk_widget_show_all (x
->menubar_widget
);
3436 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3438 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3440 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3441 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3446 /* Get rid of the menu bar of frame F, and free its storage.
3447 This is used when deleting a frame, and when turning off the menu bar. */
3450 free_frame_menubar (struct frame
*f
)
3452 struct x_output
*x
= f
->output_data
.x
;
3454 if (x
->menubar_widget
)
3458 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3459 /* The menubar and its children shall be deleted when removed from
3461 x
->menubar_widget
= 0;
3462 FRAME_MENUBAR_HEIGHT (f
) = 0;
3463 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3469 xg_event_is_for_menubar (struct frame
*f
, const XEvent
*event
)
3471 struct x_output
*x
= f
->output_data
.x
;
3480 if (! x
->menubar_widget
) return 0;
3482 if (! (event
->xbutton
.x
>= 0
3483 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3484 && event
->xbutton
.y
>= 0
3485 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
3486 && event
->xbutton
.same_screen
))
3489 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3490 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3492 gevent
.any
.window
= gw
;
3493 gevent
.any
.type
= GDK_NOTHING
;
3494 gwdesc
= gtk_get_event_widget (&gevent
);
3495 if (! gwdesc
) return 0;
3496 if (! GTK_IS_MENU_BAR (gwdesc
)
3497 && ! GTK_IS_MENU_ITEM (gwdesc
)
3498 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3501 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3502 if (! list
) return 0;
3503 rec
.x
= event
->xbutton
.x
;
3504 rec
.y
= event
->xbutton
.y
;
3508 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3510 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3511 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3520 /***********************************************************************
3521 Scroll bar functions
3522 ***********************************************************************/
3525 /* Setting scroll bar values invokes the callback. Use this variable
3526 to indicate that callback should do nothing. */
3528 bool xg_ignore_gtk_scrollbar
;
3530 /* Width and height of scroll bars for the current theme. */
3531 static int scroll_bar_width_for_theme
;
3532 static int scroll_bar_height_for_theme
;
3534 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3535 may be larger than 32 bits. Keep a mapping from integer index to widget
3536 pointers to get around the 32 bit limitation. */
3540 GtkWidget
**widgets
;
3545 /* Grow this much every time we need to allocate more */
3547 #define ID_TO_WIDGET_INCR 32
3549 /* Store the widget pointer W in id_to_widget and return the integer index. */
3552 xg_store_widget_in_map (GtkWidget
*w
)
3556 if (id_to_widget
.max_size
== id_to_widget
.used
)
3559 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3560 memory_full (SIZE_MAX
);
3562 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3563 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3564 new_size
, sizeof (GtkWidget
*));
3566 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3567 id_to_widget
.widgets
[i
] = 0;
3568 id_to_widget
.max_size
= new_size
;
3571 /* Just loop over the array and find a free place. After all,
3572 how many scroll bars are we creating? Should be a small number.
3573 The check above guarantees we will find a free place. */
3574 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3576 if (! id_to_widget
.widgets
[i
])
3578 id_to_widget
.widgets
[i
] = w
;
3579 ++id_to_widget
.used
;
3585 /* Should never end up here */
3589 /* Remove pointer at IDX from id_to_widget.
3590 Called when scroll bar is destroyed. */
3593 xg_remove_widget_from_map (ptrdiff_t idx
)
3595 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3597 id_to_widget
.widgets
[idx
] = 0;
3598 --id_to_widget
.used
;
3602 /* Get the widget pointer at IDX from id_to_widget. */
3605 xg_get_widget_from_map (ptrdiff_t idx
)
3607 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3608 return id_to_widget
.widgets
[idx
];
3614 update_theme_scrollbar_width (void)
3617 GtkAdjustment
*vadj
;
3624 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3625 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3626 g_object_ref_sink (G_OBJECT (wscroll
));
3627 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3628 gtk_widget_destroy (wscroll
);
3629 g_object_unref (G_OBJECT (wscroll
));
3634 scroll_bar_width_for_theme
= w
;
3638 update_theme_scrollbar_height (void)
3641 GtkAdjustment
*hadj
;
3648 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
, 0.1, 0.1, 0.1);
3649 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3650 g_object_ref_sink (G_OBJECT (wscroll
));
3651 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3652 gtk_widget_destroy (wscroll
);
3653 g_object_unref (G_OBJECT (wscroll
));
3656 scroll_bar_height_for_theme
= w
;
3660 xg_get_default_scrollbar_width (void)
3662 return scroll_bar_width_for_theme
* xg_get_gdk_scale ();
3666 xg_get_default_scrollbar_height (void)
3668 /* Apparently there's no default height for themes. */
3669 return scroll_bar_width_for_theme
* xg_get_gdk_scale ();
3672 /* Return the scrollbar id for X Window WID on display DPY.
3673 Return -1 if WID not in id_to_widget. */
3676 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3681 w
= xg_win_to_widget (dpy
, wid
);
3685 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3686 if (id_to_widget
.widgets
[idx
] == w
)
3693 /* Callback invoked when scroll bar WIDGET is destroyed.
3694 DATA is the index into id_to_widget for WIDGET.
3695 We free pointer to last scroll bar values here and remove the index. */
3698 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3700 intptr_t id
= (intptr_t) data
;
3701 xg_remove_widget_from_map (id
);
3705 xg_finish_scroll_bar_creation (struct frame
*f
,
3707 struct scroll_bar
*bar
,
3708 GCallback scroll_callback
,
3709 GCallback end_callback
,
3710 const char *scroll_bar_name
)
3712 GtkWidget
*webox
= gtk_event_box_new ();
3714 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3716 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3718 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3720 ptrdiff_t scroll_id
= xg_store_widget_in_map (wscroll
);
3722 g_signal_connect (G_OBJECT (wscroll
),
3724 G_CALLBACK (xg_gtk_scroll_destroy
),
3725 (gpointer
) scroll_id
);
3726 g_signal_connect (G_OBJECT (wscroll
),
3730 g_signal_connect (G_OBJECT (wscroll
),
3731 "button-release-event",
3735 /* The scroll bar widget does not draw on a window of its own. Instead
3736 it draws on the parent window, in this case the edit widget. So
3737 whenever the edit widget is cleared, the scroll bar needs to redraw
3738 also, which causes flicker. Put an event box between the edit widget
3739 and the scroll bar, so the scroll bar instead draws itself on the
3740 event box window. */
3741 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3742 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3744 xg_set_widget_bg (f
, webox
, FRAME_BACKGROUND_PIXEL (f
));
3746 /* N.B. The event box doesn't become a real X11 window until we ask
3747 for its XID via GTK_WIDGET_TO_X_WIN. If the event box is not a
3748 real X window, it and its scroll-bar child try to draw on the
3749 Emacs main window, which we draw over using Xlib. */
3750 gtk_widget_realize (webox
);
3751 GTK_WIDGET_TO_X_WIN (webox
);
3753 /* Set the cursor to an arrow. */
3754 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3756 bar
->x_window
= scroll_id
;
3759 /* Create a scroll bar widget for frame F. Store the scroll bar
3761 SCROLL_CALLBACK is the callback to invoke when the value of the
3763 END_CALLBACK is the callback to invoke when scrolling ends.
3764 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3765 to set resources for the widget. */
3768 xg_create_scroll_bar (struct frame
*f
,
3769 struct scroll_bar
*bar
,
3770 GCallback scroll_callback
,
3771 GCallback end_callback
,
3772 const char *scroll_bar_name
)
3776 GtkAdjustment
*vadj
;
3781 /* Page, step increment values are not so important here, they
3782 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3783 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3786 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3788 xg_finish_scroll_bar_creation (f
, wscroll
, bar
, scroll_callback
,
3789 end_callback
, scroll_bar_name
);
3790 bar
->horizontal
= 0;
3793 /* Create a horizontal scroll bar widget for frame F. Store the scroll
3794 bar in BAR. SCROLL_CALLBACK is the callback to invoke when the value
3795 of the bar changes. END_CALLBACK is the callback to invoke when
3796 scrolling ends. SCROLL_BAR_NAME is the name we use for the scroll
3797 bar. Can be used to set resources for the widget. */
3800 xg_create_horizontal_scroll_bar (struct frame
*f
,
3801 struct scroll_bar
*bar
,
3802 GCallback scroll_callback
,
3803 GCallback end_callback
,
3804 const char *scroll_bar_name
)
3808 GtkAdjustment
*hadj
;
3813 /* Page, step increment values are not so important here, they
3814 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3815 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
,
3818 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3820 xg_finish_scroll_bar_creation (f
, wscroll
, bar
, scroll_callback
,
3821 end_callback
, scroll_bar_name
);
3822 bar
->horizontal
= 1;
3825 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3828 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3830 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3833 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3834 gtk_widget_destroy (w
);
3835 gtk_widget_destroy (wparent
);
3836 SET_FRAME_GARBAGED (f
);
3840 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3842 TOP/LEFT are the new pixel positions where the bar shall appear.
3843 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3846 xg_update_scrollbar_pos (struct frame
*f
,
3847 ptrdiff_t scrollbar_id
,
3853 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3856 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3857 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3859 int scale
= xg_get_gdk_scale ();
3864 left
-= (scale
- 1) * ((width
/ scale
) >> 1);
3866 /* Clear out old position. */
3867 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3868 if (gtk_widget_get_parent (wparent
) == wfixed
)
3870 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3871 "x", &oldx
, "y", &oldy
, NULL
);
3872 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3875 /* Move and resize to new values. */
3876 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3877 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3878 bool hidden
= height
< msl
;
3881 /* No room. Hide scroll bar as some themes output a warning if
3882 the height is less than the min size. */
3883 gtk_widget_hide (wparent
);
3884 gtk_widget_hide (wscroll
);
3888 gtk_widget_show_all (wparent
);
3889 gtk_widget_set_size_request (wscroll
, width
, height
);
3891 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3893 /* Clear under old scroll bar position. */
3894 oldw
+= (scale
- 1) * oldw
;
3895 oldx
-= (scale
- 1) * oldw
;
3896 x_clear_area (f
, oldx
, oldy
, oldw
, oldh
);
3901 GtkWidget
*scrollbar
= xg_get_widget_from_map (scrollbar_id
);
3902 GtkWidget
*webox
= gtk_widget_get_parent (scrollbar
);
3904 /* Don't obscure any child frames. */
3905 XLowerWindow (FRAME_X_DISPLAY (f
), GTK_WIDGET_TO_X_WIN (webox
));
3908 /* GTK does not redraw until the main loop is entered again, but
3909 if there are no X events pending we will not enter it. So we sync
3910 here to get some events. */
3913 SET_FRAME_GARBAGED (f
);
3914 cancel_mouse_face (f
);
3919 /* Update the position of the horizontal scroll bar represented by SCROLLBAR_ID
3921 TOP/LEFT are the new pixel positions where the bar shall appear.
3922 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3925 xg_update_horizontal_scrollbar_pos (struct frame
*f
,
3926 ptrdiff_t scrollbar_id
,
3933 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3937 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3938 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3941 /* Clear out old position. */
3942 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3943 if (gtk_widget_get_parent (wparent
) == wfixed
)
3945 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3946 "x", &oldx
, "y", &oldy
, NULL
);
3947 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3950 /* Move and resize to new values. */
3951 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3952 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3955 /* No room. Hide scroll bar as some themes output a warning if
3956 the width is less than the min size. */
3957 gtk_widget_hide (wparent
);
3958 gtk_widget_hide (wscroll
);
3962 gtk_widget_show_all (wparent
);
3963 gtk_widget_set_size_request (wscroll
, width
, height
);
3965 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3966 /* Clear under old scroll bar position. */
3967 x_clear_area (f
, oldx
, oldy
, oldw
, oldh
);
3969 /* GTK does not redraw until the main loop is entered again, but
3970 if there are no X events pending we will not enter it. So we sync
3971 here to get some events. */
3974 GtkWidget
*scrollbar
=
3975 xg_get_widget_from_map (scrollbar_id
);
3976 GtkWidget
*webox
= gtk_widget_get_parent (scrollbar
);
3978 /* Don't obscure any child frames. */
3979 XLowerWindow (FRAME_X_DISPLAY (f
), GTK_WIDGET_TO_X_WIN (webox
));
3983 SET_FRAME_GARBAGED (f
);
3984 cancel_mouse_face (f
);
3989 /* Get the current value of the range, truncated to an integer. */
3992 int_gtk_range_get_value (GtkRange
*range
)
3994 return gtk_range_get_value (range
);
3998 /* Set the thumb size and position of scroll bar BAR. We are currently
3999 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4002 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
4007 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
4009 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4011 if (wscroll
&& bar
->dragging
== -1)
4021 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
4023 if (scroll_bar_adjust_thumb_portion_p
)
4025 /* We do the same as for MOTIF in xterm.c, use 30 chars per
4026 line rather than the real portion value. This makes the
4027 thumb less likely to resize and that looks better. */
4028 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
4030 /* When the thumb is at the bottom, position == whole.
4031 So we need to increase `whole' to make space for the thumb. */
4039 top
= (gdouble
) position
/ whole
;
4040 shown
= (gdouble
) portion
/ whole
;
4043 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
4044 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
4046 /* Assume all lines are of equal size. */
4047 new_step
= size
/ max (1, FRAME_LINES (f
));
4049 old_size
= gtk_adjustment_get_page_size (adj
);
4050 if (old_size
!= size
)
4052 int old_step
= gtk_adjustment_get_step_increment (adj
);
4053 if (old_step
!= new_step
)
4055 gtk_adjustment_set_page_size (adj
, size
);
4056 gtk_adjustment_set_step_increment (adj
, new_step
);
4057 /* Assume a page increment is about 95% of the page size */
4058 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
4063 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
4067 /* gtk_range_set_value invokes the callback. Set
4068 ignore_gtk_scrollbar to make the callback do nothing */
4069 xg_ignore_gtk_scrollbar
= 1;
4071 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
4072 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
4074 gtk_adjustment_changed (adj
);
4076 xg_ignore_gtk_scrollbar
= 0;
4083 /* Set the thumb size and position of horizontal scroll bar BAR. We are
4084 currently displaying PORTION out of a whole WHOLE, and our position
4087 xg_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
4092 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
4094 if (wscroll
&& bar
->dragging
== -1)
4098 int upper
= max (whole
- 1, 0);
4099 int pagesize
= min (upper
, max (portion
, 0));
4100 int value
= max (0, min (position
, upper
- pagesize
));
4101 /* These should be set to something more <portion, whole>
4103 int page_increment
= 4;
4104 int step_increment
= 1;
4107 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
4108 gtk_adjustment_configure (adj
, (gdouble
) value
, (gdouble
) lower
,
4109 (gdouble
) upper
, (gdouble
) step_increment
,
4110 (gdouble
) page_increment
, (gdouble
) pagesize
);
4111 gtk_adjustment_changed (adj
);
4116 /* Return true if EVENT is for a scroll bar in frame F.
4117 When the same X window is used for several Gtk+ widgets, we cannot
4118 say for sure based on the X window alone if an event is for the
4119 frame. This function does additional checks. */
4122 xg_event_is_for_scrollbar (struct frame
*f
, const XEvent
*event
)
4126 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
4128 /* Check if press occurred outside the edit widget. */
4129 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
4132 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
4133 (gdk_display_get_device_manager (gdpy
));
4134 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
4136 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
4138 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
4141 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
4142 || event
->type
== MotionNotify
))
4144 /* If we are releasing or moving the scroll bar, it has the grab. */
4145 GtkWidget
*w
= gtk_grab_get_current ();
4146 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
4153 /***********************************************************************
4155 ***********************************************************************/
4157 static GtkPrintSettings
*print_settings
= NULL
;
4158 static GtkPageSetup
*page_setup
= NULL
;
4161 xg_page_setup_dialog (void)
4163 GtkPageSetup
*new_page_setup
= NULL
;
4165 if (print_settings
== NULL
)
4166 print_settings
= gtk_print_settings_new ();
4167 new_page_setup
= gtk_print_run_page_setup_dialog (NULL
, page_setup
,
4170 g_object_unref (page_setup
);
4171 page_setup
= new_page_setup
;
4175 xg_get_page_setup (void)
4177 Lisp_Object orientation_symbol
;
4179 if (page_setup
== NULL
)
4180 page_setup
= gtk_page_setup_new ();
4182 switch (gtk_page_setup_get_orientation (page_setup
))
4184 case GTK_PAGE_ORIENTATION_PORTRAIT
:
4185 orientation_symbol
= Qportrait
;
4187 case GTK_PAGE_ORIENTATION_LANDSCAPE
:
4188 orientation_symbol
= Qlandscape
;
4190 case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT
:
4191 orientation_symbol
= Qreverse_portrait
;
4193 case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE
:
4194 orientation_symbol
= Qreverse_landscape
;
4200 return listn (CONSTYPE_HEAP
, 7,
4201 Fcons (Qorientation
, orientation_symbol
),
4202 #define MAKE_FLOAT_PAGE_SETUP(f) make_float (f (page_setup, GTK_UNIT_POINTS))
4204 MAKE_FLOAT_PAGE_SETUP (gtk_page_setup_get_page_width
)),
4206 MAKE_FLOAT_PAGE_SETUP (gtk_page_setup_get_page_height
)),
4207 Fcons (Qleft_margin
,
4208 MAKE_FLOAT_PAGE_SETUP (gtk_page_setup_get_left_margin
)),
4209 Fcons (Qright_margin
,
4210 MAKE_FLOAT_PAGE_SETUP (gtk_page_setup_get_right_margin
)),
4212 MAKE_FLOAT_PAGE_SETUP (gtk_page_setup_get_top_margin
)),
4213 Fcons (Qbottom_margin
,
4214 MAKE_FLOAT_PAGE_SETUP (gtk_page_setup_get_bottom_margin
))
4215 #undef MAKE_FLOAT_PAGE_SETUP
4220 draw_page (GtkPrintOperation
*operation
, GtkPrintContext
*context
,
4221 gint page_nr
, gpointer user_data
)
4223 Lisp_Object frames
= *((Lisp_Object
*) user_data
);
4224 struct frame
*f
= XFRAME (Fnth (make_number (page_nr
), frames
));
4225 cairo_t
*cr
= gtk_print_context_get_cairo_context (context
);
4227 x_cr_draw_frame (cr
, f
);
4231 xg_print_frames_dialog (Lisp_Object frames
)
4233 GtkPrintOperation
*print
;
4234 GtkPrintOperationResult res
;
4236 print
= gtk_print_operation_new ();
4237 if (print_settings
!= NULL
)
4238 gtk_print_operation_set_print_settings (print
, print_settings
);
4239 if (page_setup
!= NULL
)
4240 gtk_print_operation_set_default_page_setup (print
, page_setup
);
4241 gtk_print_operation_set_n_pages (print
, XINT (Flength (frames
)));
4242 g_signal_connect (print
, "draw-page", G_CALLBACK (draw_page
), &frames
);
4243 res
= gtk_print_operation_run (print
, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG
,
4245 if (res
== GTK_PRINT_OPERATION_RESULT_APPLY
)
4247 if (print_settings
!= NULL
)
4248 g_object_unref (print_settings
);
4250 g_object_ref (gtk_print_operation_get_print_settings (print
));
4252 g_object_unref (print
);
4255 #endif /* USE_CAIRO */
4259 /***********************************************************************
4261 ***********************************************************************/
4262 /* The key for the data we put in the GtkImage widgets. The data is
4263 the image used by Emacs. We use this to see if we need to update
4264 the GtkImage with a new image. */
4265 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
4267 /* The key for storing the latest modifiers so the activate callback can
4269 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
4271 /* The key for the data we put in the GtkImage widgets. The data is
4272 the stock name used by Emacs. We use this to see if we need to update
4273 the GtkImage with a new image. */
4274 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
4276 /* As above, but this is used for named theme widgets, as opposed to
4278 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
4280 /* Callback function invoked when a tool bar item is pressed.
4281 W is the button widget in the tool bar that got pressed,
4282 CLIENT_DATA is an integer that is the index of the button in the
4283 tool bar. 0 is the first button. */
4286 xg_tool_bar_button_cb (GtkWidget
*widget
,
4287 GdkEventButton
*event
,
4290 intptr_t state
= event
->state
;
4291 gpointer ptr
= (gpointer
) state
;
4292 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
4297 /* Callback function invoked when a tool bar item is pressed.
4298 W is the button widget in the tool bar that got pressed,
4299 CLIENT_DATA is an integer that is the index of the button in the
4300 tool bar. 0 is the first button. */
4303 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
4305 intptr_t idx
= (intptr_t) client_data
;
4306 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
4307 intptr_t mod
= (intptr_t) gmod
;
4309 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4310 Lisp_Object key
, frame
;
4311 struct input_event event
;
4314 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4317 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4319 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
4320 XSETFRAME (frame
, f
);
4322 /* We generate two events here. The first one is to set the prefix
4323 to `(tool_bar)', see keyboard.c. */
4324 event
.kind
= TOOL_BAR_EVENT
;
4325 event
.frame_or_window
= frame
;
4327 kbd_buffer_store_event (&event
);
4329 event
.kind
= TOOL_BAR_EVENT
;
4330 event
.frame_or_window
= frame
;
4332 /* Convert between the modifier bits GDK uses and the modifier bits
4333 Emacs uses. This assumes GDK and X masks are the same, which they are when
4335 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), mod
);
4336 kbd_buffer_store_event (&event
);
4338 /* Return focus to the frame after we have clicked on a detached
4340 x_focus_frame (f
, false);
4344 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
4346 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
4347 GtkWidget
*c1
= clist
->data
;
4348 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
4350 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4351 g_list_free (clist
);
4352 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4356 /* This callback is called when the mouse enters or leaves a tool bar item.
4357 It is used for displaying and hiding the help text.
4358 W is the tool bar item, a button.
4359 EVENT is either an enter event or leave event.
4360 CLIENT_DATA is an integer that is the index of the button in the
4361 tool bar. 0 is the first button.
4363 Returns FALSE to tell GTK to keep processing this event. */
4366 xg_tool_bar_help_callback (GtkWidget
*w
,
4367 GdkEventCrossing
*event
,
4368 gpointer client_data
)
4370 intptr_t idx
= (intptr_t) client_data
;
4371 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4372 Lisp_Object help
, frame
;
4374 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4377 if (event
->type
== GDK_ENTER_NOTIFY
)
4379 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4380 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4383 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4388 XSETFRAME (frame
, f
);
4389 kbd_buffer_store_help_event (frame
, help
);
4395 /* This callback is called when a tool bar item shall be redrawn.
4396 It modifies the expose event so that the GtkImage widget redraws the
4397 whole image. This to overcome a bug that makes GtkImage draw the image
4398 in the wrong place when it tries to redraw just a part of the image.
4399 W is the GtkImage to be redrawn.
4400 EVENT is the expose event for W.
4401 CLIENT_DATA is unused.
4403 Returns FALSE to tell GTK to keep processing this event. */
4407 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4408 GdkEventExpose
*event
,
4409 gpointer client_data
)
4413 gdk_drawable_get_size (event
->window
, &width
, &height
);
4414 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4415 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4417 event
->area
.x
= max (0, event
->area
.x
);
4418 event
->area
.y
= max (0, event
->area
.y
);
4420 event
->area
.width
= max (width
, event
->area
.width
);
4421 event
->area
.height
= max (height
, event
->area
.height
);
4427 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4428 #define toolbar_set_orientation(w, o) \
4429 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4431 #define toolbar_set_orientation(w, o) \
4432 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4435 /* Attach a tool bar to frame F. */
4438 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4440 struct x_output
*x
= f
->output_data
.x
;
4441 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4442 GtkWidget
*top_widget
= x
->toolbar_widget
;
4444 toolbar_set_orientation (x
->toolbar_widget
,
4446 ? GTK_ORIENTATION_VERTICAL
4447 : GTK_ORIENTATION_HORIZONTAL
);
4451 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4454 if (EQ (pos
, Qleft
))
4455 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4458 x
->toolbar_in_hbox
= true;
4462 bool vbox_pos
= x
->menubar_widget
!= 0;
4463 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4467 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4470 x
->toolbar_in_hbox
= false;
4472 x
->toolbar_is_packed
= true;
4475 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4478 tb_size_cb (GtkWidget
*widget
,
4479 GdkRectangle
*allocation
,
4482 /* When tool bar is created it has one preferred size. But when size is
4483 allocated between widgets, it may get another. So we must update
4484 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4485 struct frame
*f
= user_data
;
4487 if (xg_update_tool_bar_sizes (f
))
4489 frame_size_history_add (f
, Qtb_size_cb
, 0, 0, Qnil
);
4490 adjust_frame_size (f
, -1, -1, 5, 0, Qtool_bar_lines
);
4494 /* Create a tool bar for frame F. */
4497 xg_create_tool_bar (struct frame
*f
)
4499 struct x_output
*x
= f
->output_data
.x
;
4500 #if GTK_CHECK_VERSION (3, 3, 6)
4501 GtkStyleContext
*gsty
;
4503 struct xg_frame_tb_info
*tbinfo
4504 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4508 tbinfo
= xmalloc (sizeof (*tbinfo
));
4509 tbinfo
->last_tool_bar
= Qnil
;
4510 tbinfo
->style
= Qnil
;
4511 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4512 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4513 tbinfo
->n_last_items
= 0;
4514 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4519 x
->toolbar_widget
= gtk_toolbar_new ();
4521 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4523 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4524 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4525 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4526 G_CALLBACK (tb_size_cb
), f
);
4527 #if GTK_CHECK_VERSION (3, 3, 6)
4528 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4529 gtk_style_context_add_class (gsty
, "primary-toolbar");
4534 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4536 /* Find the right-to-left image named by RTL in the tool bar images for F.
4537 Returns IMAGE if RTL is not found. */
4540 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4543 Lisp_Object file
, rtl_name
;
4545 rtl_name
= Ffile_name_nondirectory (rtl
);
4547 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4549 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4550 if (!NILP (file
= file_for_image (rtl_image
)))
4552 file
= call1 (intern ("file-name-sans-extension"),
4553 Ffile_name_nondirectory (file
));
4554 if (! NILP (Fequal (file
, rtl_name
)))
4565 static GtkToolItem
*
4566 xg_make_tool_item (struct frame
*f
,
4568 GtkWidget
**wbutton
,
4570 int i
, bool horiz
, bool text_image
)
4572 GtkToolItem
*ti
= gtk_tool_item_new ();
4573 GtkWidget
*vb
= gtk_box_new (horiz
4574 ? GTK_ORIENTATION_HORIZONTAL
4575 : GTK_ORIENTATION_VERTICAL
,
4577 GtkWidget
*wb
= gtk_button_new ();
4578 /* The eventbox is here so we can have tooltips on disabled items. */
4579 GtkWidget
*weventbox
= gtk_event_box_new ();
4580 #if GTK_CHECK_VERSION (3, 3, 6)
4581 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4582 GtkStyleContext
*gsty
;
4584 gtk_css_provider_load_from_data (css_prov
,
4586 " background-color: transparent;"
4590 gsty
= gtk_widget_get_style_context (weventbox
);
4591 gtk_style_context_add_provider (gsty
,
4592 GTK_STYLE_PROVIDER (css_prov
),
4593 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4594 g_object_unref (css_prov
);
4597 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4599 if (wimage
&& !text_image
)
4600 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4602 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4603 if (wimage
&& text_image
)
4604 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4606 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4607 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4608 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4609 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4610 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4612 if (wimage
|| label
)
4615 gpointer gi
= (gpointer
) ii
;
4617 g_signal_connect (G_OBJECT (wb
), "clicked",
4618 G_CALLBACK (xg_tool_bar_callback
),
4621 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4624 /* Catch expose events to overcome an annoying redraw bug, see
4625 comment for xg_tool_bar_item_expose_callback. */
4626 g_signal_connect (G_OBJECT (ti
),
4628 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4631 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4633 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4634 no distinction based on modifiers in the activate callback,
4635 so we have to do it ourselves. */
4636 g_signal_connect (wb
, "button-release-event",
4637 G_CALLBACK (xg_tool_bar_button_cb
),
4640 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4642 /* Use enter/leave notify to show help. We use the events
4643 rather than the GtkButton specific signals "enter" and
4644 "leave", so we can have only one callback. The event
4645 will tell us what kind of event it is. */
4646 g_signal_connect (G_OBJECT (weventbox
),
4647 "enter-notify-event",
4648 G_CALLBACK (xg_tool_bar_help_callback
),
4650 g_signal_connect (G_OBJECT (weventbox
),
4651 "leave-notify-event",
4652 G_CALLBACK (xg_tool_bar_help_callback
),
4656 if (wbutton
) *wbutton
= wb
;
4662 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4666 if (GTK_IS_BOX (vb
))
4668 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4669 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4670 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4674 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4680 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4681 const char *icon_name
, const struct image
*img
,
4682 const char *label
, bool horiz
)
4686 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4687 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4689 /* Check if the tool icon matches. */
4690 if (stock_name
&& wimage
)
4692 old
= g_object_get_data (G_OBJECT (wimage
),
4693 XG_TOOL_BAR_STOCK_NAME
);
4694 if (!old
|| strcmp (old
, stock_name
))
4697 else if (icon_name
&& wimage
)
4699 old
= g_object_get_data (G_OBJECT (wimage
),
4700 XG_TOOL_BAR_ICON_NAME
);
4701 if (!old
|| strcmp (old
, icon_name
))
4706 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4707 XG_TOOL_BAR_IMAGE_DATA
);
4708 Pixmap old_img
= (Pixmap
) gold_img
;
4709 if (old_img
!= img
->pixmap
)
4713 /* Check button configuration and label. */
4714 if (is_box_type (vb
, horiz
)
4715 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4718 /* Ensure label is correct. */
4720 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4725 xg_update_tool_bar_sizes (struct frame
*f
)
4727 struct x_output
*x
= f
->output_data
.x
;
4729 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4730 GtkWidget
*top_widget
= x
->toolbar_widget
;
4732 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4733 if (x
->toolbar_in_hbox
)
4736 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4738 "position", &pos
, NULL
);
4739 if (pos
== 0) nl
= req
.width
;
4740 else nr
= req
.width
;
4745 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4747 "position", &pos
, NULL
);
4748 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4749 else nb
= req
.height
;
4752 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4753 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4754 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4755 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4757 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4758 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4759 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4760 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4761 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4762 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4771 find_icon_from_name (char *name
,
4772 GtkIconTheme
*icon_theme
,
4775 #if ! GTK_CHECK_VERSION (3, 10, 0)
4776 GtkStockItem stock_item
;
4779 if (name
[0] == 'n' && name
[1] == ':')
4781 *icon_name
= name
+ 2;
4784 if (! gtk_icon_theme_has_icon (icon_theme
, *icon_name
))
4788 #if ! GTK_CHECK_VERSION (3, 10, 0)
4789 else if (gtk_stock_lookup (name
, &stock_item
))
4792 else if (gtk_icon_theme_has_icon (icon_theme
, name
))
4807 /* Update the tool bar for frame F. Add new buttons and remove old. */
4810 update_frame_tool_bar (struct frame
*f
)
4813 struct x_output
*x
= f
->output_data
.x
;
4814 int hmargin
= 0, vmargin
= 0;
4815 GtkToolbar
*wtoolbar
;
4817 GtkTextDirection dir
;
4819 bool text_image
, horiz
;
4820 struct xg_frame_tb_info
*tbinfo
;
4822 GtkIconTheme
*icon_theme
;
4825 if (! FRAME_GTK_WIDGET (f
))
4830 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4832 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4833 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4835 else if (CONSP (Vtool_bar_button_margin
))
4837 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4838 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4840 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4841 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4844 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4845 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4846 i.e. zero. This means that margins less than
4847 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4848 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4849 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4851 if (! x
->toolbar_widget
)
4852 xg_create_tool_bar (f
);
4854 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4855 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4857 style
= Ftool_bar_get_system_style ();
4858 screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4859 icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4861 /* Are we up to date? */
4862 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4865 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4866 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4867 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4868 && tbinfo
->dir
== dir
4869 && ! NILP (Fequal (tbinfo
->style
, style
))
4870 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4876 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4877 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4878 tbinfo
->style
= style
;
4879 tbinfo
->hmargin
= hmargin
;
4880 tbinfo
->vmargin
= vmargin
;
4883 text_image
= EQ (style
, Qtext_image_horiz
);
4884 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4886 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4888 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4889 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4893 struct image
*img
= NULL
;
4895 Lisp_Object stock
= Qnil
;
4896 char *stock_name
= NULL
;
4897 char *icon_name
= NULL
;
4899 GtkWidget
*wbutton
= NULL
;
4900 Lisp_Object specified_file
;
4901 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4903 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4904 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4905 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4908 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4910 /* If this is a separator, use a gtk separator item. */
4911 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4913 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4916 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4918 ti
= gtk_separator_tool_item_new ();
4919 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4925 /* Otherwise, the tool-bar item is an ordinary button. */
4927 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4929 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4933 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4935 /* Ignore invalid image specifications. */
4936 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4937 if (!valid_image_p (image
))
4940 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4945 specified_file
= file_for_image (image
);
4946 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4947 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4952 for (tem
= stock
; CONSP (tem
); tem
= XCDR (tem
))
4953 if (! NILP (tem
) && STRINGP (XCAR (tem
)))
4955 stock_name
= find_icon_from_name (SSDATA (XCAR (tem
)),
4958 if (stock_name
|| icon_name
) break;
4961 else if (STRINGP (stock
))
4963 stock_name
= find_icon_from_name (SSDATA (stock
),
4968 if (stock_name
|| icon_name
)
4969 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4971 if (stock_name
== NULL
&& icon_name
== NULL
)
4973 /* No stock image, or stock item not known. Try regular
4974 image. If image is a vector, choose it according to the
4976 if (dir
== GTK_TEXT_DIR_RTL
4977 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4979 image
= find_rtl_image (f
, image
, rtl
);
4981 if (VECTORP (image
))
4985 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4986 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4989 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4990 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4992 eassert (ASIZE (image
) >= idx
);
4993 image
= AREF (image
, idx
);
4998 img_id
= lookup_image (f
, image
);
4999 img
= IMAGE_FROM_ID (f
, img_id
);
5000 prepare_image_for_display (f
, img
);
5002 if (img
->load_failed_p
|| img
->pixmap
== None
)
5005 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
5011 /* If there is an existing widget, check if it's stale; if so,
5012 remove it and make a new tool item from scratch. */
5013 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
5016 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
5025 /* Save the image so we can see if an update is needed the
5026 next time we call xg_tool_item_match_p. */
5027 if (EQ (style
, Qtext
))
5029 else if (stock_name
)
5032 #if GTK_CHECK_VERSION (3, 10, 0)
5033 w
= gtk_image_new_from_icon_name (stock_name
, icon_size
);
5035 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
5037 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
5038 (gpointer
) xstrdup (stock_name
),
5039 (GDestroyNotify
) xfree
);
5043 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
5044 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
5045 (gpointer
) xstrdup (icon_name
),
5046 (GDestroyNotify
) xfree
);
5050 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
5051 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
5052 (gpointer
)img
->pixmap
);
5055 #if GTK_CHECK_VERSION (3, 14, 0)
5058 gtk_widget_set_margin_start (w
, hmargin
);
5059 gtk_widget_set_margin_end (w
, hmargin
);
5060 gtk_widget_set_margin_top (w
, vmargin
);
5061 gtk_widget_set_margin_bottom (w
, vmargin
);
5064 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
5066 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
5067 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
5072 gtk_widget_set_sensitive (wbutton
, enabled_p
);
5076 /* Remove buttons not longer needed. */
5079 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
5081 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
5082 } while (ti
!= NULL
);
5084 if (f
->n_tool_bar_items
!= 0)
5086 if (! x
->toolbar_is_packed
)
5087 xg_pack_tool_bar (f
, FRAME_TOOL_BAR_POSITION (f
));
5088 gtk_widget_show_all (x
->toolbar_widget
);
5089 if (xg_update_tool_bar_sizes (f
))
5092 = ((f
->after_make_frame
5093 && !f
->tool_bar_resized
5094 && (EQ (frame_inhibit_implied_resize
, Qt
)
5095 || (CONSP (frame_inhibit_implied_resize
)
5096 && !NILP (Fmemq (Qtool_bar_lines
,
5097 frame_inhibit_implied_resize
))))
5098 /* This will probably fail to DTRT in the
5099 fullheight/-width cases. */
5100 && NILP (get_frame_param (f
, Qfullscreen
)))
5104 frame_size_history_add (f
, Qupdate_frame_tool_bar
, 0, 0, Qnil
);
5105 adjust_frame_size (f
, -1, -1, inhibit
, 0, Qtool_bar_lines
);
5107 f
->tool_bar_resized
= f
->tool_bar_redisplayed
;
5113 /* Deallocate all resources for the tool bar on frame F.
5114 Remove the tool bar. */
5117 free_frame_tool_bar (struct frame
*f
)
5119 struct x_output
*x
= f
->output_data
.x
;
5121 if (x
->toolbar_widget
)
5123 struct xg_frame_tb_info
*tbinfo
;
5124 GtkWidget
*top_widget
= x
->toolbar_widget
;
5127 if (x
->toolbar_is_packed
)
5129 if (x
->toolbar_in_hbox
)
5130 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5133 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5137 gtk_widget_destroy (x
->toolbar_widget
);
5139 x
->toolbar_widget
= 0;
5140 x
->toolbar_widget
= 0;
5141 x
->toolbar_is_packed
= false;
5142 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
5143 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
5145 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5150 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5155 frame_size_history_add (f
, Qfree_frame_tool_bar
, 0, 0, Qnil
);
5156 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5163 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
5165 struct x_output
*x
= f
->output_data
.x
;
5166 GtkWidget
*top_widget
= x
->toolbar_widget
;
5168 if (! x
->toolbar_widget
|| ! top_widget
)
5172 g_object_ref (top_widget
);
5173 if (x
->toolbar_is_packed
)
5175 if (x
->toolbar_in_hbox
)
5176 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5179 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5183 xg_pack_tool_bar (f
, pos
);
5184 g_object_unref (top_widget
);
5186 if (xg_update_tool_bar_sizes (f
))
5188 frame_size_history_add (f
, Qxg_change_toolbar_position
, 0, 0, Qnil
);
5189 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5198 /***********************************************************************
5200 ***********************************************************************/
5202 xg_initialize (void)
5204 GtkBindingSet
*binding_set
;
5205 GtkSettings
*settings
;
5208 /* Work around a bug with corrupted data if libXft gets unloaded. This way
5209 we keep it permanently linked in. */
5214 xg_ignore_gtk_scrollbar
= 0;
5215 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
5216 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
5218 id_to_widget
.max_size
= id_to_widget
.used
= 0;
5219 id_to_widget
.widgets
= 0;
5221 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
5222 (gdk_display_get_default ()));
5223 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5224 bindings. It doesn't seem to be any way to remove properties,
5225 so we set it to "" which in means "no key". */
5226 gtk_settings_set_string_property (settings
,
5227 "gtk-menu-bar-accel",
5231 /* Make GTK text input widgets use Emacs style keybindings. This is
5233 gtk_settings_set_string_property (settings
,
5234 "gtk-key-theme-name",
5238 /* Make dialogs close on C-g. Since file dialog inherits from
5239 dialog, this works for them also. */
5240 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
5241 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5244 /* Make menus close on C-g. */
5245 binding_set
= gtk_binding_set_by_class (g_type_class_ref
5246 (GTK_TYPE_MENU_SHELL
));
5247 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5249 update_theme_scrollbar_width ();
5250 update_theme_scrollbar_height ();
5252 #ifdef HAVE_FREETYPE
5253 x_last_font_name
= NULL
;
5257 #endif /* USE_GTK */