1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2014 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
30 #include "blockinput.h"
31 #include "syssignal.h"
35 #include "termhooks.h"
41 #include <gdk/gdkkeysyms.h>
42 #include "xsettings.h"
45 #include <X11/Xft/Xft.h>
50 #include "emacsgtkfixed.h"
53 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
54 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
56 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
57 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
59 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
60 #define gtk_widget_set_has_window(w, b) \
61 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
63 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
64 #define gtk_dialog_get_action_area(w) ((w)->action_area)
65 #define gtk_dialog_get_content_area(w) ((w)->vbox)
67 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
68 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
70 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
71 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
72 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
73 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
74 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
76 #if GTK_CHECK_VERSION (2, 12, 0)
77 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
79 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
83 #if GTK_CHECK_VERSION (3, 2, 0)
84 #define USE_NEW_GTK_FONT_CHOOSER 1
86 #define USE_NEW_GTK_FONT_CHOOSER 0
87 #define gtk_font_chooser_dialog_new(x, y) \
88 gtk_font_selection_dialog_new (x)
89 #undef GTK_FONT_CHOOSER
90 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
91 #define gtk_font_chooser_set_font(x, y) \
92 gtk_font_selection_dialog_set_font_name (x, y)
94 #endif /* HAVE_FREETYPE */
96 #if GTK_CHECK_VERSION (3, 10, 0)
97 #define XG_TEXT_CANCEL "Cancel"
98 #define XG_TEXT_OK "OK"
99 #define XG_TEXT_OPEN "Open"
101 #define XG_TEXT_CANCEL GTK_STOCK_CANCEL
102 #define XG_TEXT_OK GTK_STOCK_OK
103 #define XG_TEXT_OPEN GTK_STOCK_OPEN
107 #ifdef USE_GTK_TOOLTIP
108 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
110 #define gdk_window_get_geometry(w, a, b, c, d) \
111 gdk_window_get_geometry (w, a, b, c, d, 0)
112 #define gdk_x11_window_lookup_for_display(d, w) \
113 gdk_xid_table_lookup_for_display (d, w)
114 #define gtk_box_new(ori, spacing) \
115 ((ori) == GTK_ORIENTATION_HORIZONTAL \
116 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
117 #define gtk_scrollbar_new(ori, spacing) \
118 ((ori) == GTK_ORIENTATION_HORIZONTAL \
119 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
121 #define GDK_KEY_g GDK_g
123 #endif /* HAVE_GTK3 */
125 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
127 static void update_theme_scrollbar_width (void);
128 static void update_theme_scrollbar_height (void);
130 #define TB_INFO_KEY "xg_frame_tb_info"
131 struct xg_frame_tb_info
133 Lisp_Object last_tool_bar
;
136 int hmargin
, vmargin
;
137 GtkTextDirection dir
;
141 /***********************************************************************
142 Display handling functions
143 ***********************************************************************/
145 /* Keep track of the default display, or NULL if there is none. Emacs
146 may close all its displays. */
148 static GdkDisplay
*gdpy_def
;
150 /* When the GTK widget W is to be created on a display for F that
151 is not the default display, set the display for W.
152 W can be a GtkMenu or a GtkWindow widget. */
155 xg_set_screen (GtkWidget
*w
, struct frame
*f
)
157 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
159 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
160 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
163 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
165 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
170 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
171 *DPY is set to NULL if the display can't be opened.
173 Returns non-zero if display could be opened, zero if display could not
174 be opened, and less than zero if the GTK version doesn't support
175 multiple displays. */
178 xg_display_open (char *display_name
, Display
**dpy
)
182 gdpy
= gdk_display_open (display_name
);
183 if (!gdpy_def
&& gdpy
)
186 gdk_display_manager_set_default_display (gdk_display_manager_get (),
190 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
194 /* Close display DPY. */
197 xg_display_close (Display
*dpy
)
199 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
201 /* If this is the default display, try to change it before closing.
202 If there is no other display to use, gdpy_def is set to NULL, and
203 the next call to xg_display_open resets the default display. */
204 if (gdk_display_get_default () == gdpy
)
206 struct x_display_info
*dpyinfo
;
207 GdkDisplay
*gdpy_new
= NULL
;
209 /* Find another display. */
210 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
211 if (dpyinfo
->display
!= dpy
)
213 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
214 gdk_display_manager_set_default_display (gdk_display_manager_get (),
221 #if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
222 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
223 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
224 can continue running, but there will be memory leaks. */
225 g_object_run_dispose (G_OBJECT (gdpy
));
227 /* This seems to be fixed in GTK 2.10. */
228 gdk_display_close (gdpy
);
233 /***********************************************************************
235 ***********************************************************************/
237 /* Create and return the cursor to be used for popup menus and
238 scroll bars on display DPY. */
241 xg_create_default_cursor (Display
*dpy
)
243 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
244 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
248 xg_get_pixbuf_from_pixmap (struct frame
*f
, Pixmap pix
)
253 unsigned int width
, height
, uunused
;
256 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
257 &width
, &height
, &uunused
, &uunused
);
259 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
263 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
276 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
279 xg_get_pixbuf_from_pix_and_mask (struct frame
*f
,
284 GdkPixbuf
*icon_buf
, *tmp_buf
;
286 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
287 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
288 g_object_unref (G_OBJECT (tmp_buf
));
290 width
= gdk_pixbuf_get_width (icon_buf
);
291 height
= gdk_pixbuf_get_height (icon_buf
);
295 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
296 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
297 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
298 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
299 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
302 for (y
= 0; y
< height
; ++y
)
304 guchar
*iconptr
, *maskptr
;
307 iconptr
= pixels
+ y
* rowstride
;
308 maskptr
= mask_pixels
+ y
* mask_rowstride
;
310 for (x
= 0; x
< width
; ++x
)
312 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
313 just R is sufficient. */
315 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
317 iconptr
+= rowstride
/width
;
318 maskptr
+= mask_rowstride
/width
;
322 g_object_unref (G_OBJECT (mask_buf
));
329 file_for_image (Lisp_Object image
)
331 Lisp_Object specified_file
= Qnil
;
334 for (tail
= XCDR (image
);
335 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
336 tail
= XCDR (XCDR (tail
)))
337 if (EQ (XCAR (tail
), QCfile
))
338 specified_file
= XCAR (XCDR (tail
));
340 return specified_file
;
343 /* For the image defined in IMG, make and return a GtkImage. For displays with
344 8 planes or less we must make a GdkPixbuf and apply the mask manually.
345 Otherwise the highlighting and dimming the tool bar code in GTK does
346 will look bad. For display with more than 8 planes we just use the
347 pixmap and mask directly. For monochrome displays, GTK doesn't seem
348 able to use external pixmaps, it looks bad whatever we do.
349 The image is defined on the display where frame F is.
350 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
351 If OLD_WIDGET is NULL, a new widget is constructed and returned.
352 If OLD_WIDGET is not NULL, that widget is modified. */
355 xg_get_image_for_pixmap (struct frame
*f
,
358 GtkImage
*old_widget
)
362 /* If we have a file, let GTK do all the image handling.
363 This seems to be the only way to make insensitive and activated icons
364 look good in all cases. */
365 Lisp_Object specified_file
= file_for_image (img
->spec
);
368 /* We already loaded the image once before calling this
369 function, so this only fails if the image file has been removed.
370 In that case, use the pixmap already loaded. */
372 if (STRINGP (specified_file
)
373 && STRINGP (file
= x_find_image_file (specified_file
)))
376 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
378 gtk_image_set_from_file (old_widget
, SSDATA (file
));
380 return GTK_WIDGET (old_widget
);
383 /* No file, do the image handling ourselves. This will look very bad
384 on a monochrome display, and sometimes bad on all displays with
387 /* This is a workaround to make icons look good on pseudo color
388 displays. Apparently GTK expects the images to have an alpha
389 channel. If they don't, insensitive and activated icons will
390 look bad. This workaround does not work on monochrome displays,
391 and is strictly not needed on true color/static color displays (i.e.
392 16 bits and higher). But we do it anyway so we get a pixbuf that is
393 not associated with the img->pixmap. The img->pixmap may be removed
394 by clearing the image cache and then the tool bar redraw fails, since
395 Gtk+ assumes the pixmap is always there. */
396 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
401 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
403 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
405 g_object_unref (G_OBJECT (icon_buf
));
408 return GTK_WIDGET (old_widget
);
412 /* Set CURSOR on W and all widgets W contain. We must do like this
413 for scroll bars and menu because they create widgets internally,
414 and it is those widgets that are visible. */
417 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
419 GdkWindow
*window
= gtk_widget_get_window (w
);
420 GList
*children
= gdk_window_peek_children (window
);
422 gdk_window_set_cursor (window
, cursor
);
424 /* The scroll bar widget has more than one GDK window (had to look at
425 the source to figure this out), and there is no way to set cursor
426 on widgets in GTK. So we must set the cursor for all GDK windows.
429 for ( ; children
; children
= g_list_next (children
))
430 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
433 /* Insert NODE into linked LIST. */
436 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
438 xg_list_node
*list_start
= list
->next
;
440 if (list_start
) list_start
->prev
= node
;
441 node
->next
= list_start
;
446 /* Remove NODE from linked LIST. */
449 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
451 xg_list_node
*list_start
= list
->next
;
452 if (node
== list_start
)
454 list
->next
= node
->next
;
455 if (list
->next
) list
->next
->prev
= 0;
459 node
->prev
->next
= node
->next
;
460 if (node
->next
) node
->next
->prev
= node
->prev
;
464 /* Allocate and return a utf8 version of STR. If STR is already
465 utf8 or NULL, just return a copy of STR.
466 A new string is allocated and the caller must free the result
470 get_utf8_string (const char *str
)
474 if (!str
) return NULL
;
476 /* If not UTF-8, try current locale. */
477 if (!g_utf8_validate (str
, -1, NULL
))
478 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
480 return g_strdup (str
);
484 /* Probably some control characters in str. Escape them. */
486 ptrdiff_t nr_bad
= 0;
489 unsigned char *p
= (unsigned char *)str
;
493 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
494 &bytes_written
, &err
))
495 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
498 p
+= bytes_written
+1;
511 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
512 memory_full (SIZE_MAX
);
513 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
514 p
= (unsigned char *)str
;
516 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
517 &bytes_written
, &err
))
518 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
520 memcpy (up
, p
, bytes_written
);
522 up
+= sprintf (up
, "\\%03o", p
[bytes_written
]);
523 p
+= bytes_written
+ 1;
542 /* Check for special colors used in face spec for region face.
543 The colors are fetched from the Gtk+ theme.
544 Return true if color was found, false if not. */
547 xg_check_special_colors (struct frame
*f
,
548 const char *color_name
,
552 bool get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
553 bool get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
555 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
561 GtkStyleContext
*gsty
562 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
564 char buf
[sizeof "rgb://rrrr/gggg/bbbb"];
565 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
567 gtk_style_context_get_color (gsty
, state
, &col
);
569 gtk_style_context_get_background_color (gsty
, state
, &col
);
571 sprintf (buf
, "rgb:%04x/%04x/%04x",
572 (int)(col
.red
* 65535),
573 (int)(col
.green
* 65535),
574 (int)(col
.blue
* 65535));
575 success_p
= (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
579 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
580 GdkColor
*grgb
= get_bg
581 ? &gsty
->bg
[GTK_STATE_SELECTED
]
582 : &gsty
->fg
[GTK_STATE_SELECTED
];
584 color
->red
= grgb
->red
;
585 color
->green
= grgb
->green
;
586 color
->blue
= grgb
->blue
;
587 color
->pixel
= grgb
->pixel
;
598 /***********************************************************************
600 ***********************************************************************/
601 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
602 We use that to pop down the tooltip. This happens if Gtk+ for some
603 reason wants to change or hide the tooltip. */
605 #ifdef USE_GTK_TOOLTIP
608 hierarchy_ch_cb (GtkWidget
*widget
,
609 GtkWidget
*previous_toplevel
,
612 struct frame
*f
= user_data
;
613 struct x_output
*x
= f
->output_data
.x
;
614 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
616 if (! top
|| ! GTK_IS_WINDOW (top
))
617 gtk_widget_hide (previous_toplevel
);
620 /* Callback called when Gtk+ thinks a tooltip should be displayed.
621 We use it to get the tooltip window and the tooltip widget so
622 we can manipulate the ourselves.
624 Return FALSE ensures that the tooltip is not shown. */
627 qttip_cb (GtkWidget
*widget
,
630 gboolean keyboard_mode
,
634 struct frame
*f
= user_data
;
635 struct x_output
*x
= f
->output_data
.x
;
636 if (x
->ttip_widget
== NULL
)
641 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
642 x
->ttip_widget
= tooltip
;
643 g_object_ref (G_OBJECT (tooltip
));
644 x
->ttip_lbl
= gtk_label_new ("");
645 g_object_ref (G_OBJECT (x
->ttip_lbl
));
646 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
647 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
649 /* Change stupid Gtk+ default line wrapping. */
650 p
= gtk_widget_get_parent (x
->ttip_lbl
);
651 list
= gtk_container_get_children (GTK_CONTAINER (p
));
652 for (iter
= list
; iter
; iter
= g_list_next (iter
))
654 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
655 if (GTK_IS_LABEL (w
))
656 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
660 /* ATK needs an empty title for some reason. */
661 gtk_window_set_title (x
->ttip_window
, "");
662 /* Realize so we can safely get screen later on. */
663 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
664 gtk_widget_realize (x
->ttip_lbl
);
666 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
667 G_CALLBACK (hierarchy_ch_cb
), f
);
672 #endif /* USE_GTK_TOOLTIP */
674 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
675 Return true if a system tooltip is available. */
678 xg_prepare_tooltip (struct frame
*f
,
683 #ifndef USE_GTK_TOOLTIP
686 struct x_output
*x
= f
->output_data
.x
;
690 GtkSettings
*settings
;
691 gboolean tt_enabled
= TRUE
;
693 Lisp_Object encoded_string
;
695 if (!x
->ttip_lbl
) return 0;
698 encoded_string
= ENCODE_UTF_8 (string
);
699 widget
= GTK_WIDGET (x
->ttip_lbl
);
700 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
701 screen
= gdk_window_get_screen (gwin
);
702 settings
= gtk_settings_get_for_screen (screen
);
703 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
706 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
707 /* Record that we disabled it so it can be enabled again. */
708 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
712 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
713 g_object_set_data (G_OBJECT
714 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
715 "gdk-display-current-tooltip", NULL
);
717 /* Put our dummy widget in so we can get callbacks for unrealize and
718 hierarchy-changed. */
719 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
720 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
721 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
722 if (width
) *width
= req
.width
;
723 if (height
) *height
= req
.height
;
728 #endif /* USE_GTK_TOOLTIP */
731 /* Show the tooltip at ROOT_X and ROOT_Y.
732 xg_prepare_tooltip must have been called before this function. */
735 xg_show_tooltip (struct frame
*f
, int root_x
, int root_y
)
737 #ifdef USE_GTK_TOOLTIP
738 struct x_output
*x
= f
->output_data
.x
;
742 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
743 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
749 /* Hide tooltip if shown. Do nothing if not shown.
750 Return true if tip was hidden, false if not (i.e. not using
754 xg_hide_tooltip (struct frame
*f
)
757 #ifdef USE_GTK_TOOLTIP
758 if (f
->output_data
.x
->ttip_window
)
760 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
762 gtk_widget_hide (GTK_WIDGET (win
));
764 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
766 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
767 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
768 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
769 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
780 /***********************************************************************
781 General functions for creating widgets, resizing, events, e.t.c.
782 ***********************************************************************/
785 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
786 const gchar
*msg
, gpointer user_data
)
788 if (!strstr (msg
, "visible children"))
789 fprintf (stderr
, "XX %s-WARNING **: %s\n", log_domain
, msg
);
792 /* Make a geometry string and pass that to GTK. It seems this is the
793 only way to get geometry position right if the user explicitly
794 asked for a position when starting Emacs.
795 F is the frame we shall set geometry for. */
798 xg_set_geometry (struct frame
*f
)
800 if (f
->size_hint_flags
& (USPosition
| PPosition
))
802 int left
= f
->left_pos
;
803 int xneg
= f
->size_hint_flags
& XNegative
;
804 int top
= f
->top_pos
;
805 int yneg
= f
->size_hint_flags
& YNegative
;
806 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
814 sprintf (geom_str
, "=%dx%d%c%d%c%d",
815 FRAME_PIXEL_WIDTH (f
),
816 FRAME_PIXEL_HEIGHT (f
),
817 (xneg
? '-' : '+'), left
,
818 (yneg
? '-' : '+'), top
);
820 /* Silence warning about visible children. */
821 id
= g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
822 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
824 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
826 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
828 g_log_remove_handler ("Gtk", id
);
832 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
833 and use a GtkFixed widget, this doesn't happen automatically. */
836 xg_clear_under_internal_border (struct frame
*f
)
838 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
840 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
842 gtk_widget_queue_draw (wfixed
);
843 gdk_window_process_all_updates ();
845 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0, 0,
846 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
848 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0, 0,
849 FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
851 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0,
852 FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
853 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
855 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
856 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
857 0, FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
861 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
862 and a Gtk+ menu bar, we get resize events for the edit part of the
863 frame only. We let Gtk+ deal with the Gtk+ parts.
864 F is the frame to resize.
865 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
868 xg_frame_resized (struct frame
*f
, int pixelwidth
, int pixelheight
)
872 if (pixelwidth
== -1 && pixelheight
== -1)
874 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
875 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
877 &pixelwidth
, &pixelheight
);
882 width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
);
883 height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
);
885 if (width
!= FRAME_TEXT_WIDTH (f
)
886 || height
!= FRAME_TEXT_HEIGHT (f
)
887 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
888 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
890 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
891 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
893 xg_clear_under_internal_border (f
);
894 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
895 SET_FRAME_GARBAGED (f
);
896 cancel_mouse_face (f
);
898 do_pending_window_change (0);
902 /* Resize the outer window of frame F after changing the height.
903 COLUMNS/ROWS is the size the edit area shall have after the resize. */
906 xg_frame_set_char_size (struct frame
*f
, int width
, int height
)
908 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
909 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
911 if (FRAME_PIXEL_HEIGHT (f
) == 0)
914 /* Do this before resize, as we don't know yet if we will be resized. */
915 xg_clear_under_internal_border (f
);
917 /* Must resize our top level widget. Font size may have changed,
918 but not rows/cols. */
919 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
920 pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
),
921 pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
)
922 + FRAME_MENUBAR_HEIGHT (f
));
923 x_wm_set_size_hint (f
, 0, 0);
925 SET_FRAME_GARBAGED (f
);
926 cancel_mouse_face (f
);
928 /* We can not call change_frame_size for a mapped frame,
929 we can not set pixel width/height either. The window manager may
930 override our resize request, XMonad does this all the time.
931 The best we can do is try to sync, so lisp code sees the updated
932 size as fast as possible.
933 For unmapped windows, we can set rows/cols. When
934 the frame is mapped again we will (hopefully) get the correct size. */
935 if (FRAME_VISIBLE_P (f
))
937 /* Must call this to flush out events */
938 (void)gtk_events_pending ();
940 x_wait_for_event (f
, ConfigureNotify
);
943 adjust_frame_size (f
, -1, -1, 5, 0);
946 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
947 The policy is to keep the number of editable lines. */
950 xg_height_or_width_changed (struct frame
*f
)
952 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
953 FRAME_TOTAL_PIXEL_WIDTH (f
),
954 FRAME_TOTAL_PIXEL_HEIGHT (f
));
955 f
->output_data
.x
->hint_flags
= 0;
956 x_wm_set_size_hint (f
, 0, 0);
959 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
960 Must be done like this, because GtkWidget:s can have "hidden"
961 X Window that aren't accessible.
963 Return 0 if no widget match WDESC. */
966 xg_win_to_widget (Display
*dpy
, Window wdesc
)
969 GtkWidget
*gwdesc
= 0;
973 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
978 event
.any
.window
= gdkwin
;
979 event
.any
.type
= GDK_NOTHING
;
980 gwdesc
= gtk_get_event_widget (&event
);
987 /* Set the background of widget W to PIXEL. */
990 xg_set_widget_bg (struct frame
*f
, GtkWidget
*w
, unsigned long pixel
)
996 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
998 bg
.red
= (double)xbg
.red
/65535.0;
999 bg
.green
= (double)xbg
.green
/65535.0;
1000 bg
.blue
= (double)xbg
.blue
/65535.0;
1002 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1006 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1007 gdk_colormap_query_color (map
, pixel
, &bg
);
1008 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1012 /* Callback called when the gtk theme changes.
1013 We notify lisp code so it can fix faces used for region for example. */
1016 style_changed_cb (GObject
*go
,
1020 struct input_event event
;
1021 GdkDisplay
*gdpy
= user_data
;
1022 const char *display_name
= gdk_display_get_name (gdpy
);
1023 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1026 event
.kind
= CONFIG_CHANGED_EVENT
;
1027 event
.frame_or_window
= build_string (display_name
);
1028 /* Theme doesn't change often, so intern is called seldom. */
1029 event
.arg
= intern ("theme-name");
1030 kbd_buffer_store_event (&event
);
1032 update_theme_scrollbar_width ();
1033 update_theme_scrollbar_height ();
1035 /* If scroll bar width changed, we need set the new size on all frames
1039 Lisp_Object rest
, frame
;
1040 FOR_EACH_FRAME (rest
, frame
)
1042 struct frame
*f
= XFRAME (frame
);
1043 if (FRAME_LIVE_P (f
)
1045 && FRAME_X_DISPLAY (f
) == dpy
)
1047 x_set_scroll_bar_default_width (f
);
1048 x_set_scroll_bar_default_height (f
);
1049 xg_frame_set_char_size (f
, FRAME_TEXT_WIDTH (f
), FRAME_TEXT_HEIGHT (f
));
1055 /* Called when a delete-event occurs on WIDGET. */
1058 delete_cb (GtkWidget
*widget
,
1063 /* The event doesn't arrive in the normal event loop. Send event
1065 struct frame
*f
= user_data
;
1066 struct input_event ie
;
1069 ie
.kind
= DELETE_WINDOW_EVENT
;
1070 XSETFRAME (ie
.frame_or_window
, f
);
1071 kbd_buffer_store_event (&ie
);
1077 /* Create and set up the GTK widgets for frame F.
1078 Return true if creation succeeded. */
1081 xg_create_frame_widgets (struct frame
*f
)
1084 GtkWidget
*wvbox
, *whbox
;
1093 if (FRAME_X_EMBEDDED_P (f
))
1095 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1096 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1099 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1101 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1102 has backported it to Gtk+ 2.0 and they add the resize grip for
1103 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1104 forever, so disable the grip. */
1105 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1106 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1107 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1110 xg_set_screen (wtop
, f
);
1112 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1113 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1114 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1115 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1118 wfixed
= emacs_fixed_new (f
);
1120 wfixed
= gtk_fixed_new ();
1123 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1125 if (wtop
) gtk_widget_destroy (wtop
);
1126 if (wvbox
) gtk_widget_destroy (wvbox
);
1127 if (whbox
) gtk_widget_destroy (whbox
);
1128 if (wfixed
) gtk_widget_destroy (wfixed
);
1134 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1135 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1136 gtk_widget_set_name (wvbox
, "pane");
1137 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1139 /* If this frame has a title or name, set it in the title bar. */
1140 if (! NILP (f
->title
))
1141 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1142 else if (! NILP (f
->name
))
1143 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1145 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1147 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1148 FRAME_GTK_WIDGET (f
) = wfixed
;
1149 f
->output_data
.x
->vbox_widget
= wvbox
;
1150 f
->output_data
.x
->hbox_widget
= whbox
;
1152 gtk_widget_set_has_window (wfixed
, TRUE
);
1154 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1155 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1156 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1158 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1159 update_frame_tool_bar (f
);
1161 /* We don't want this widget double buffered, because we draw on it
1162 with regular X drawing primitives, so from a GTK/GDK point of
1163 view, the widget is totally blank. When an expose comes, this
1164 will make the widget blank, and then Emacs redraws it. This flickers
1165 a lot, so we turn off double buffering. */
1166 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1168 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1169 SSDATA (Vx_resource_name
),
1170 SSDATA (Vx_resource_class
));
1172 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1173 GTK is to destroy the widget. We want Emacs to do that instead. */
1174 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1175 G_CALLBACK (delete_cb
), f
);
1177 /* Convert our geometry parameters into a geometry string
1179 GTK will itself handle calculating the real position this way. */
1180 xg_set_geometry (f
);
1182 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1184 gtk_widget_add_events (wfixed
,
1185 GDK_POINTER_MOTION_MASK
1187 | GDK_BUTTON_PRESS_MASK
1188 | GDK_BUTTON_RELEASE_MASK
1189 | GDK_KEY_PRESS_MASK
1190 | GDK_ENTER_NOTIFY_MASK
1191 | GDK_LEAVE_NOTIFY_MASK
1192 | GDK_FOCUS_CHANGE_MASK
1193 | GDK_STRUCTURE_MASK
1194 | GDK_VISIBILITY_NOTIFY_MASK
);
1196 /* Must realize the windows so the X window gets created. It is used
1197 by callers of this function. */
1198 gtk_widget_realize (wfixed
);
1199 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1201 /* Since GTK clears its window by filling with the background color,
1202 we must keep X and GTK background in sync. */
1203 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1206 /* Also, do not let any background pixmap to be set, this looks very
1207 bad as Emacs overwrites the background pixmap with its own idea
1208 of background color. */
1209 style
= gtk_widget_get_modifier_style (wfixed
);
1211 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1212 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1213 gtk_widget_modify_style (wfixed
, style
);
1215 gtk_widget_set_can_focus (wfixed
, TRUE
);
1216 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1219 #ifdef USE_GTK_TOOLTIP
1220 /* Steal a tool tip window we can move ourselves. */
1221 f
->output_data
.x
->ttip_widget
= 0;
1222 f
->output_data
.x
->ttip_lbl
= 0;
1223 f
->output_data
.x
->ttip_window
= 0;
1224 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1225 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1229 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1230 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1231 /* Only connect this signal once per screen. */
1232 if (! g_signal_handler_find (G_OBJECT (gs
),
1233 G_SIGNAL_MATCH_FUNC
,
1235 G_CALLBACK (style_changed_cb
),
1238 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1239 G_CALLBACK (style_changed_cb
),
1240 gdk_screen_get_display (screen
));
1250 xg_free_frame_widgets (struct frame
*f
)
1252 if (FRAME_GTK_OUTER_WIDGET (f
))
1254 #ifdef USE_GTK_TOOLTIP
1255 struct x_output
*x
= f
->output_data
.x
;
1257 struct xg_frame_tb_info
*tbinfo
1258 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1263 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1264 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1265 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1266 #ifdef USE_GTK_TOOLTIP
1268 gtk_widget_destroy (x
->ttip_lbl
);
1270 g_object_unref (G_OBJECT (x
->ttip_widget
));
1275 /* Set the normal size hints for the window manager, for frame F.
1276 FLAGS is the flags word to use--or 0 meaning preserve the flags
1277 that the window now has.
1278 If USER_POSITION, set the User Position
1279 flag (this is useful when FLAGS is 0). */
1282 x_wm_set_size_hint (struct frame
*f
, long int flags
, bool user_position
)
1284 /* Must use GTK routines here, otherwise GTK resets the size hints
1285 to its own defaults. */
1286 GdkGeometry size_hints
;
1287 gint hint_flags
= 0;
1288 int base_width
, base_height
;
1289 int min_rows
= 0, min_cols
= 0;
1290 int win_gravity
= f
->win_gravity
;
1291 Lisp_Object fs_state
, frame
;
1293 /* Don't set size hints during initialization; that apparently leads
1294 to a race condition. See the thread at
1295 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1296 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1299 XSETFRAME (frame
, f
);
1300 fs_state
= Fframe_parameter (frame
, Qfullscreen
);
1301 if (EQ (fs_state
, Qmaximized
) || EQ (fs_state
, Qfullboth
))
1303 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1304 Gtk3 don't get along and the frame shrinks (!).
1311 memset (&size_hints
, 0, sizeof (size_hints
));
1312 f
->output_data
.x
->size_hints
= size_hints
;
1313 f
->output_data
.x
->hint_flags
= hint_flags
;
1316 flags
= f
->size_hint_flags
;
1318 size_hints
= f
->output_data
.x
->size_hints
;
1319 hint_flags
= f
->output_data
.x
->hint_flags
;
1321 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1322 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
1323 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
1325 hint_flags
|= GDK_HINT_BASE_SIZE
;
1326 /* Use one row/col here so base_height/width does not become zero.
1327 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1328 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1329 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1330 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1332 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1333 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1335 size_hints
.base_width
= base_width
;
1336 size_hints
.base_height
= base_height
;
1337 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);
1338 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
1340 /* These currently have a one to one mapping with the X values, but I
1341 don't think we should rely on that. */
1342 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1343 size_hints
.win_gravity
= 0;
1344 if (win_gravity
== NorthWestGravity
)
1345 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1346 else if (win_gravity
== NorthGravity
)
1347 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1348 else if (win_gravity
== NorthEastGravity
)
1349 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1350 else if (win_gravity
== WestGravity
)
1351 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1352 else if (win_gravity
== CenterGravity
)
1353 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1354 else if (win_gravity
== EastGravity
)
1355 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1356 else if (win_gravity
== SouthWestGravity
)
1357 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1358 else if (win_gravity
== SouthGravity
)
1359 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1360 else if (win_gravity
== SouthEastGravity
)
1361 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1362 else if (win_gravity
== StaticGravity
)
1363 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1367 hint_flags
&= ~GDK_HINT_POS
;
1368 hint_flags
|= GDK_HINT_USER_POS
;
1371 if (hint_flags
!= f
->output_data
.x
->hint_flags
1372 || memcmp (&size_hints
,
1373 &f
->output_data
.x
->size_hints
,
1374 sizeof (size_hints
)) != 0)
1377 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1378 NULL
, &size_hints
, hint_flags
);
1379 f
->output_data
.x
->size_hints
= size_hints
;
1380 f
->output_data
.x
->hint_flags
= hint_flags
;
1385 /* Change background color of a frame.
1386 Since GTK uses the background color to clear the window, we must
1387 keep the GTK and X colors in sync.
1388 F is the frame to change,
1389 BG is the pixel value to change to. */
1392 xg_set_background_color (struct frame
*f
, unsigned long bg
)
1394 if (FRAME_GTK_WIDGET (f
))
1397 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1403 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1404 functions so GTK does not overwrite the icon. */
1407 xg_set_frame_icon (struct frame
*f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1409 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1413 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1418 /***********************************************************************
1420 ***********************************************************************/
1421 /* Return the dialog title to use for a dialog of type KEY.
1422 This is the encoding used by lwlib. We use the same for GTK. */
1425 get_dialog_title (char key
)
1427 const char *title
= "";
1435 title
= "Information";
1454 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1455 the dialog, but return TRUE so the event does not propagate further
1456 in GTK. This prevents GTK from destroying the dialog widget automatically
1457 and we can always destroy the widget manually, regardless of how
1458 it was popped down (button press or WM_DELETE_WINDOW).
1459 W is the dialog widget.
1460 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1461 user_data is NULL (not used).
1463 Returns TRUE to end propagation of event. */
1466 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1468 gtk_widget_unmap (w
);
1472 /* Create a popup dialog window. See also xg_create_widget below.
1473 WV is a widget_value describing the dialog.
1474 SELECT_CB is the callback to use when a button has been pressed.
1475 DEACTIVATE_CB is the callback to use when the dialog pops down.
1477 Returns the GTK dialog widget. */
1480 create_dialog (widget_value
*wv
,
1481 GCallback select_cb
,
1482 GCallback deactivate_cb
)
1484 const char *title
= get_dialog_title (wv
->name
[0]);
1485 int total_buttons
= wv
->name
[1] - '0';
1486 int right_buttons
= wv
->name
[4] - '0';
1489 int button_spacing
= 10;
1490 GtkWidget
*wdialog
= gtk_dialog_new ();
1491 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1493 GtkWidget
*whbox_down
;
1495 /* If the number of buttons is greater than 4, make two rows of buttons
1496 instead. This looks better. */
1497 bool make_two_rows
= total_buttons
> 4;
1499 #if GTK_CHECK_VERSION (3, 12, 0)
1500 GtkBuilder
*gbld
= gtk_builder_new ();
1501 GObject
*go
= gtk_buildable_get_internal_child (GTK_BUILDABLE (wd
),
1504 GtkBox
*cur_box
= GTK_BOX (go
);
1505 g_object_unref (G_OBJECT (gbld
));
1507 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1510 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1511 left_buttons
= total_buttons
- right_buttons
;
1513 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1514 gtk_widget_set_name (wdialog
, "emacs-dialog");
1519 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1520 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1521 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1522 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1523 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1524 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1526 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1527 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1528 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1530 cur_box
= GTK_BOX (whbox_up
);
1533 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1534 G_CALLBACK (dialog_delete_callback
), 0);
1538 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1539 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1542 for (item
= wv
->contents
; item
; item
= item
->next
)
1544 char *utf8_label
= get_utf8_string (item
->value
);
1548 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1550 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1551 /* This is the text part of the dialog. */
1552 w
= gtk_label_new (utf8_label
);
1553 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1554 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1555 #if GTK_CHECK_VERSION (3, 14, 0)
1556 gtk_widget_set_halign (w
, GTK_ALIGN_START
);
1557 gtk_widget_set_valign (w
, GTK_ALIGN_CENTER
);
1559 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1561 /* Try to make dialog look better. Must realize first so
1562 the widget can calculate the size it needs. */
1563 gtk_widget_realize (w
);
1564 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1565 gtk_box_set_spacing (wvbox
, req
.height
);
1566 if (item
->value
&& strlen (item
->value
) > 0)
1567 button_spacing
= 2*req
.width
/strlen (item
->value
);
1568 if (button_spacing
< 10) button_spacing
= 10;
1572 /* This is one button to add to the dialog. */
1573 w
= gtk_button_new_with_label (utf8_label
);
1574 if (! item
->enabled
)
1575 gtk_widget_set_sensitive (w
, FALSE
);
1577 g_signal_connect (G_OBJECT (w
), "clicked",
1578 select_cb
, item
->call_data
);
1580 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1581 if (++button_nr
== left_buttons
)
1584 cur_box
= GTK_BOX (whbox_down
);
1589 g_free (utf8_label
);
1595 struct xg_dialog_data
1603 /* Function that is called when the file or font dialogs pop down.
1604 W is the dialog widget, RESPONSE is the response code.
1605 USER_DATA is what we passed in to g_signal_connect. */
1608 xg_dialog_response_cb (GtkDialog
*w
,
1612 struct xg_dialog_data
*dd
= user_data
;
1613 dd
->response
= response
;
1614 g_main_loop_quit (dd
->loop
);
1618 /* Destroy the dialog. This makes it pop down. */
1621 pop_down_dialog (void *arg
)
1623 struct xg_dialog_data
*dd
= arg
;
1626 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1627 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1629 g_main_loop_quit (dd
->loop
);
1630 g_main_loop_unref (dd
->loop
);
1635 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1636 We pass in DATA as gpointer* so we can use this as a callback. */
1639 xg_maybe_add_timer (gpointer data
)
1641 struct xg_dialog_data
*dd
= data
;
1642 struct timespec next_time
= timer_check ();
1646 if (timespec_valid_p (next_time
))
1648 time_t s
= next_time
.tv_sec
;
1649 int per_ms
= TIMESPEC_RESOLUTION
/ 1000;
1650 int ms
= (next_time
.tv_nsec
+ per_ms
- 1) / per_ms
;
1651 if (s
<= ((guint
) -1 - ms
) / 1000)
1652 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1658 /* Pops up a modal dialog W and waits for response.
1659 We don't use gtk_dialog_run because we want to process emacs timers.
1660 The dialog W is not destroyed when this function returns. */
1663 xg_dialog_run (struct frame
*f
, GtkWidget
*w
)
1665 ptrdiff_t count
= SPECPDL_INDEX ();
1666 struct xg_dialog_data dd
;
1668 xg_set_screen (w
, f
);
1669 gtk_window_set_transient_for (GTK_WINDOW (w
),
1670 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1671 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1672 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1674 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1675 dd
.response
= GTK_RESPONSE_CANCEL
;
1679 g_signal_connect (G_OBJECT (w
),
1681 G_CALLBACK (xg_dialog_response_cb
),
1683 /* Don't destroy the widget if closed by the window manager close button. */
1684 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1685 gtk_widget_show (w
);
1687 record_unwind_protect_ptr (pop_down_dialog
, &dd
);
1689 (void) xg_maybe_add_timer (&dd
);
1690 g_main_loop_run (dd
.loop
);
1693 unbind_to (count
, Qnil
);
1699 /***********************************************************************
1700 File dialog functions
1701 ***********************************************************************/
1702 /* Return true if the old file selection dialog is being used. */
1705 xg_uses_old_file_dialog (void)
1707 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1708 return x_gtk_use_old_file_dialog
;
1715 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1717 /* Return the selected file for file chooser dialog W.
1718 The returned string must be free:d. */
1721 xg_get_file_name_from_chooser (GtkWidget
*w
)
1723 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1726 /* Callback called when the "Show hidden files" toggle is pressed.
1727 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1730 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1732 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1734 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1735 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1739 /* Callback called when a property changes in a file chooser.
1740 GOBJECT is the file chooser dialog, ARG1 describes the property.
1741 USER_DATA is the toggle widget in the file chooser dialog.
1742 We use this to update the "Show hidden files" toggle when the user
1743 changes that property by right clicking in the file list. */
1746 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1748 if (strcmp (arg1
->name
, "show-hidden") == 0)
1750 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1751 gboolean visible
, toggle_on
;
1753 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1754 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1756 if (!!visible
!= !!toggle_on
)
1758 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1759 G_CALLBACK (xg_toggle_visibility_cb
),
1761 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1762 g_signal_handlers_unblock_by_func
1763 (G_OBJECT (wtoggle
),
1764 G_CALLBACK (xg_toggle_visibility_cb
),
1767 x_gtk_show_hidden_files
= visible
;
1771 /* Read a file name from the user using a file chooser dialog.
1772 F is the current frame.
1773 PROMPT is a prompt to show to the user. May not be NULL.
1774 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1775 If MUSTMATCH_P, the returned file name must be an existing
1776 file. (Actually, this only has cosmetic effects, the user can
1777 still enter a non-existing file.) *FUNC is set to a function that
1778 can be used to retrieve the selected file name from the returned widget.
1780 Returns the created widget. */
1783 xg_get_file_with_chooser (struct frame
*f
,
1785 char *default_filename
,
1786 bool mustmatch_p
, bool only_dir_p
,
1787 xg_get_file_func
*func
)
1791 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1792 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1793 GtkFileChooserAction action
= (mustmatch_p
?
1794 GTK_FILE_CHOOSER_ACTION_OPEN
:
1795 GTK_FILE_CHOOSER_ACTION_SAVE
);
1798 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1800 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1801 XG_TEXT_CANCEL
, GTK_RESPONSE_CANCEL
,
1802 (mustmatch_p
|| only_dir_p
?
1803 XG_TEXT_OPEN
: XG_TEXT_OK
),
1806 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1808 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1809 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1810 gtk_widget_show (wbox
);
1811 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1813 if (x_gtk_show_hidden_files
)
1815 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1816 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1818 gtk_widget_show (wtoggle
);
1819 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1820 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1821 g_signal_connect (G_OBJECT (filewin
), "notify",
1822 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1824 if (x_gtk_file_dialog_help_text
)
1827 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1828 Show the C-l help text only for versions < 2.10. */
1829 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1830 strcat (msgbuf
, "\nType C-l to display a file name text entry box.\n");
1831 strcat (msgbuf
, "\nIf you don't like this file selector, use the "
1832 "corresponding\nkey binding or customize "
1833 "use-file-dialog to turn it off.");
1835 wmessage
= gtk_label_new (msgbuf
);
1836 gtk_widget_show (wmessage
);
1839 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1840 if (x_gtk_file_dialog_help_text
)
1841 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1842 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1844 if (default_filename
)
1847 struct gcpro gcpro1
;
1848 char *utf8_filename
;
1851 file
= build_string (default_filename
);
1853 /* File chooser does not understand ~/... in the file name. It must be
1854 an absolute name starting with /. */
1855 if (default_filename
[0] != '/')
1856 file
= Fexpand_file_name (file
, Qnil
);
1858 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1859 if (! NILP (Ffile_directory_p (file
)))
1860 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1864 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1866 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1868 char *cp
= strrchr (utf8_filename
, '/');
1870 else cp
= utf8_filename
;
1871 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1878 *func
= xg_get_file_name_from_chooser
;
1882 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1884 /* Return the selected file for file selector dialog W.
1885 The returned string must be free:d. */
1888 xg_get_file_name_from_selector (GtkWidget
*w
)
1890 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1891 return xstrdup (gtk_file_selection_get_filename (filesel
));
1894 /* Create a file selection dialog.
1895 F is the current frame.
1896 PROMPT is a prompt to show to the user. May not be NULL.
1897 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1898 If MUSTMATCH_P, the returned file name must be an existing
1899 file. *FUNC is set to a function that can be used to retrieve the
1900 selected file name from the returned widget.
1902 Returns the created widget. */
1905 xg_get_file_with_selection (struct frame
*f
,
1907 char *default_filename
,
1908 bool mustmatch_p
, bool only_dir_p
,
1909 xg_get_file_func
*func
)
1912 GtkFileSelection
*filesel
;
1914 filewin
= gtk_file_selection_new (prompt
);
1915 filesel
= GTK_FILE_SELECTION (filewin
);
1917 if (default_filename
)
1918 gtk_file_selection_set_filename (filesel
, default_filename
);
1922 /* The selection_entry part of filesel is not documented. */
1923 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1924 gtk_file_selection_hide_fileop_buttons (filesel
);
1927 *func
= xg_get_file_name_from_selector
;
1931 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1933 /* Read a file name from the user using a file dialog, either the old
1934 file selection dialog, or the new file chooser dialog. Which to use
1935 depends on what the GTK version used has, and what the value of
1936 gtk-use-old-file-dialog.
1937 F is the current frame.
1938 PROMPT is a prompt to show to the user. May not be NULL.
1939 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1940 If MUSTMATCH_P, the returned file name must be an existing
1943 Returns a file name or NULL if no file was selected.
1944 The returned string must be freed by the caller. */
1947 xg_get_file_name (struct frame
*f
,
1949 char *default_filename
,
1955 int filesel_done
= 0;
1956 xg_get_file_func func
;
1958 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1960 if (xg_uses_old_file_dialog ())
1961 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1962 mustmatch_p
, only_dir_p
, &func
);
1964 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1965 mustmatch_p
, only_dir_p
, &func
);
1967 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1968 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1969 mustmatch_p
, only_dir_p
, &func
);
1970 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1972 gtk_widget_set_name (w
, "emacs-filedialog");
1974 filesel_done
= xg_dialog_run (f
, w
);
1975 if (filesel_done
== GTK_RESPONSE_OK
)
1978 gtk_widget_destroy (w
);
1982 /***********************************************************************
1984 ***********************************************************************/
1986 #ifdef HAVE_FREETYPE
1988 #if USE_NEW_GTK_FONT_CHOOSER
1990 #define XG_WEIGHT_TO_SYMBOL(w) \
1991 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
1992 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
1993 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
1994 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
1995 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
1996 : w <= PANGO_WEIGHT_BOLD ? Qbold \
1997 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
2000 #define XG_STYLE_TO_SYMBOL(s) \
2001 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
2002 : s == PANGO_STYLE_ITALIC ? Qitalic \
2005 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2008 static char *x_last_font_name
;
2010 /* Pop up a GTK font selector and return the name of the font the user
2011 selects, as a C string. The returned font name follows GTK's own
2014 `FAMILY [VALUE1 VALUE2] SIZE'
2016 This can be parsed using font_parse_fcname in font.c.
2017 DEFAULT_NAME, if non-zero, is the default font name. */
2020 xg_get_font (struct frame
*f
, const char *default_name
)
2024 Lisp_Object font
= Qnil
;
2026 w
= gtk_font_chooser_dialog_new
2027 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2031 /* Convert fontconfig names to Gtk names, i.e. remove - before
2033 char *p
= strrchr (default_name
, '-');
2037 while (c_isdigit (*ep
))
2039 if (*ep
== '\0') *p
= ' ';
2042 else if (x_last_font_name
)
2043 default_name
= x_last_font_name
;
2046 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2048 gtk_widget_set_name (w
, "emacs-fontdialog");
2049 done
= xg_dialog_run (f
, w
);
2050 if (done
== GTK_RESPONSE_OK
)
2052 #if USE_NEW_GTK_FONT_CHOOSER
2053 /* Use the GTK3 font chooser. */
2054 PangoFontDescription
*desc
2055 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2059 Lisp_Object args
[10];
2060 const char *name
= pango_font_description_get_family (desc
);
2061 gint size
= pango_font_description_get_size (desc
);
2062 PangoWeight weight
= pango_font_description_get_weight (desc
);
2063 PangoStyle style
= pango_font_description_get_style (desc
);
2066 args
[1] = build_string (name
);
2069 args
[3] = make_float (pango_units_to_double (size
));
2072 args
[5] = XG_WEIGHT_TO_SYMBOL (weight
);
2075 args
[7] = XG_STYLE_TO_SYMBOL (style
);
2080 font
= Ffont_spec (8, args
);
2082 pango_font_description_free (desc
);
2083 dupstring (&x_last_font_name
, name
);
2086 #else /* Use old font selector, which just returns the font name. */
2089 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2093 font
= build_string (font_name
);
2094 g_free (x_last_font_name
);
2095 x_last_font_name
= font_name
;
2097 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2100 gtk_widget_destroy (w
);
2103 #endif /* HAVE_FREETYPE */
2107 /***********************************************************************
2109 ***********************************************************************/
2111 /* The name of menu items that can be used for customization. Since GTK
2112 RC files are very crude and primitive, we have to set this on all
2113 menu item names so a user can easily customize menu items. */
2115 #define MENU_ITEM_NAME "emacs-menuitem"
2118 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2119 during GC. The next member points to the items. */
2120 static xg_list_node xg_menu_cb_list
;
2122 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2123 during GC. The next member points to the items. */
2124 static xg_list_node xg_menu_item_cb_list
;
2126 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2127 F is the frame CL_DATA will be initialized for.
2128 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2130 The menu bar and all sub menus under the menu bar in a frame
2131 share the same structure, hence the reference count.
2133 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2134 allocated xg_menu_cb_data if CL_DATA is NULL. */
2136 static xg_menu_cb_data
*
2137 make_cl_data (xg_menu_cb_data
*cl_data
, struct frame
*f
, GCallback highlight_cb
)
2141 cl_data
= xmalloc (sizeof *cl_data
);
2143 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2144 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2145 cl_data
->highlight_cb
= highlight_cb
;
2146 cl_data
->ref_count
= 0;
2148 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2151 cl_data
->ref_count
++;
2156 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2157 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2159 When the menu bar is updated, menu items may have been added and/or
2160 removed, so menu_bar_vector and menu_bar_items_used change. We must
2161 then update CL_DATA since it is used to determine which menu
2162 item that is invoked in the menu.
2163 HIGHLIGHT_CB could change, there is no check that the same
2164 function is given when modifying a menu bar as was given when
2165 creating the menu bar. */
2168 update_cl_data (xg_menu_cb_data
*cl_data
,
2170 GCallback highlight_cb
)
2175 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2176 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2177 cl_data
->highlight_cb
= highlight_cb
;
2181 /* Decrease reference count for CL_DATA.
2182 If reference count is zero, free CL_DATA. */
2185 unref_cl_data (xg_menu_cb_data
*cl_data
)
2187 if (cl_data
&& cl_data
->ref_count
> 0)
2189 cl_data
->ref_count
--;
2190 if (cl_data
->ref_count
== 0)
2192 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2198 /* Function that marks all lisp data during GC. */
2204 Lisp_Object rest
, frame
;
2206 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2207 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2209 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2211 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2213 if (! NILP (cb_data
->help
))
2214 mark_object (cb_data
->help
);
2217 FOR_EACH_FRAME (rest
, frame
)
2219 struct frame
*f
= XFRAME (frame
);
2221 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2223 struct xg_frame_tb_info
*tbinfo
2224 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2228 mark_object (tbinfo
->last_tool_bar
);
2229 mark_object (tbinfo
->style
);
2236 /* Callback called when a menu item is destroyed. Used to free data.
2237 W is the widget that is being destroyed (not used).
2238 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2241 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2245 xg_menu_item_cb_data
*data
= client_data
;
2246 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2251 /* Callback called when the pointer enters/leaves a menu item.
2252 W is the parent of the menu item.
2253 EVENT is either an enter event or leave event.
2254 CLIENT_DATA is not used.
2256 Returns FALSE to tell GTK to keep processing this event. */
2259 menuitem_highlight_callback (GtkWidget
*w
,
2260 GdkEventCrossing
*event
,
2261 gpointer client_data
)
2264 GtkWidget
*subwidget
;
2265 xg_menu_item_cb_data
*data
;
2267 ev
.crossing
= *event
;
2268 subwidget
= gtk_get_event_widget (&ev
);
2269 data
= g_object_get_data (G_OBJECT (subwidget
), XG_ITEM_DATA
);
2272 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2274 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2275 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2276 (*func
) (subwidget
, call_data
);
2283 /* Callback called when a menu is destroyed. Used to free data.
2284 W is the widget that is being destroyed (not used).
2285 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2288 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2290 unref_cl_data (client_data
);
2293 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2294 must be non-NULL) and can be inserted into a menu item.
2296 Returns the GtkHBox. */
2299 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2305 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2306 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2307 wlbl
= gtk_label_new (utf8_label
);
2308 wkey
= gtk_label_new (utf8_key
);
2310 #if GTK_CHECK_VERSION (3, 14, 0)
2311 gtk_widget_set_halign (wlbl
, GTK_ALIGN_START
);
2312 gtk_widget_set_valign (wlbl
, GTK_ALIGN_CENTER
);
2313 gtk_widget_set_halign (wkey
, GTK_ALIGN_START
);
2314 gtk_widget_set_valign (wkey
, GTK_ALIGN_CENTER
);
2316 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2317 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2319 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2320 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2322 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2323 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2324 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2329 /* Make and return a menu item widget with the key to the right.
2330 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2331 UTF8_KEY is the text representing the key binding.
2332 ITEM is the widget_value describing the menu item.
2334 GROUP is an in/out parameter. If the menu item to be created is not
2335 part of any radio menu group, *GROUP contains NULL on entry and exit.
2336 If the menu item to be created is part of a radio menu group, on entry
2337 *GROUP contains the group to use, or NULL if this is the first item
2338 in the group. On exit, *GROUP contains the radio item group.
2340 Unfortunately, keys don't line up as nicely as in Motif,
2341 but the MacOS X version doesn't either, so I guess that is OK. */
2344 make_menu_item (const char *utf8_label
,
2345 const char *utf8_key
,
2350 GtkWidget
*wtoadd
= 0;
2352 /* It has been observed that some menu items have a NULL name field.
2353 This will lead to this function being called with a NULL utf8_label.
2354 GTK crashes on that so we set a blank label. Why there is a NULL
2355 name remains to be investigated. */
2356 if (! utf8_label
) utf8_label
= " ";
2359 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2361 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2364 if (utf8_key
) w
= gtk_check_menu_item_new ();
2365 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2366 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2368 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2370 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2371 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2372 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2374 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2379 if (utf8_key
) w
= gtk_menu_item_new ();
2380 else w
= gtk_menu_item_new_with_label (utf8_label
);
2383 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2384 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2389 /* Create a menu item widget, and connect the callbacks.
2390 ITEM describes the menu item.
2391 F is the frame the created menu belongs to.
2392 SELECT_CB is the callback to use when a menu item is selected.
2393 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2394 CL_DATA points to the callback data to be used for this menu.
2395 GROUP is an in/out parameter. If the menu item to be created is not
2396 part of any radio menu group, *GROUP contains NULL on entry and exit.
2397 If the menu item to be created is part of a radio menu group, on entry
2398 *GROUP contains the group to use, or NULL if this is the first item
2399 in the group. On exit, *GROUP contains the radio item group.
2401 Returns the created GtkWidget. */
2404 xg_create_one_menuitem (widget_value
*item
,
2406 GCallback select_cb
,
2407 GCallback highlight_cb
,
2408 xg_menu_cb_data
*cl_data
,
2414 xg_menu_item_cb_data
*cb_data
;
2416 utf8_label
= get_utf8_string (item
->name
);
2417 utf8_key
= get_utf8_string (item
->key
);
2419 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2421 if (utf8_label
) g_free (utf8_label
);
2422 if (utf8_key
) g_free (utf8_key
);
2424 cb_data
= xmalloc (sizeof *cb_data
);
2426 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2428 cb_data
->select_id
= 0;
2429 cb_data
->help
= item
->help
;
2430 cb_data
->cl_data
= cl_data
;
2431 cb_data
->call_data
= item
->call_data
;
2433 g_signal_connect (G_OBJECT (w
),
2435 G_CALLBACK (menuitem_destroy_callback
),
2438 /* Put cb_data in widget, so we can get at it when modifying menubar */
2439 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2441 /* final item, not a submenu */
2442 if (item
->call_data
&& ! item
->contents
)
2446 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2452 /* Create a full menu tree specified by DATA.
2453 F is the frame the created menu belongs to.
2454 SELECT_CB is the callback to use when a menu item is selected.
2455 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2456 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2457 If POP_UP_P, create a popup menu.
2458 If MENU_BAR_P, create a menu bar.
2459 TOPMENU is the topmost GtkWidget that others shall be placed under.
2460 It may be NULL, in that case we create the appropriate widget
2461 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2462 CL_DATA is the callback data we shall use for this menu, or NULL
2463 if we haven't set the first callback yet.
2464 NAME is the name to give to the top level menu if this function
2465 creates it. May be NULL to not set any name.
2467 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2470 This function calls itself to create submenus. */
2473 create_menus (widget_value
*data
,
2475 GCallback select_cb
,
2476 GCallback deactivate_cb
,
2477 GCallback highlight_cb
,
2481 xg_menu_cb_data
*cl_data
,
2485 GtkWidget
*wmenu
= topmenu
;
2486 GSList
*group
= NULL
;
2492 wmenu
= gtk_menu_new ();
2493 xg_set_screen (wmenu
, f
);
2494 /* Connect this to the menu instead of items so we get enter/leave for
2495 disabled items also. TODO: Still does not get enter/leave for
2496 disabled items in detached menus. */
2497 g_signal_connect (G_OBJECT (wmenu
),
2498 "enter-notify-event",
2499 G_CALLBACK (menuitem_highlight_callback
),
2501 g_signal_connect (G_OBJECT (wmenu
),
2502 "leave-notify-event",
2503 G_CALLBACK (menuitem_highlight_callback
),
2508 wmenu
= gtk_menu_bar_new ();
2509 /* Set width of menu bar to a small value so it doesn't enlarge
2510 a small initial frame size. The width will be set to the
2511 width of the frame later on when it is added to a container.
2512 height -1: Natural height. */
2513 gtk_widget_set_size_request (wmenu
, 1, -1);
2516 /* Put cl_data on the top menu for easier access. */
2517 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2518 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2519 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2520 G_CALLBACK (menu_destroy_callback
), cl_data
);
2523 gtk_widget_set_name (wmenu
, name
);
2526 g_signal_connect (G_OBJECT (wmenu
),
2527 "selection-done", deactivate_cb
, 0);
2530 for (item
= data
; item
; item
= item
->next
)
2534 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2535 && !menu_separator_name_p (item
->name
))
2538 /* A title for a popup. We do the same as GTK does when
2539 creating titles, but it does not look good. */
2541 utf8_label
= get_utf8_string (item
->name
);
2543 w
= gtk_menu_item_new_with_label (utf8_label
);
2544 gtk_widget_set_sensitive (w
, FALSE
);
2545 if (utf8_label
) g_free (utf8_label
);
2547 else if (menu_separator_name_p (item
->name
))
2550 /* GTK only have one separator type. */
2551 w
= gtk_separator_menu_item_new ();
2555 w
= xg_create_one_menuitem (item
,
2557 item
->contents
? 0 : select_cb
,
2562 /* Create a possibly empty submenu for menu bar items, since some
2563 themes don't highlight items correctly without it. */
2564 if (item
->contents
|| menu_bar_p
)
2566 GtkWidget
*submenu
= create_menus (item
->contents
,
2576 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2580 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2581 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2587 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2588 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2589 with some text and buttons.
2590 F is the frame the created item belongs to.
2591 NAME is the name to use for the top widget.
2592 VAL is a widget_value structure describing items to be created.
2593 SELECT_CB is the callback to use when a menu item is selected or
2594 a dialog button is pressed.
2595 DEACTIVATE_CB is the callback to use when an item is deactivated.
2596 For a menu, when a sub menu is not shown anymore, for a dialog it is
2597 called when the dialog is popped down.
2598 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2600 Returns the widget created. */
2603 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2604 widget_value
*val
, GCallback select_cb
,
2605 GCallback deactivate_cb
, GCallback highlight_cb
)
2608 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2609 bool pop_up_p
= strcmp (type
, "popup") == 0;
2611 if (strcmp (type
, "dialog") == 0)
2613 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2614 xg_set_screen (w
, f
);
2615 gtk_window_set_transient_for (GTK_WINDOW (w
),
2616 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2617 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2618 gtk_widget_set_name (w
, "emacs-dialog");
2619 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2621 else if (menu_bar_p
|| pop_up_p
)
2623 w
= create_menus (val
->contents
,
2634 /* Set the cursor to an arrow for popup menus when they are mapped.
2635 This is done by default for menu bar menus. */
2638 /* Must realize so the GdkWindow inside the widget is created. */
2639 gtk_widget_realize (w
);
2640 xg_set_cursor (w
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
2645 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2652 /* Return the label for menu item WITEM. */
2655 xg_get_menu_item_label (GtkMenuItem
*witem
)
2657 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2658 return gtk_label_get_label (wlabel
);
2661 /* Return true if the menu item WITEM has the text LABEL. */
2664 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2667 char *utf8_label
= get_utf8_string (label
);
2668 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2670 if (! old_label
&& ! utf8_label
)
2672 else if (old_label
&& utf8_label
)
2673 is_same
= strcmp (utf8_label
, old_label
) == 0;
2675 if (utf8_label
) g_free (utf8_label
);
2680 /* Destroy widgets in LIST. */
2683 xg_destroy_widgets (GList
*list
)
2687 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2689 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2691 /* Destroying the widget will remove it from the container it is in. */
2692 gtk_widget_destroy (w
);
2696 /* Update the top level names in MENUBAR (i.e. not submenus).
2697 F is the frame the menu bar belongs to.
2698 *LIST is a list with the current menu bar names (menu item widgets).
2699 ITER is the item within *LIST that shall be updated.
2700 POS is the numerical position, starting at 0, of ITER in *LIST.
2701 VAL describes what the menu bar shall look like after the update.
2702 SELECT_CB is the callback to use when a menu item is selected.
2703 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2704 CL_DATA points to the callback data to be used for this menu bar.
2706 This function calls itself to walk through the menu bar names. */
2709 xg_update_menubar (GtkWidget
*menubar
,
2715 GCallback select_cb
,
2716 GCallback deactivate_cb
,
2717 GCallback highlight_cb
,
2718 xg_menu_cb_data
*cl_data
)
2720 if (! iter
&& ! val
)
2722 else if (iter
&& ! val
)
2724 /* Item(s) have been removed. Remove all remaining items. */
2725 xg_destroy_widgets (iter
);
2727 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2728 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2729 gtk_menu_item_new_with_label (""),
2735 else if (! iter
&& val
)
2737 /* Item(s) added. Add all new items in one call. */
2738 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2739 0, 1, menubar
, cl_data
, 0);
2745 /* Below this neither iter or val is NULL */
2746 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2748 /* This item is still the same, check next item. */
2750 iter
= g_list_next (iter
);
2753 else /* This item is changed. */
2755 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2756 GtkMenuItem
*witem2
= 0;
2757 bool val_in_menubar
= 0;
2758 bool iter_in_new_menubar
= 0;
2762 /* See if the changed entry (val) is present later in the menu bar */
2764 iter2
&& ! val_in_menubar
;
2765 iter2
= g_list_next (iter2
))
2767 witem2
= GTK_MENU_ITEM (iter2
->data
);
2768 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2771 /* See if the current entry (iter) is present later in the
2772 specification for the new menu bar. */
2773 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2774 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2776 if (val_in_menubar
&& ! iter_in_new_menubar
)
2780 /* This corresponds to:
2785 g_object_ref (G_OBJECT (witem
));
2786 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2787 gtk_widget_destroy (GTK_WIDGET (witem
));
2789 /* Must get new list since the old changed. */
2790 g_list_free (*list
);
2791 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2792 while (nr
-- > 0) iter
= g_list_next (iter
);
2794 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2796 /* This corresponds to:
2799 Rename B to X. This might seem to be a strange thing to do,
2800 since if there is a menu under B it will be totally wrong for X.
2801 But consider editing a C file. Then there is a C-mode menu
2802 (corresponds to B above).
2803 If then doing C-x C-f the minibuf menu (X above) replaces the
2804 C-mode menu. When returning from the minibuffer, we get
2805 back the C-mode menu. Thus we do:
2806 Rename B to X (C-mode to minibuf menu)
2807 Rename X to B (minibuf to C-mode menu).
2808 If the X menu hasn't been invoked, the menu under B
2809 is up to date when leaving the minibuffer. */
2810 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2811 char *utf8_label
= get_utf8_string (val
->name
);
2813 /* GTK menu items don't notice when their labels have been
2814 changed from underneath them, so we have to explicitly
2815 use g_object_notify to tell listeners (e.g., a GMenuModel
2816 bridge that might be loaded) that the item's label has
2818 gtk_label_set_text (wlabel
, utf8_label
);
2819 #if GTK_CHECK_VERSION (2, 16, 0)
2820 g_object_notify (G_OBJECT (witem
), "label");
2822 if (utf8_label
) g_free (utf8_label
);
2823 iter
= g_list_next (iter
);
2827 else if (! val_in_menubar
&& iter_in_new_menubar
)
2829 /* This corresponds to:
2836 GtkWidget
*w
= xg_create_one_menuitem (val
,
2843 /* Create a possibly empty submenu for menu bar items, since some
2844 themes don't highlight items correctly without it. */
2845 GtkWidget
*submenu
= create_menus (NULL
, f
,
2846 select_cb
, deactivate_cb
,
2848 0, 0, 0, cl_data
, 0);
2850 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2851 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2852 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2854 g_list_free (*list
);
2855 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2856 while (nr
-- > 0) iter
= g_list_next (iter
);
2857 iter
= g_list_next (iter
);
2861 else /* if (val_in_menubar && iter_in_new_menubar) */
2864 /* This corresponds to:
2869 g_object_ref (G_OBJECT (witem2
));
2870 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2871 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2872 GTK_WIDGET (witem2
), pos
);
2873 g_object_unref (G_OBJECT (witem2
));
2875 g_list_free (*list
);
2876 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2877 while (nr
-- > 0) iter
= g_list_next (iter
);
2878 if (iter
) iter
= g_list_next (iter
);
2884 /* Update the rest of the menu bar. */
2885 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2886 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2889 /* Update the menu item W so it corresponds to VAL.
2890 SELECT_CB is the callback to use when a menu item is selected.
2891 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2892 CL_DATA is the data to set in the widget for menu invocation. */
2895 xg_update_menu_item (widget_value
*val
,
2897 GCallback select_cb
,
2898 GCallback highlight_cb
,
2899 xg_menu_cb_data
*cl_data
)
2906 const char *old_label
= 0;
2907 const char *old_key
= 0;
2908 xg_menu_item_cb_data
*cb_data
;
2909 bool label_changed
= false;
2911 wchild
= XG_BIN_CHILD (w
);
2912 utf8_label
= get_utf8_string (val
->name
);
2913 utf8_key
= get_utf8_string (val
->key
);
2915 /* See if W is a menu item with a key. See make_menu_item above. */
2916 if (GTK_IS_BOX (wchild
))
2918 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2920 wlbl
= GTK_LABEL (list
->data
);
2921 wkey
= GTK_LABEL (list
->next
->data
);
2926 /* Remove the key and keep just the label. */
2927 g_object_ref (G_OBJECT (wlbl
));
2928 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2929 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2930 g_object_unref (G_OBJECT (wlbl
));
2935 else /* Just a label. */
2937 wlbl
= GTK_LABEL (wchild
);
2939 /* Check if there is now a key. */
2942 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2943 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2945 wlbl
= GTK_LABEL (list
->data
);
2946 wkey
= GTK_LABEL (list
->next
->data
);
2949 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2950 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2954 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2955 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2957 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2959 label_changed
= true;
2960 gtk_label_set_text (wkey
, utf8_key
);
2963 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2965 label_changed
= true;
2966 gtk_label_set_text (wlbl
, utf8_label
);
2969 if (utf8_key
) g_free (utf8_key
);
2970 if (utf8_label
) g_free (utf8_label
);
2972 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2973 gtk_widget_set_sensitive (w
, FALSE
);
2974 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2975 gtk_widget_set_sensitive (w
, TRUE
);
2977 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
2980 cb_data
->call_data
= val
->call_data
;
2981 cb_data
->help
= val
->help
;
2982 cb_data
->cl_data
= cl_data
;
2984 /* We assume the callback functions don't change. */
2985 if (val
->call_data
&& ! val
->contents
)
2987 /* This item shall have a select callback. */
2988 if (! cb_data
->select_id
)
2990 = g_signal_connect (G_OBJECT (w
), "activate",
2991 select_cb
, cb_data
);
2993 else if (cb_data
->select_id
)
2995 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2996 cb_data
->select_id
= 0;
3000 #if GTK_CHECK_VERSION (2, 16, 0)
3001 if (label_changed
) /* See comment in xg_update_menubar. */
3002 g_object_notify (G_OBJECT (w
), "label");
3006 /* Update the toggle menu item W so it corresponds to VAL. */
3009 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3011 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3014 /* Update the radio menu item W so it corresponds to VAL. */
3017 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3019 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3022 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3023 SUBMENU may be NULL, in that case a new menu is created.
3024 F is the frame the menu bar belongs to.
3025 VAL describes the contents of the menu bar.
3026 SELECT_CB is the callback to use when a menu item is selected.
3027 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3028 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3029 CL_DATA is the call back data to use for any newly created items.
3031 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3035 xg_update_submenu (GtkWidget
*submenu
,
3038 GCallback select_cb
,
3039 GCallback deactivate_cb
,
3040 GCallback highlight_cb
,
3041 xg_menu_cb_data
*cl_data
)
3043 GtkWidget
*newsub
= submenu
;
3047 GList
*first_radio
= 0;
3050 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3052 for (cur
= val
, iter
= list
;
3054 iter
= g_list_next (iter
), cur
= cur
->next
)
3056 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3058 /* Remember first radio button in a group. If we get a mismatch in
3059 a radio group we must rebuild the whole group so that the connections
3060 in GTK becomes correct. */
3061 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3063 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3064 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3067 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3069 if (! menu_separator_name_p (cur
->name
))
3072 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3074 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3076 xg_update_toggle_item (cur
, w
);
3077 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3079 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3081 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3083 xg_update_radio_item (cur
, w
);
3084 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3086 else if (GTK_IS_MENU_ITEM (w
))
3088 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3091 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3092 menu_separator_name_p (cur
->name
))
3095 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3097 sub
= gtk_menu_item_get_submenu (witem
);
3098 if (sub
&& ! cur
->contents
)
3100 /* Not a submenu anymore. */
3101 g_object_ref (G_OBJECT (sub
));
3102 remove_submenu (witem
);
3103 gtk_widget_destroy (sub
);
3105 else if (cur
->contents
)
3109 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3110 select_cb
, deactivate_cb
,
3111 highlight_cb
, cl_data
);
3113 /* If this item just became a submenu, we must set it. */
3115 gtk_menu_item_set_submenu (witem
, nsub
);
3120 /* Structural difference. Remove everything from here and down
3126 /* Remove widgets from first structural change. */
3129 /* If we are adding new menu items below, we must remove from
3130 first radio button so that radio groups become correct. */
3131 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3132 else xg_destroy_widgets (iter
);
3137 /* More items added. Create them. */
3138 newsub
= create_menus (cur
,
3150 if (list
) g_list_free (list
);
3155 /* Update the MENUBAR.
3156 F is the frame the menu bar belongs to.
3157 VAL describes the contents of the menu bar.
3158 If DEEP_P, rebuild all but the top level menu names in
3159 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3160 SELECT_CB is the callback to use when a menu item is selected.
3161 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3162 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3165 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3166 widget_value
*val
, bool deep_p
,
3167 GCallback select_cb
, GCallback deactivate_cb
,
3168 GCallback highlight_cb
)
3170 xg_menu_cb_data
*cl_data
;
3171 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3175 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3177 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3178 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3184 /* Update all sub menus.
3185 We must keep the submenus (GTK menu item widgets) since the
3186 X Window in the XEvent that activates the menu are those widgets. */
3188 /* Update cl_data, menu_item things in F may have changed. */
3189 update_cl_data (cl_data
, f
, highlight_cb
);
3191 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3196 GtkMenuItem
*witem
= 0;
3198 /* Find sub menu that corresponds to val and update it. */
3199 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3201 witem
= GTK_MENU_ITEM (iter
->data
);
3202 if (xg_item_label_same_p (witem
, cur
->name
))
3204 sub
= gtk_menu_item_get_submenu (witem
);
3209 newsub
= xg_update_submenu (sub
,
3216 /* sub may still be NULL. If we just updated non deep and added
3217 a new menu bar item, it has no sub menu yet. So we set the
3218 newly created sub menu under witem. */
3219 if (newsub
!= sub
&& witem
!= 0)
3221 xg_set_screen (newsub
, f
);
3222 gtk_menu_item_set_submenu (witem
, newsub
);
3228 gtk_widget_show_all (menubar
);
3231 /* Callback called when the menu bar W is mapped.
3232 Used to find the height of the menu bar if we didn't get it
3233 after showing the widget. */
3236 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3239 struct frame
*f
= user_data
;
3240 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3241 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3243 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3244 xg_height_or_width_changed (f
);
3248 /* Recompute all the widgets of frame F, when the menu bar has been
3252 xg_update_frame_menubar (struct frame
*f
)
3254 struct x_output
*x
= f
->output_data
.x
;
3257 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3260 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3261 return; /* Already done this, happens for frames created invisible. */
3265 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3267 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3269 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3270 gtk_widget_show_all (x
->menubar_widget
);
3271 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3273 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3275 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3276 xg_height_or_width_changed (f
);
3281 /* Get rid of the menu bar of frame F, and free its storage.
3282 This is used when deleting a frame, and when turning off the menu bar. */
3285 free_frame_menubar (struct frame
*f
)
3287 struct x_output
*x
= f
->output_data
.x
;
3289 if (x
->menubar_widget
)
3293 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3294 /* The menubar and its children shall be deleted when removed from
3296 x
->menubar_widget
= 0;
3297 FRAME_MENUBAR_HEIGHT (f
) = 0;
3298 xg_height_or_width_changed (f
);
3304 xg_event_is_for_menubar (struct frame
*f
, const XEvent
*event
)
3306 struct x_output
*x
= f
->output_data
.x
;
3315 if (! x
->menubar_widget
) return 0;
3317 if (! (event
->xbutton
.x
>= 0
3318 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3319 && event
->xbutton
.y
>= 0
3320 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
3321 && event
->xbutton
.same_screen
))
3324 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3325 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3327 gevent
.any
.window
= gw
;
3328 gevent
.any
.type
= GDK_NOTHING
;
3329 gwdesc
= gtk_get_event_widget (&gevent
);
3330 if (! gwdesc
) return 0;
3331 if (! GTK_IS_MENU_BAR (gwdesc
)
3332 && ! GTK_IS_MENU_ITEM (gwdesc
)
3333 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3336 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3337 if (! list
) return 0;
3338 rec
.x
= event
->xbutton
.x
;
3339 rec
.y
= event
->xbutton
.y
;
3343 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3345 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3346 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3355 /***********************************************************************
3356 Scroll bar functions
3357 ***********************************************************************/
3360 /* Setting scroll bar values invokes the callback. Use this variable
3361 to indicate that callback should do nothing. */
3363 bool xg_ignore_gtk_scrollbar
;
3365 /* Width and height of scroll bars for the current theme. */
3366 static int scroll_bar_width_for_theme
;
3367 static int scroll_bar_height_for_theme
;
3369 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3370 may be larger than 32 bits. Keep a mapping from integer index to widget
3371 pointers to get around the 32 bit limitation. */
3375 GtkWidget
**widgets
;
3380 /* Grow this much every time we need to allocate more */
3382 #define ID_TO_WIDGET_INCR 32
3384 /* Store the widget pointer W in id_to_widget and return the integer index. */
3387 xg_store_widget_in_map (GtkWidget
*w
)
3391 if (id_to_widget
.max_size
== id_to_widget
.used
)
3394 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3395 memory_full (SIZE_MAX
);
3397 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3398 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3399 new_size
, sizeof (GtkWidget
*));
3401 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3402 id_to_widget
.widgets
[i
] = 0;
3403 id_to_widget
.max_size
= new_size
;
3406 /* Just loop over the array and find a free place. After all,
3407 how many scroll bars are we creating? Should be a small number.
3408 The check above guarantees we will find a free place. */
3409 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3411 if (! id_to_widget
.widgets
[i
])
3413 id_to_widget
.widgets
[i
] = w
;
3414 ++id_to_widget
.used
;
3420 /* Should never end up here */
3424 /* Remove pointer at IDX from id_to_widget.
3425 Called when scroll bar is destroyed. */
3428 xg_remove_widget_from_map (ptrdiff_t idx
)
3430 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3432 id_to_widget
.widgets
[idx
] = 0;
3433 --id_to_widget
.used
;
3437 /* Get the widget pointer at IDX from id_to_widget. */
3440 xg_get_widget_from_map (ptrdiff_t idx
)
3442 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3443 return id_to_widget
.widgets
[idx
];
3449 update_theme_scrollbar_width (void)
3452 GtkAdjustment
*vadj
;
3459 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3460 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3461 g_object_ref_sink (G_OBJECT (wscroll
));
3462 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3463 gtk_widget_destroy (wscroll
);
3464 g_object_unref (G_OBJECT (wscroll
));
3467 scroll_bar_width_for_theme
= w
;
3471 update_theme_scrollbar_height (void)
3474 GtkAdjustment
*hadj
;
3481 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
, 0.1, 0.1, 0.1);
3482 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3483 g_object_ref_sink (G_OBJECT (wscroll
));
3484 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3485 gtk_widget_destroy (wscroll
);
3486 g_object_unref (G_OBJECT (wscroll
));
3489 scroll_bar_height_for_theme
= w
;
3493 xg_get_default_scrollbar_width (void)
3495 return scroll_bar_width_for_theme
;
3499 xg_get_default_scrollbar_height (void)
3501 /* Apparently there's no default height for themes. */
3502 return scroll_bar_width_for_theme
;
3505 /* Return the scrollbar id for X Window WID on display DPY.
3506 Return -1 if WID not in id_to_widget. */
3509 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3514 w
= xg_win_to_widget (dpy
, wid
);
3518 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3519 if (id_to_widget
.widgets
[idx
] == w
)
3526 /* Callback invoked when scroll bar WIDGET is destroyed.
3527 DATA is the index into id_to_widget for WIDGET.
3528 We free pointer to last scroll bar values here and remove the index. */
3531 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3533 intptr_t id
= (intptr_t) data
;
3534 xg_remove_widget_from_map (id
);
3537 /* Create a scroll bar widget for frame F. Store the scroll bar
3539 SCROLL_CALLBACK is the callback to invoke when the value of the
3541 END_CALLBACK is the callback to invoke when scrolling ends.
3542 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3543 to set resources for the widget. */
3546 xg_create_scroll_bar (struct frame
*f
,
3547 struct scroll_bar
*bar
,
3548 GCallback scroll_callback
,
3549 GCallback end_callback
,
3550 const char *scroll_bar_name
)
3556 GtkAdjustment
*vadj
;
3561 /* Page, step increment values are not so important here, they
3562 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3563 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3566 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3567 webox
= gtk_event_box_new ();
3568 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3570 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3572 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3574 scroll_id
= xg_store_widget_in_map (wscroll
);
3576 g_signal_connect (G_OBJECT (wscroll
),
3578 G_CALLBACK (xg_gtk_scroll_destroy
),
3579 (gpointer
) scroll_id
);
3580 g_signal_connect (G_OBJECT (wscroll
),
3584 g_signal_connect (G_OBJECT (wscroll
),
3585 "button-release-event",
3589 /* The scroll bar widget does not draw on a window of its own. Instead
3590 it draws on the parent window, in this case the edit widget. So
3591 whenever the edit widget is cleared, the scroll bar needs to redraw
3592 also, which causes flicker. Put an event box between the edit widget
3593 and the scroll bar, so the scroll bar instead draws itself on the
3594 event box window. */
3595 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3596 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3599 /* Set the cursor to an arrow. */
3600 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3602 bar
->x_window
= scroll_id
;
3603 bar
->horizontal
= 0;
3606 /* Create a horizontal scroll bar widget for frame F. Store the scroll
3607 bar in BAR. SCROLL_CALLBACK is the callback to invoke when the value
3608 of the bar changes. END_CALLBACK is the callback to invoke when
3609 scrolling ends. SCROLL_BAR_NAME is the name we use for the scroll
3610 bar. Can be used to set resources for the widget. */
3613 xg_create_horizontal_scroll_bar (struct frame
*f
,
3614 struct scroll_bar
*bar
,
3615 GCallback scroll_callback
,
3616 GCallback end_callback
,
3617 const char *scroll_bar_name
)
3623 GtkAdjustment
*hadj
;
3628 /* Page, step increment values are not so important here, they
3629 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3630 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
,
3633 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3634 webox
= gtk_event_box_new ();
3635 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3637 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3639 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3641 scroll_id
= xg_store_widget_in_map (wscroll
);
3643 g_signal_connect (G_OBJECT (wscroll
),
3645 G_CALLBACK (xg_gtk_scroll_destroy
),
3646 (gpointer
) scroll_id
);
3647 g_signal_connect (G_OBJECT (wscroll
),
3651 g_signal_connect (G_OBJECT (wscroll
),
3652 "button-release-event",
3656 /* The scroll bar widget does not draw on a window of its own. Instead
3657 it draws on the parent window, in this case the edit widget. So
3658 whenever the edit widget is cleared, the scroll bar needs to redraw
3659 also, which causes flicker. Put an event box between the edit widget
3660 and the scroll bar, so the scroll bar instead draws itself on the
3661 event box window. */
3662 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3663 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3666 /* Set the cursor to an arrow. */
3667 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3669 bar
->x_window
= scroll_id
;
3670 bar
->horizontal
= 1;
3673 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3676 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3678 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3681 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3682 gtk_widget_destroy (w
);
3683 gtk_widget_destroy (wparent
);
3684 SET_FRAME_GARBAGED (f
);
3688 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3690 TOP/LEFT are the new pixel positions where the bar shall appear.
3691 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3694 xg_update_scrollbar_pos (struct frame
*f
,
3695 ptrdiff_t scrollbar_id
,
3702 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3706 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3707 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3710 /* Clear out old position. */
3711 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3712 if (gtk_widget_get_parent (wparent
) == wfixed
)
3714 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3715 "x", &oldx
, "y", &oldy
, NULL
);
3716 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3719 /* Move and resize to new values. */
3720 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3721 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3724 /* No room. Hide scroll bar as some themes output a warning if
3725 the height is less than the min size. */
3726 gtk_widget_hide (wparent
);
3727 gtk_widget_hide (wscroll
);
3731 gtk_widget_show_all (wparent
);
3732 gtk_widget_set_size_request (wscroll
, width
, height
);
3734 gtk_widget_queue_draw (wfixed
);
3735 gdk_window_process_all_updates ();
3736 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3737 /* Clear under old scroll bar position. This must be done after
3738 the gtk_widget_queue_draw and gdk_window_process_all_updates
3740 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3741 oldx
, oldy
, oldw
, oldh
);
3743 /* GTK does not redraw until the main loop is entered again, but
3744 if there are no X events pending we will not enter it. So we sync
3745 here to get some events. */
3748 SET_FRAME_GARBAGED (f
);
3749 cancel_mouse_face (f
);
3754 /* Update the position of the horizontal scroll bar represented by SCROLLBAR_ID
3756 TOP/LEFT are the new pixel positions where the bar shall appear.
3757 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3760 xg_update_horizontal_scrollbar_pos (struct frame
*f
,
3761 ptrdiff_t scrollbar_id
,
3768 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3772 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3773 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3776 /* Clear out old position. */
3777 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3778 if (gtk_widget_get_parent (wparent
) == wfixed
)
3780 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3781 "x", &oldx
, "y", &oldy
, NULL
);
3782 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3785 /* Move and resize to new values. */
3786 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3787 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3790 /* No room. Hide scroll bar as some themes output a warning if
3791 the width is less than the min size. */
3792 gtk_widget_hide (wparent
);
3793 gtk_widget_hide (wscroll
);
3797 gtk_widget_show_all (wparent
);
3798 gtk_widget_set_size_request (wscroll
, width
, height
);
3800 gtk_widget_queue_draw (wfixed
);
3801 gdk_window_process_all_updates ();
3802 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3803 /* Clear under old scroll bar position. This must be done after
3804 the gtk_widget_queue_draw and gdk_window_process_all_updates
3806 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3807 oldx
, oldy
, oldw
, oldh
);
3809 /* GTK does not redraw until the main loop is entered again, but
3810 if there are no X events pending we will not enter it. So we sync
3811 here to get some events. */
3814 SET_FRAME_GARBAGED (f
);
3815 cancel_mouse_face (f
);
3820 /* Get the current value of the range, truncated to an integer. */
3823 int_gtk_range_get_value (GtkRange
*range
)
3825 return gtk_range_get_value (range
);
3829 /* Set the thumb size and position of scroll bar BAR. We are currently
3830 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3833 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3838 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3840 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3842 if (wscroll
&& bar
->dragging
== -1)
3852 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3854 if (scroll_bar_adjust_thumb_portion_p
)
3856 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3857 line rather than the real portion value. This makes the
3858 thumb less likely to resize and that looks better. */
3859 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3861 /* When the thumb is at the bottom, position == whole.
3862 So we need to increase `whole' to make space for the thumb. */
3870 top
= (gdouble
) position
/ whole
;
3871 shown
= (gdouble
) portion
/ whole
;
3874 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
3875 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
3877 /* Assume all lines are of equal size. */
3878 new_step
= size
/ max (1, FRAME_LINES (f
));
3880 old_size
= gtk_adjustment_get_page_size (adj
);
3881 if (old_size
!= size
)
3883 int old_step
= gtk_adjustment_get_step_increment (adj
);
3884 if (old_step
!= new_step
)
3886 gtk_adjustment_set_page_size (adj
, size
);
3887 gtk_adjustment_set_step_increment (adj
, new_step
);
3888 /* Assume a page increment is about 95% of the page size */
3889 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3894 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3898 /* gtk_range_set_value invokes the callback. Set
3899 ignore_gtk_scrollbar to make the callback do nothing */
3900 xg_ignore_gtk_scrollbar
= 1;
3902 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3903 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3905 gtk_adjustment_changed (adj
);
3907 xg_ignore_gtk_scrollbar
= 0;
3914 /* Set the thumb size and position of horizontal scroll bar BAR. We are
3915 currently displaying PORTION out of a whole WHOLE, and our position
3918 xg_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
3923 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3925 if (wscroll
&& bar
->dragging
== -1)
3929 int upper
= max (whole
- 1, 0);
3930 int pagesize
= min (upper
, max (portion
, 0));
3931 int value
= max (0, min (position
, upper
- pagesize
));
3932 /* These should be set to something more <portion, whole>
3934 int page_increment
= 4;
3935 int step_increment
= 1;
3938 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3939 #if GTK_CHECK_VERSION (2, 3, 16)
3940 gtk_adjustment_configure (adj
, (gdouble
) value
, (gdouble
) lower
,
3941 (gdouble
) upper
, (gdouble
) step_increment
,
3942 (gdouble
) page_increment
, (gdouble
) pagesize
);
3944 gtk_adjustment_set_lower (adj
, (gdouble
) lower
);
3945 gtk_adjustment_set_upper (adj
, (gdouble
) upper
);
3946 gtk_adjustment_set_page_size (adj
, (gdouble
) pagesize
);
3947 gtk_adjustment_set_value (adj
, (gdouble
) value
);
3948 gtk_adjustment_set_page_increment (adj
, (gdouble
) page_increment
);
3949 gtk_adjustment_set_step_increment (adj
, (gdouble
) step_increment
);
3951 gtk_adjustment_changed (adj
);
3956 /* Return true if EVENT is for a scroll bar in frame F.
3957 When the same X window is used for several Gtk+ widgets, we cannot
3958 say for sure based on the X window alone if an event is for the
3959 frame. This function does additional checks. */
3962 xg_event_is_for_scrollbar (struct frame
*f
, const XEvent
*event
)
3966 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3968 /* Check if press occurred outside the edit widget. */
3969 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3972 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
3973 (gdk_display_get_device_manager (gdpy
));
3974 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
3976 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
3978 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3981 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3982 || event
->type
== MotionNotify
))
3984 /* If we are releasing or moving the scroll bar, it has the grab. */
3985 GtkWidget
*w
= gtk_grab_get_current ();
3986 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3994 /***********************************************************************
3996 ***********************************************************************/
3997 /* The key for the data we put in the GtkImage widgets. The data is
3998 the image used by Emacs. We use this to see if we need to update
3999 the GtkImage with a new image. */
4000 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
4002 /* The key for storing the latest modifiers so the activate callback can
4004 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
4006 /* The key for the data we put in the GtkImage widgets. The data is
4007 the stock name used by Emacs. We use this to see if we need to update
4008 the GtkImage with a new image. */
4009 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
4011 /* As above, but this is used for named theme widgets, as opposed to
4013 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
4015 /* Callback function invoked when a tool bar item is pressed.
4016 W is the button widget in the tool bar that got pressed,
4017 CLIENT_DATA is an integer that is the index of the button in the
4018 tool bar. 0 is the first button. */
4021 xg_tool_bar_button_cb (GtkWidget
*widget
,
4022 GdkEventButton
*event
,
4025 intptr_t state
= event
->state
;
4026 gpointer ptr
= (gpointer
) state
;
4027 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
4032 /* Callback function invoked when a tool bar item is pressed.
4033 W is the button widget in the tool bar that got pressed,
4034 CLIENT_DATA is an integer that is the index of the button in the
4035 tool bar. 0 is the first button. */
4038 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
4040 intptr_t idx
= (intptr_t) client_data
;
4041 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
4042 intptr_t mod
= (intptr_t) gmod
;
4044 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4045 Lisp_Object key
, frame
;
4046 struct input_event event
;
4049 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4052 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4054 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
4055 XSETFRAME (frame
, f
);
4057 /* We generate two events here. The first one is to set the prefix
4058 to `(tool_bar)', see keyboard.c. */
4059 event
.kind
= TOOL_BAR_EVENT
;
4060 event
.frame_or_window
= frame
;
4062 kbd_buffer_store_event (&event
);
4064 event
.kind
= TOOL_BAR_EVENT
;
4065 event
.frame_or_window
= frame
;
4067 /* Convert between the modifier bits GDK uses and the modifier bits
4068 Emacs uses. This assumes GDK and X masks are the same, which they are when
4070 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), mod
);
4071 kbd_buffer_store_event (&event
);
4073 /* Return focus to the frame after we have clicked on a detached
4079 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
4081 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
4082 GtkWidget
*c1
= clist
->data
;
4083 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
4085 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4086 g_list_free (clist
);
4087 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4091 /* This callback is called when the mouse enters or leaves a tool bar item.
4092 It is used for displaying and hiding the help text.
4093 W is the tool bar item, a button.
4094 EVENT is either an enter event or leave event.
4095 CLIENT_DATA is an integer that is the index of the button in the
4096 tool bar. 0 is the first button.
4098 Returns FALSE to tell GTK to keep processing this event. */
4101 xg_tool_bar_help_callback (GtkWidget
*w
,
4102 GdkEventCrossing
*event
,
4103 gpointer client_data
)
4105 intptr_t idx
= (intptr_t) client_data
;
4106 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4107 Lisp_Object help
, frame
;
4109 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4112 if (event
->type
== GDK_ENTER_NOTIFY
)
4114 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4115 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4118 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4123 XSETFRAME (frame
, f
);
4124 kbd_buffer_store_help_event (frame
, help
);
4130 /* This callback is called when a tool bar item shall be redrawn.
4131 It modifies the expose event so that the GtkImage widget redraws the
4132 whole image. This to overcome a bug that makes GtkImage draw the image
4133 in the wrong place when it tries to redraw just a part of the image.
4134 W is the GtkImage to be redrawn.
4135 EVENT is the expose event for W.
4136 CLIENT_DATA is unused.
4138 Returns FALSE to tell GTK to keep processing this event. */
4142 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4143 GdkEventExpose
*event
,
4144 gpointer client_data
)
4148 gdk_drawable_get_size (event
->window
, &width
, &height
);
4149 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4150 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4152 event
->area
.x
= max (0, event
->area
.x
);
4153 event
->area
.y
= max (0, event
->area
.y
);
4155 event
->area
.width
= max (width
, event
->area
.width
);
4156 event
->area
.height
= max (height
, event
->area
.height
);
4162 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4163 #define toolbar_set_orientation(w, o) \
4164 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4166 #define toolbar_set_orientation(w, o) \
4167 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4170 /* Attach a tool bar to frame F. */
4173 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4175 struct x_output
*x
= f
->output_data
.x
;
4176 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4177 GtkWidget
*top_widget
= x
->toolbar_widget
;
4179 toolbar_set_orientation (x
->toolbar_widget
,
4181 ? GTK_ORIENTATION_VERTICAL
4182 : GTK_ORIENTATION_HORIZONTAL
);
4186 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4189 if (EQ (pos
, Qleft
))
4190 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4193 x
->toolbar_in_hbox
= true;
4197 bool vbox_pos
= x
->menubar_widget
!= 0;
4198 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4202 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4205 x
->toolbar_in_hbox
= false;
4207 x
->toolbar_is_packed
= true;
4210 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4213 tb_size_cb (GtkWidget
*widget
,
4214 GdkRectangle
*allocation
,
4217 /* When tool bar is created it has one preferred size. But when size is
4218 allocated between widgets, it may get another. So we must update
4219 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4220 struct frame
*f
= user_data
;
4221 if (xg_update_tool_bar_sizes (f
))
4222 xg_height_or_width_changed (f
);
4225 /* Create a tool bar for frame F. */
4228 xg_create_tool_bar (struct frame
*f
)
4230 struct x_output
*x
= f
->output_data
.x
;
4231 #if GTK_CHECK_VERSION (3, 3, 6)
4232 GtkStyleContext
*gsty
;
4234 struct xg_frame_tb_info
*tbinfo
4235 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4239 tbinfo
= xmalloc (sizeof (*tbinfo
));
4240 tbinfo
->last_tool_bar
= Qnil
;
4241 tbinfo
->style
= Qnil
;
4242 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4243 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4244 tbinfo
->n_last_items
= 0;
4245 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4250 x
->toolbar_widget
= gtk_toolbar_new ();
4252 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4254 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4255 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4256 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4257 G_CALLBACK (tb_size_cb
), f
);
4258 #if GTK_CHECK_VERSION (3, 3, 6)
4259 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4260 gtk_style_context_add_class (gsty
, "primary-toolbar");
4265 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4267 /* Find the right-to-left image named by RTL in the tool bar images for F.
4268 Returns IMAGE if RTL is not found. */
4271 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4274 Lisp_Object file
, rtl_name
;
4275 struct gcpro gcpro1
, gcpro2
;
4276 GCPRO2 (file
, rtl_name
);
4278 rtl_name
= Ffile_name_nondirectory (rtl
);
4280 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4282 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4283 if (!NILP (file
= file_for_image (rtl_image
)))
4285 file
= call1 (intern ("file-name-sans-extension"),
4286 Ffile_name_nondirectory (file
));
4287 if (! NILP (Fequal (file
, rtl_name
)))
4298 static GtkToolItem
*
4299 xg_make_tool_item (struct frame
*f
,
4301 GtkWidget
**wbutton
,
4303 int i
, bool horiz
, bool text_image
)
4305 GtkToolItem
*ti
= gtk_tool_item_new ();
4306 GtkWidget
*vb
= gtk_box_new (horiz
4307 ? GTK_ORIENTATION_HORIZONTAL
4308 : GTK_ORIENTATION_VERTICAL
,
4310 GtkWidget
*wb
= gtk_button_new ();
4311 /* The eventbox is here so we can have tooltips on disabled items. */
4312 GtkWidget
*weventbox
= gtk_event_box_new ();
4313 #if GTK_CHECK_VERSION (3, 3, 6)
4314 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4315 GtkStyleContext
*gsty
;
4317 gtk_css_provider_load_from_data (css_prov
,
4319 " background-color: transparent;"
4323 gsty
= gtk_widget_get_style_context (weventbox
);
4324 gtk_style_context_add_provider (gsty
,
4325 GTK_STYLE_PROVIDER (css_prov
),
4326 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4327 g_object_unref (css_prov
);
4330 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4332 if (wimage
&& !text_image
)
4333 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4335 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4336 if (wimage
&& text_image
)
4337 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4339 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4340 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4341 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4342 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4343 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4345 if (wimage
|| label
)
4348 gpointer gi
= (gpointer
) ii
;
4350 g_signal_connect (G_OBJECT (wb
), "clicked",
4351 G_CALLBACK (xg_tool_bar_callback
),
4354 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4357 /* Catch expose events to overcome an annoying redraw bug, see
4358 comment for xg_tool_bar_item_expose_callback. */
4359 g_signal_connect (G_OBJECT (ti
),
4361 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4364 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4366 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4367 no distinction based on modifiers in the activate callback,
4368 so we have to do it ourselves. */
4369 g_signal_connect (wb
, "button-release-event",
4370 G_CALLBACK (xg_tool_bar_button_cb
),
4373 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4375 /* Use enter/leave notify to show help. We use the events
4376 rather than the GtkButton specific signals "enter" and
4377 "leave", so we can have only one callback. The event
4378 will tell us what kind of event it is. */
4379 g_signal_connect (G_OBJECT (weventbox
),
4380 "enter-notify-event",
4381 G_CALLBACK (xg_tool_bar_help_callback
),
4383 g_signal_connect (G_OBJECT (weventbox
),
4384 "leave-notify-event",
4385 G_CALLBACK (xg_tool_bar_help_callback
),
4389 if (wbutton
) *wbutton
= wb
;
4395 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4399 if (GTK_IS_BOX (vb
))
4401 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4402 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4403 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4407 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4413 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4414 const char *icon_name
, const struct image
*img
,
4415 const char *label
, bool horiz
)
4419 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4420 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4422 /* Check if the tool icon matches. */
4423 if (stock_name
&& wimage
)
4425 old
= g_object_get_data (G_OBJECT (wimage
),
4426 XG_TOOL_BAR_STOCK_NAME
);
4427 if (!old
|| strcmp (old
, stock_name
))
4430 else if (icon_name
&& wimage
)
4432 old
= g_object_get_data (G_OBJECT (wimage
),
4433 XG_TOOL_BAR_ICON_NAME
);
4434 if (!old
|| strcmp (old
, icon_name
))
4439 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4440 XG_TOOL_BAR_IMAGE_DATA
);
4441 Pixmap old_img
= (Pixmap
) gold_img
;
4442 if (old_img
!= img
->pixmap
)
4446 /* Check button configuration and label. */
4447 if (is_box_type (vb
, horiz
)
4448 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4451 /* Ensure label is correct. */
4453 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4458 xg_update_tool_bar_sizes (struct frame
*f
)
4460 struct x_output
*x
= f
->output_data
.x
;
4462 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4463 GtkWidget
*top_widget
= x
->toolbar_widget
;
4465 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4466 if (x
->toolbar_in_hbox
)
4469 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4471 "position", &pos
, NULL
);
4472 if (pos
== 0) nl
= req
.width
;
4473 else nr
= req
.width
;
4478 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4480 "position", &pos
, NULL
);
4481 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4482 else nb
= req
.height
;
4485 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4486 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4487 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4488 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4490 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4491 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4492 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4493 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4494 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4495 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4503 find_icon_from_name (char *name
,
4504 GtkIconTheme
*icon_theme
,
4507 #if ! GTK_CHECK_VERSION (3, 10, 0)
4508 GtkStockItem stock_item
;
4511 if (name
[0] == 'n' && name
[1] == ':')
4513 *icon_name
= name
+ 2;
4516 if (! gtk_icon_theme_has_icon (icon_theme
, *icon_name
))
4520 #if ! GTK_CHECK_VERSION (3, 10, 0)
4521 else if (gtk_stock_lookup (name
, &stock_item
))
4524 else if (gtk_icon_theme_has_icon (icon_theme
, name
))
4539 /* Update the tool bar for frame F. Add new buttons and remove old. */
4542 update_frame_tool_bar (struct frame
*f
)
4545 struct x_output
*x
= f
->output_data
.x
;
4546 int hmargin
= 0, vmargin
= 0;
4547 GtkToolbar
*wtoolbar
;
4549 GtkTextDirection dir
;
4551 bool text_image
, horiz
;
4552 struct xg_frame_tb_info
*tbinfo
;
4554 GtkIconTheme
*icon_theme
;
4557 if (! FRAME_GTK_WIDGET (f
))
4562 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4564 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4565 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4567 else if (CONSP (Vtool_bar_button_margin
))
4569 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4570 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4572 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4573 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4576 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4577 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4578 i.e. zero. This means that margins less than
4579 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4580 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4581 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4583 if (! x
->toolbar_widget
)
4584 xg_create_tool_bar (f
);
4586 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4587 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4589 style
= Ftool_bar_get_system_style ();
4590 screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4591 icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4593 /* Are we up to date? */
4594 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4597 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4598 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4599 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4600 && tbinfo
->dir
== dir
4601 && ! NILP (Fequal (tbinfo
->style
, style
))
4602 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4608 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4609 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4610 tbinfo
->style
= style
;
4611 tbinfo
->hmargin
= hmargin
;
4612 tbinfo
->vmargin
= vmargin
;
4615 text_image
= EQ (style
, Qtext_image_horiz
);
4616 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4618 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4620 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4621 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4625 struct image
*img
= NULL
;
4627 Lisp_Object stock
= Qnil
;
4628 char *stock_name
= NULL
;
4629 char *icon_name
= NULL
;
4631 GtkWidget
*wbutton
= NULL
;
4632 Lisp_Object specified_file
;
4633 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4635 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4636 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4637 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4640 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4642 /* If this is a separator, use a gtk separator item. */
4643 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4645 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4648 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4650 ti
= gtk_separator_tool_item_new ();
4651 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4657 /* Otherwise, the tool-bar item is an ordinary button. */
4659 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4661 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4665 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4667 /* Ignore invalid image specifications. */
4668 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4669 if (!valid_image_p (image
))
4672 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4677 specified_file
= file_for_image (image
);
4678 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4679 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4684 for (tem
= stock
; CONSP (tem
); tem
= XCDR (tem
))
4685 if (! NILP (tem
) && STRINGP (XCAR (tem
)))
4687 stock_name
= find_icon_from_name (SSDATA (XCAR (tem
)),
4690 if (stock_name
|| icon_name
) break;
4693 else if (STRINGP (stock
))
4695 stock_name
= find_icon_from_name (SSDATA (stock
),
4700 if (stock_name
|| icon_name
)
4701 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4703 if (stock_name
== NULL
&& icon_name
== NULL
)
4705 /* No stock image, or stock item not known. Try regular
4706 image. If image is a vector, choose it according to the
4708 if (dir
== GTK_TEXT_DIR_RTL
4709 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4711 image
= find_rtl_image (f
, image
, rtl
);
4713 if (VECTORP (image
))
4717 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4718 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4721 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4722 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4724 eassert (ASIZE (image
) >= idx
);
4725 image
= AREF (image
, idx
);
4730 img_id
= lookup_image (f
, image
);
4731 img
= IMAGE_FROM_ID (f
, img_id
);
4732 prepare_image_for_display (f
, img
);
4734 if (img
->load_failed_p
|| img
->pixmap
== None
)
4737 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4743 /* If there is an existing widget, check if it's stale; if so,
4744 remove it and make a new tool item from scratch. */
4745 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4748 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4757 /* Save the image so we can see if an update is needed the
4758 next time we call xg_tool_item_match_p. */
4759 if (EQ (style
, Qtext
))
4761 else if (stock_name
)
4764 #if GTK_CHECK_VERSION (3, 10, 0)
4765 w
= gtk_image_new_from_icon_name (stock_name
, icon_size
);
4767 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4769 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4770 (gpointer
) xstrdup (stock_name
),
4771 (GDestroyNotify
) xfree
);
4775 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4776 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4777 (gpointer
) xstrdup (icon_name
),
4778 (GDestroyNotify
) xfree
);
4782 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4783 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4784 (gpointer
)img
->pixmap
);
4787 #if GTK_CHECK_VERSION (3, 14, 0)
4790 gtk_widget_set_margin_start (w
, hmargin
);
4791 gtk_widget_set_margin_end (w
, hmargin
);
4792 gtk_widget_set_margin_top (w
, vmargin
);
4793 gtk_widget_set_margin_bottom (w
, vmargin
);
4796 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4798 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4799 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4804 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4808 /* Remove buttons not longer needed. */
4811 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4813 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4814 } while (ti
!= NULL
);
4816 if (f
->n_tool_bar_items
!= 0)
4818 if (! x
->toolbar_is_packed
)
4819 xg_pack_tool_bar (f
, FRAME_TOOL_BAR_POSITION (f
));
4820 gtk_widget_show_all (x
->toolbar_widget
);
4821 if (xg_update_tool_bar_sizes (f
))
4822 xg_height_or_width_changed (f
);
4828 /* Deallocate all resources for the tool bar on frame F.
4829 Remove the tool bar. */
4832 free_frame_tool_bar (struct frame
*f
)
4834 struct x_output
*x
= f
->output_data
.x
;
4836 if (x
->toolbar_widget
)
4838 struct xg_frame_tb_info
*tbinfo
;
4839 GtkWidget
*top_widget
= x
->toolbar_widget
;
4842 if (x
->toolbar_is_packed
)
4844 if (x
->toolbar_in_hbox
)
4845 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4848 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4852 gtk_widget_destroy (x
->toolbar_widget
);
4854 x
->toolbar_widget
= 0;
4855 x
->toolbar_widget
= 0;
4856 x
->toolbar_is_packed
= false;
4857 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4858 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4860 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4865 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4870 xg_height_or_width_changed (f
);
4877 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
4879 struct x_output
*x
= f
->output_data
.x
;
4880 GtkWidget
*top_widget
= x
->toolbar_widget
;
4882 if (! x
->toolbar_widget
|| ! top_widget
)
4886 g_object_ref (top_widget
);
4887 if (x
->toolbar_is_packed
)
4889 if (x
->toolbar_in_hbox
)
4890 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4893 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4897 xg_pack_tool_bar (f
, pos
);
4898 g_object_unref (top_widget
);
4899 if (xg_update_tool_bar_sizes (f
))
4900 xg_height_or_width_changed (f
);
4907 /***********************************************************************
4909 ***********************************************************************/
4911 xg_initialize (void)
4913 GtkBindingSet
*binding_set
;
4914 GtkSettings
*settings
;
4917 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4918 we keep it permanently linked in. */
4923 xg_ignore_gtk_scrollbar
= 0;
4924 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4925 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4927 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4928 id_to_widget
.widgets
= 0;
4930 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
4931 (gdk_display_get_default ()));
4932 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4933 bindings. It doesn't seem to be any way to remove properties,
4934 so we set it to "" which in means "no key". */
4935 gtk_settings_set_string_property (settings
,
4936 "gtk-menu-bar-accel",
4940 /* Make GTK text input widgets use Emacs style keybindings. This is
4942 gtk_settings_set_string_property (settings
,
4943 "gtk-key-theme-name",
4947 /* Make dialogs close on C-g. Since file dialog inherits from
4948 dialog, this works for them also. */
4949 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4950 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4953 /* Make menus close on C-g. */
4954 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4955 (GTK_TYPE_MENU_SHELL
));
4956 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4958 update_theme_scrollbar_width ();
4959 update_theme_scrollbar_height ();
4961 #ifdef HAVE_FREETYPE
4962 x_last_font_name
= NULL
;
4966 #endif /* USE_GTK */