Grab all Python process output before inferior-python-mode hooks.
[emacs.git] / src / gtkutil.c
blobb18e5f325e1d86b573c82a4a05de2f1e7d1b8bd0
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/>. */
20 #include <config.h>
22 #ifdef USE_GTK
23 #include <float.h>
24 #include <stdio.h>
26 #include <c-ctype.h>
28 #include "lisp.h"
29 #include "xterm.h"
30 #include "blockinput.h"
31 #include "syssignal.h"
32 #include "window.h"
33 #include "buffer.h"
34 #include "gtkutil.h"
35 #include "termhooks.h"
36 #include "keyboard.h"
37 #include "charset.h"
38 #include "coding.h"
39 #include "font.h"
41 #include <gdk/gdkkeysyms.h>
42 #include "xsettings.h"
44 #ifdef HAVE_XFT
45 #include <X11/Xft/Xft.h>
46 #endif
48 #ifdef HAVE_GTK3
49 #include <gtk/gtkx.h>
50 #include "emacsgtkfixed.h"
51 #endif
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))
62 #endif
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)
66 #endif
67 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
68 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
69 #endif
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))
75 #endif
76 #if GTK_CHECK_VERSION (2, 12, 0)
77 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
78 #else
79 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
80 #endif
82 #ifdef HAVE_FREETYPE
83 #if GTK_CHECK_VERSION (3, 2, 0)
84 #define USE_NEW_GTK_FONT_CHOOSER 1
85 #else
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)
93 #endif
94 #endif /* HAVE_FREETYPE */
96 #ifndef HAVE_GTK3
97 #ifdef USE_GTK_TOOLTIP
98 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
99 #endif
100 #define gdk_window_get_geometry(w, a, b, c, d) \
101 gdk_window_get_geometry (w, a, b, c, d, 0)
102 #define gdk_x11_window_lookup_for_display(d, w) \
103 gdk_xid_table_lookup_for_display (d, w)
104 #define gtk_box_new(ori, spacing) \
105 ((ori) == GTK_ORIENTATION_HORIZONTAL \
106 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
107 #define gtk_scrollbar_new(ori, spacing) \
108 ((ori) == GTK_ORIENTATION_HORIZONTAL \
109 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
110 #ifndef GDK_KEY_g
111 #define GDK_KEY_g GDK_g
112 #endif
113 #endif /* HAVE_GTK3 */
115 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
117 static void update_theme_scrollbar_width (void);
118 static void update_theme_scrollbar_height (void);
120 #define TB_INFO_KEY "xg_frame_tb_info"
121 struct xg_frame_tb_info
123 Lisp_Object last_tool_bar;
124 Lisp_Object style;
125 int n_last_items;
126 int hmargin, vmargin;
127 GtkTextDirection dir;
131 /***********************************************************************
132 Display handling functions
133 ***********************************************************************/
135 /* Keep track of the default display, or NULL if there is none. Emacs
136 may close all its displays. */
138 static GdkDisplay *gdpy_def;
140 /* When the GTK widget W is to be created on a display for F that
141 is not the default display, set the display for W.
142 W can be a GtkMenu or a GtkWindow widget. */
144 static void
145 xg_set_screen (GtkWidget *w, struct frame *f)
147 if (FRAME_X_DISPLAY (f) != DEFAULT_GDK_DISPLAY ())
149 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
150 GdkScreen *gscreen = gdk_display_get_default_screen (gdpy);
152 if (GTK_IS_MENU (w))
153 gtk_menu_set_screen (GTK_MENU (w), gscreen);
154 else
155 gtk_window_set_screen (GTK_WINDOW (w), gscreen);
160 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
161 *DPY is set to NULL if the display can't be opened.
163 Returns non-zero if display could be opened, zero if display could not
164 be opened, and less than zero if the GTK version doesn't support
165 multiple displays. */
167 void
168 xg_display_open (char *display_name, Display **dpy)
170 GdkDisplay *gdpy;
172 gdpy = gdk_display_open (display_name);
173 if (!gdpy_def && gdpy)
175 gdpy_def = gdpy;
176 gdk_display_manager_set_default_display (gdk_display_manager_get (),
177 gdpy);
180 *dpy = gdpy ? GDK_DISPLAY_XDISPLAY (gdpy) : NULL;
184 /* Close display DPY. */
186 void
187 xg_display_close (Display *dpy)
189 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (dpy);
191 /* If this is the default display, try to change it before closing.
192 If there is no other display to use, gdpy_def is set to NULL, and
193 the next call to xg_display_open resets the default display. */
194 if (gdk_display_get_default () == gdpy)
196 struct x_display_info *dpyinfo;
197 GdkDisplay *gdpy_new = NULL;
199 /* Find another display. */
200 for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
201 if (dpyinfo->display != dpy)
203 gdpy_new = gdk_x11_lookup_xdisplay (dpyinfo->display);
204 gdk_display_manager_set_default_display (gdk_display_manager_get (),
205 gdpy_new);
206 break;
208 gdpy_def = gdpy_new;
211 #if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
212 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
213 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
214 can continue running, but there will be memory leaks. */
215 g_object_run_dispose (G_OBJECT (gdpy));
216 #else
217 /* This seems to be fixed in GTK 2.10. */
218 gdk_display_close (gdpy);
219 #endif
223 /***********************************************************************
224 Utility functions
225 ***********************************************************************/
227 /* Create and return the cursor to be used for popup menus and
228 scroll bars on display DPY. */
230 GdkCursor *
231 xg_create_default_cursor (Display *dpy)
233 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (dpy);
234 return gdk_cursor_new_for_display (gdpy, GDK_LEFT_PTR);
237 static GdkPixbuf *
238 xg_get_pixbuf_from_pixmap (struct frame *f, Pixmap pix)
240 int iunused;
241 GdkPixbuf *tmp_buf;
242 Window wunused;
243 unsigned int width, height, uunused;
244 XImage *xim;
246 XGetGeometry (FRAME_X_DISPLAY (f), pix, &wunused, &iunused, &iunused,
247 &width, &height, &uunused, &uunused);
249 xim = XGetImage (FRAME_X_DISPLAY (f), pix, 0, 0, width, height,
250 ~0, XYPixmap);
251 if (!xim) return 0;
253 tmp_buf = gdk_pixbuf_new_from_data ((guchar *) xim->data,
254 GDK_COLORSPACE_RGB,
255 FALSE,
256 xim->bitmap_unit,
257 width,
258 height,
259 xim->bytes_per_line,
260 NULL,
261 NULL);
262 XDestroyImage (xim);
263 return tmp_buf;
266 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
268 static GdkPixbuf *
269 xg_get_pixbuf_from_pix_and_mask (struct frame *f,
270 Pixmap pix,
271 Pixmap mask)
273 int width, height;
274 GdkPixbuf *icon_buf, *tmp_buf;
276 tmp_buf = xg_get_pixbuf_from_pixmap (f, pix);
277 icon_buf = gdk_pixbuf_add_alpha (tmp_buf, FALSE, 0, 0, 0);
278 g_object_unref (G_OBJECT (tmp_buf));
280 width = gdk_pixbuf_get_width (icon_buf);
281 height = gdk_pixbuf_get_height (icon_buf);
283 if (mask)
285 GdkPixbuf *mask_buf = xg_get_pixbuf_from_pixmap (f, mask);
286 guchar *pixels = gdk_pixbuf_get_pixels (icon_buf);
287 guchar *mask_pixels = gdk_pixbuf_get_pixels (mask_buf);
288 int rowstride = gdk_pixbuf_get_rowstride (icon_buf);
289 int mask_rowstride = gdk_pixbuf_get_rowstride (mask_buf);
290 int y;
292 for (y = 0; y < height; ++y)
294 guchar *iconptr, *maskptr;
295 int x;
297 iconptr = pixels + y * rowstride;
298 maskptr = mask_pixels + y * mask_rowstride;
300 for (x = 0; x < width; ++x)
302 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
303 just R is sufficient. */
304 if (maskptr[0] == 0)
305 iconptr[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
307 iconptr += rowstride/width;
308 maskptr += mask_rowstride/width;
312 g_object_unref (G_OBJECT (mask_buf));
315 return icon_buf;
318 static Lisp_Object
319 file_for_image (Lisp_Object image)
321 Lisp_Object specified_file = Qnil;
322 Lisp_Object tail;
324 for (tail = XCDR (image);
325 NILP (specified_file) && CONSP (tail) && CONSP (XCDR (tail));
326 tail = XCDR (XCDR (tail)))
327 if (EQ (XCAR (tail), QCfile))
328 specified_file = XCAR (XCDR (tail));
330 return specified_file;
333 /* For the image defined in IMG, make and return a GtkImage. For displays with
334 8 planes or less we must make a GdkPixbuf and apply the mask manually.
335 Otherwise the highlighting and dimming the tool bar code in GTK does
336 will look bad. For display with more than 8 planes we just use the
337 pixmap and mask directly. For monochrome displays, GTK doesn't seem
338 able to use external pixmaps, it looks bad whatever we do.
339 The image is defined on the display where frame F is.
340 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
341 If OLD_WIDGET is NULL, a new widget is constructed and returned.
342 If OLD_WIDGET is not NULL, that widget is modified. */
344 static GtkWidget *
345 xg_get_image_for_pixmap (struct frame *f,
346 struct image *img,
347 GtkWidget *widget,
348 GtkImage *old_widget)
350 GdkPixbuf *icon_buf;
352 /* If we have a file, let GTK do all the image handling.
353 This seems to be the only way to make insensitive and activated icons
354 look good in all cases. */
355 Lisp_Object specified_file = file_for_image (img->spec);
356 Lisp_Object file;
358 /* We already loaded the image once before calling this
359 function, so this only fails if the image file has been removed.
360 In that case, use the pixmap already loaded. */
362 if (STRINGP (specified_file)
363 && STRINGP (file = x_find_image_file (specified_file)))
365 if (! old_widget)
366 old_widget = GTK_IMAGE (gtk_image_new_from_file (SSDATA (file)));
367 else
368 gtk_image_set_from_file (old_widget, SSDATA (file));
370 return GTK_WIDGET (old_widget);
373 /* No file, do the image handling ourselves. This will look very bad
374 on a monochrome display, and sometimes bad on all displays with
375 certain themes. */
377 /* This is a workaround to make icons look good on pseudo color
378 displays. Apparently GTK expects the images to have an alpha
379 channel. If they don't, insensitive and activated icons will
380 look bad. This workaround does not work on monochrome displays,
381 and is strictly not needed on true color/static color displays (i.e.
382 16 bits and higher). But we do it anyway so we get a pixbuf that is
383 not associated with the img->pixmap. The img->pixmap may be removed
384 by clearing the image cache and then the tool bar redraw fails, since
385 Gtk+ assumes the pixmap is always there. */
386 icon_buf = xg_get_pixbuf_from_pix_and_mask (f, img->pixmap, img->mask);
388 if (icon_buf)
390 if (! old_widget)
391 old_widget = GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf));
392 else
393 gtk_image_set_from_pixbuf (old_widget, icon_buf);
395 g_object_unref (G_OBJECT (icon_buf));
398 return GTK_WIDGET (old_widget);
402 /* Set CURSOR on W and all widgets W contain. We must do like this
403 for scroll bars and menu because they create widgets internally,
404 and it is those widgets that are visible. */
406 static void
407 xg_set_cursor (GtkWidget *w, GdkCursor *cursor)
409 GdkWindow *window = gtk_widget_get_window (w);
410 GList *children = gdk_window_peek_children (window);
412 gdk_window_set_cursor (window, cursor);
414 /* The scroll bar widget has more than one GDK window (had to look at
415 the source to figure this out), and there is no way to set cursor
416 on widgets in GTK. So we must set the cursor for all GDK windows.
417 Ditto for menus. */
419 for ( ; children; children = g_list_next (children))
420 gdk_window_set_cursor (GDK_WINDOW (children->data), cursor);
423 /* Insert NODE into linked LIST. */
425 static void
426 xg_list_insert (xg_list_node *list, xg_list_node *node)
428 xg_list_node *list_start = list->next;
430 if (list_start) list_start->prev = node;
431 node->next = list_start;
432 node->prev = 0;
433 list->next = node;
436 /* Remove NODE from linked LIST. */
438 static void
439 xg_list_remove (xg_list_node *list, xg_list_node *node)
441 xg_list_node *list_start = list->next;
442 if (node == list_start)
444 list->next = node->next;
445 if (list->next) list->next->prev = 0;
447 else
449 node->prev->next = node->next;
450 if (node->next) node->next->prev = node->prev;
454 /* Allocate and return a utf8 version of STR. If STR is already
455 utf8 or NULL, just return a copy of STR.
456 A new string is allocated and the caller must free the result
457 with g_free. */
459 static char *
460 get_utf8_string (const char *str)
462 char *utf8_str;
464 if (!str) return NULL;
466 /* If not UTF-8, try current locale. */
467 if (!g_utf8_validate (str, -1, NULL))
468 utf8_str = g_locale_to_utf8 (str, -1, 0, 0, 0);
469 else
470 return g_strdup (str);
472 if (!utf8_str)
474 /* Probably some control characters in str. Escape them. */
475 ptrdiff_t len;
476 ptrdiff_t nr_bad = 0;
477 gsize bytes_read;
478 gsize bytes_written;
479 unsigned char *p = (unsigned char *)str;
480 char *cp, *up;
481 GError *err = NULL;
483 while (! (cp = g_locale_to_utf8 ((char *)p, -1, &bytes_read,
484 &bytes_written, &err))
485 && err->code == G_CONVERT_ERROR_ILLEGAL_SEQUENCE)
487 ++nr_bad;
488 p += bytes_written+1;
489 g_error_free (err);
490 err = NULL;
493 if (err)
495 g_error_free (err);
496 err = NULL;
498 if (cp) g_free (cp);
500 len = strlen (str);
501 if ((min (PTRDIFF_MAX, SIZE_MAX) - len - 1) / 4 < nr_bad)
502 memory_full (SIZE_MAX);
503 up = utf8_str = xmalloc (len + nr_bad * 4 + 1);
504 p = (unsigned char *)str;
506 while (! (cp = g_locale_to_utf8 ((char *)p, -1, &bytes_read,
507 &bytes_written, &err))
508 && err->code == G_CONVERT_ERROR_ILLEGAL_SEQUENCE)
510 memcpy (up, p, bytes_written);
511 sprintf (up + bytes_written, "\\%03o", p[bytes_written]);
512 up += bytes_written+4;
513 p += bytes_written+1;
514 g_error_free (err);
515 err = NULL;
518 if (cp)
520 strcat (utf8_str, cp);
521 g_free (cp);
523 if (err)
525 g_error_free (err);
526 err = NULL;
529 return utf8_str;
532 /* Check for special colors used in face spec for region face.
533 The colors are fetched from the Gtk+ theme.
534 Return true if color was found, false if not. */
536 bool
537 xg_check_special_colors (struct frame *f,
538 const char *color_name,
539 XColor *color)
541 bool success_p = 0;
542 bool get_bg = strcmp ("gtk_selection_bg_color", color_name) == 0;
543 bool get_fg = !get_bg && strcmp ("gtk_selection_fg_color", color_name) == 0;
545 if (! FRAME_GTK_WIDGET (f) || ! (get_bg || get_fg))
546 return success_p;
548 block_input ();
550 #ifdef HAVE_GTK3
551 GtkStyleContext *gsty
552 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f));
553 GdkRGBA col;
554 char buf[sizeof "rgb://rrrr/gggg/bbbb"];
555 int state = GTK_STATE_FLAG_SELECTED|GTK_STATE_FLAG_FOCUSED;
556 if (get_fg)
557 gtk_style_context_get_color (gsty, state, &col);
558 else
559 gtk_style_context_get_background_color (gsty, state, &col);
561 sprintf (buf, "rgb:%04x/%04x/%04x",
562 (int)(col.red * 65535),
563 (int)(col.green * 65535),
564 (int)(col.blue * 65535));
565 success_p = (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
566 buf, color)
567 != 0);
568 #else
569 GtkStyle *gsty = gtk_widget_get_style (FRAME_GTK_WIDGET (f));
570 GdkColor *grgb = get_bg
571 ? &gsty->bg[GTK_STATE_SELECTED]
572 : &gsty->fg[GTK_STATE_SELECTED];
574 color->red = grgb->red;
575 color->green = grgb->green;
576 color->blue = grgb->blue;
577 color->pixel = grgb->pixel;
578 success_p = 1;
579 #endif
582 unblock_input ();
583 return success_p;
588 /***********************************************************************
589 Tooltips
590 ***********************************************************************/
591 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
592 We use that to pop down the tooltip. This happens if Gtk+ for some
593 reason wants to change or hide the tooltip. */
595 #ifdef USE_GTK_TOOLTIP
597 static void
598 hierarchy_ch_cb (GtkWidget *widget,
599 GtkWidget *previous_toplevel,
600 gpointer user_data)
602 struct frame *f = user_data;
603 struct x_output *x = f->output_data.x;
604 GtkWidget *top = gtk_widget_get_toplevel (x->ttip_lbl);
606 if (! top || ! GTK_IS_WINDOW (top))
607 gtk_widget_hide (previous_toplevel);
610 /* Callback called when Gtk+ thinks a tooltip should be displayed.
611 We use it to get the tooltip window and the tooltip widget so
612 we can manipulate the ourselves.
614 Return FALSE ensures that the tooltip is not shown. */
616 static gboolean
617 qttip_cb (GtkWidget *widget,
618 gint xpos,
619 gint ypos,
620 gboolean keyboard_mode,
621 GtkTooltip *tooltip,
622 gpointer user_data)
624 struct frame *f = user_data;
625 struct x_output *x = f->output_data.x;
626 if (x->ttip_widget == NULL)
628 GtkWidget *p;
629 GList *list, *iter;
631 g_object_set (G_OBJECT (widget), "has-tooltip", FALSE, NULL);
632 x->ttip_widget = tooltip;
633 g_object_ref (G_OBJECT (tooltip));
634 x->ttip_lbl = gtk_label_new ("");
635 g_object_ref (G_OBJECT (x->ttip_lbl));
636 gtk_tooltip_set_custom (tooltip, x->ttip_lbl);
637 x->ttip_window = GTK_WINDOW (gtk_widget_get_toplevel (x->ttip_lbl));
639 /* Change stupid Gtk+ default line wrapping. */
640 p = gtk_widget_get_parent (x->ttip_lbl);
641 list = gtk_container_get_children (GTK_CONTAINER (p));
642 for (iter = list; iter; iter = g_list_next (iter))
644 GtkWidget *w = GTK_WIDGET (iter->data);
645 if (GTK_IS_LABEL (w))
646 gtk_label_set_line_wrap (GTK_LABEL (w), FALSE);
648 g_list_free (list);
650 /* ATK needs an empty title for some reason. */
651 gtk_window_set_title (x->ttip_window, "");
652 /* Realize so we can safely get screen later on. */
653 gtk_widget_realize (GTK_WIDGET (x->ttip_window));
654 gtk_widget_realize (x->ttip_lbl);
656 g_signal_connect (x->ttip_lbl, "hierarchy-changed",
657 G_CALLBACK (hierarchy_ch_cb), f);
659 return FALSE;
662 #endif /* USE_GTK_TOOLTIP */
664 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
665 Return true if a system tooltip is available. */
667 bool
668 xg_prepare_tooltip (struct frame *f,
669 Lisp_Object string,
670 int *width,
671 int *height)
673 #ifndef USE_GTK_TOOLTIP
674 return 0;
675 #else
676 struct x_output *x = f->output_data.x;
677 GtkWidget *widget;
678 GdkWindow *gwin;
679 GdkScreen *screen;
680 GtkSettings *settings;
681 gboolean tt_enabled = TRUE;
682 GtkRequisition req;
683 Lisp_Object encoded_string;
685 if (!x->ttip_lbl) return 0;
687 block_input ();
688 encoded_string = ENCODE_UTF_8 (string);
689 widget = GTK_WIDGET (x->ttip_lbl);
690 gwin = gtk_widget_get_window (GTK_WIDGET (x->ttip_window));
691 screen = gdk_window_get_screen (gwin);
692 settings = gtk_settings_get_for_screen (screen);
693 g_object_get (settings, "gtk-enable-tooltips", &tt_enabled, NULL);
694 if (tt_enabled)
696 g_object_set (settings, "gtk-enable-tooltips", FALSE, NULL);
697 /* Record that we disabled it so it can be enabled again. */
698 g_object_set_data (G_OBJECT (x->ttip_window), "restore-tt",
699 (gpointer)f);
702 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
703 g_object_set_data (G_OBJECT
704 (gtk_widget_get_display (GTK_WIDGET (x->ttip_window))),
705 "gdk-display-current-tooltip", NULL);
707 /* Put our dummy widget in so we can get callbacks for unrealize and
708 hierarchy-changed. */
709 gtk_tooltip_set_custom (x->ttip_widget, widget);
710 gtk_tooltip_set_text (x->ttip_widget, SSDATA (encoded_string));
711 gtk_widget_get_preferred_size (GTK_WIDGET (x->ttip_window), NULL, &req);
712 if (width) *width = req.width;
713 if (height) *height = req.height;
715 unblock_input ();
717 return 1;
718 #endif /* USE_GTK_TOOLTIP */
721 /* Show the tooltip at ROOT_X and ROOT_Y.
722 xg_prepare_tooltip must have been called before this function. */
724 void
725 xg_show_tooltip (struct frame *f, int root_x, int root_y)
727 #ifdef USE_GTK_TOOLTIP
728 struct x_output *x = f->output_data.x;
729 if (x->ttip_window)
731 block_input ();
732 gtk_window_move (x->ttip_window, root_x, root_y);
733 gtk_widget_show_all (GTK_WIDGET (x->ttip_window));
734 unblock_input ();
736 #endif
739 /* Hide tooltip if shown. Do nothing if not shown.
740 Return true if tip was hidden, false if not (i.e. not using
741 system tooltips). */
743 bool
744 xg_hide_tooltip (struct frame *f)
746 bool ret = 0;
747 #ifdef USE_GTK_TOOLTIP
748 if (f->output_data.x->ttip_window)
750 GtkWindow *win = f->output_data.x->ttip_window;
751 block_input ();
752 gtk_widget_hide (GTK_WIDGET (win));
754 if (g_object_get_data (G_OBJECT (win), "restore-tt"))
756 GdkWindow *gwin = gtk_widget_get_window (GTK_WIDGET (win));
757 GdkScreen *screen = gdk_window_get_screen (gwin);
758 GtkSettings *settings = gtk_settings_get_for_screen (screen);
759 g_object_set (settings, "gtk-enable-tooltips", TRUE, NULL);
761 unblock_input ();
763 ret = 1;
765 #endif
766 return ret;
770 /***********************************************************************
771 General functions for creating widgets, resizing, events, e.t.c.
772 ***********************************************************************/
774 static void
775 my_log_handler (const gchar *log_domain, GLogLevelFlags log_level,
776 const gchar *msg, gpointer user_data)
778 if (!strstr (msg, "visible children"))
779 fprintf (stderr, "XX %s-WARNING **: %s\n", log_domain, msg);
782 /* Make a geometry string and pass that to GTK. It seems this is the
783 only way to get geometry position right if the user explicitly
784 asked for a position when starting Emacs.
785 F is the frame we shall set geometry for. */
787 static void
788 xg_set_geometry (struct frame *f)
790 if (f->size_hint_flags & (USPosition | PPosition))
792 int left = f->left_pos;
793 int xneg = f->size_hint_flags & XNegative;
794 int top = f->top_pos;
795 int yneg = f->size_hint_flags & YNegative;
796 char geom_str[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
797 guint id;
799 if (xneg)
800 left = -left;
801 if (yneg)
802 top = -top;
804 sprintf (geom_str, "=%dx%d%c%d%c%d",
805 FRAME_PIXEL_WIDTH (f),
806 FRAME_PIXEL_HEIGHT (f),
807 (xneg ? '-' : '+'), left,
808 (yneg ? '-' : '+'), top);
810 /* Silence warning about visible children. */
811 id = g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL
812 | G_LOG_FLAG_RECURSION, my_log_handler, NULL);
814 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
815 geom_str))
816 fprintf (stderr, "Failed to parse: '%s'\n", geom_str);
818 g_log_remove_handler ("Gtk", id);
822 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
823 and use a GtkFixed widget, this doesn't happen automatically. */
825 void
826 xg_clear_under_internal_border (struct frame *f)
828 if (FRAME_INTERNAL_BORDER_WIDTH (f) > 0)
830 GtkWidget *wfixed = f->output_data.x->edit_widget;
832 gtk_widget_queue_draw (wfixed);
833 gdk_window_process_all_updates ();
835 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), 0, 0,
836 FRAME_PIXEL_WIDTH (f), FRAME_INTERNAL_BORDER_WIDTH (f));
838 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), 0, 0,
839 FRAME_INTERNAL_BORDER_WIDTH (f), FRAME_PIXEL_HEIGHT (f));
841 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), 0,
842 FRAME_PIXEL_HEIGHT (f) - FRAME_INTERNAL_BORDER_WIDTH (f),
843 FRAME_PIXEL_WIDTH (f), FRAME_INTERNAL_BORDER_WIDTH (f));
845 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
846 FRAME_PIXEL_WIDTH (f) - FRAME_INTERNAL_BORDER_WIDTH (f),
847 0, FRAME_INTERNAL_BORDER_WIDTH (f), FRAME_PIXEL_HEIGHT (f));
851 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
852 and a Gtk+ menu bar, we get resize events for the edit part of the
853 frame only. We let Gtk+ deal with the Gtk+ parts.
854 F is the frame to resize.
855 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
857 void
858 xg_frame_resized (struct frame *f, int pixelwidth, int pixelheight)
860 int width, height;
862 if (pixelwidth == -1 && pixelheight == -1)
864 if (FRAME_GTK_WIDGET (f) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f)))
865 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f)),
866 0, 0,
867 &pixelwidth, &pixelheight);
868 else return;
872 width = FRAME_PIXEL_TO_TEXT_WIDTH (f, pixelwidth);
873 height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, pixelheight);
875 if (width != FRAME_TEXT_WIDTH (f)
876 || height != FRAME_TEXT_HEIGHT (f)
877 || pixelwidth != FRAME_PIXEL_WIDTH (f)
878 || pixelheight != FRAME_PIXEL_HEIGHT (f))
880 FRAME_PIXEL_WIDTH (f) = pixelwidth;
881 FRAME_PIXEL_HEIGHT (f) = pixelheight;
883 xg_clear_under_internal_border (f);
884 change_frame_size (f, width, height, 0, 1, 0, 1);
885 SET_FRAME_GARBAGED (f);
886 cancel_mouse_face (f);
888 do_pending_window_change (0);
892 /* Resize the outer window of frame F after changing the height.
893 COLUMNS/ROWS is the size the edit area shall have after the resize. */
895 void
896 xg_frame_set_char_size (struct frame *f, int width, int height)
898 int pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width);
899 int pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height);
901 if (FRAME_PIXEL_HEIGHT (f) == 0)
902 return;
904 /* Do this before resize, as we don't know yet if we will be resized. */
905 xg_clear_under_internal_border (f);
907 /* Must resize our top level widget. Font size may have changed,
908 but not rows/cols. */
909 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
910 pixelwidth + FRAME_TOOLBAR_WIDTH (f),
911 pixelheight + FRAME_TOOLBAR_HEIGHT (f)
912 + FRAME_MENUBAR_HEIGHT (f));
913 x_wm_set_size_hint (f, 0, 0);
915 SET_FRAME_GARBAGED (f);
916 cancel_mouse_face (f);
918 /* We can not call change_frame_size for a mapped frame,
919 we can not set pixel width/height either. The window manager may
920 override our resize request, XMonad does this all the time.
921 The best we can do is try to sync, so lisp code sees the updated
922 size as fast as possible.
923 For unmapped windows, we can set rows/cols. When
924 the frame is mapped again we will (hopefully) get the correct size. */
925 if (FRAME_VISIBLE_P (f))
927 /* Must call this to flush out events */
928 (void)gtk_events_pending ();
929 gdk_flush ();
930 x_wait_for_event (f, ConfigureNotify);
932 else
933 adjust_frame_size (f, -1, -1, 5, 0);
936 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
937 The policy is to keep the number of editable lines. */
939 static void
940 xg_height_or_width_changed (struct frame *f)
942 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
943 FRAME_TOTAL_PIXEL_WIDTH (f),
944 FRAME_TOTAL_PIXEL_HEIGHT (f));
945 f->output_data.x->hint_flags = 0;
946 x_wm_set_size_hint (f, 0, 0);
949 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
950 Must be done like this, because GtkWidget:s can have "hidden"
951 X Window that aren't accessible.
953 Return 0 if no widget match WDESC. */
955 GtkWidget *
956 xg_win_to_widget (Display *dpy, Window wdesc)
958 gpointer gdkwin;
959 GtkWidget *gwdesc = 0;
961 block_input ();
963 gdkwin = gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy),
964 wdesc);
965 if (gdkwin)
967 GdkEvent event;
968 event.any.window = gdkwin;
969 event.any.type = GDK_NOTHING;
970 gwdesc = gtk_get_event_widget (&event);
973 unblock_input ();
974 return gwdesc;
977 /* Set the background of widget W to PIXEL. */
979 static void
980 xg_set_widget_bg (struct frame *f, GtkWidget *w, unsigned long pixel)
982 #ifdef HAVE_GTK3
983 GdkRGBA bg;
984 XColor xbg;
985 xbg.pixel = pixel;
986 if (XQueryColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), &xbg))
988 bg.red = (double)xbg.red/65535.0;
989 bg.green = (double)xbg.green/65535.0;
990 bg.blue = (double)xbg.blue/65535.0;
991 bg.alpha = 1.0;
992 gtk_widget_override_background_color (w, GTK_STATE_FLAG_NORMAL, &bg);
994 #else
995 GdkColor bg;
996 GdkColormap *map = gtk_widget_get_colormap (w);
997 gdk_colormap_query_color (map, pixel, &bg);
998 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f), GTK_STATE_NORMAL, &bg);
999 #endif
1002 /* Callback called when the gtk theme changes.
1003 We notify lisp code so it can fix faces used for region for example. */
1005 static void
1006 style_changed_cb (GObject *go,
1007 GParamSpec *spec,
1008 gpointer user_data)
1010 struct input_event event;
1011 GdkDisplay *gdpy = user_data;
1012 const char *display_name = gdk_display_get_name (gdpy);
1013 Display *dpy = GDK_DISPLAY_XDISPLAY (gdpy);
1015 EVENT_INIT (event);
1016 event.kind = CONFIG_CHANGED_EVENT;
1017 event.frame_or_window = build_string (display_name);
1018 /* Theme doesn't change often, so intern is called seldom. */
1019 event.arg = intern ("theme-name");
1020 kbd_buffer_store_event (&event);
1022 update_theme_scrollbar_width ();
1023 update_theme_scrollbar_height ();
1025 /* If scroll bar width changed, we need set the new size on all frames
1026 on this display. */
1027 if (dpy)
1029 Lisp_Object rest, frame;
1030 FOR_EACH_FRAME (rest, frame)
1032 struct frame *f = XFRAME (frame);
1033 if (FRAME_LIVE_P (f)
1034 && FRAME_X_P (f)
1035 && FRAME_X_DISPLAY (f) == dpy)
1037 x_set_scroll_bar_default_width (f);
1038 x_set_scroll_bar_default_height (f);
1039 xg_frame_set_char_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f));
1045 /* Called when a delete-event occurs on WIDGET. */
1047 static gboolean
1048 delete_cb (GtkWidget *widget,
1049 GdkEvent *event,
1050 gpointer user_data)
1052 #ifdef HAVE_GTK3
1053 /* The event doesn't arrive in the normal event loop. Send event
1054 here. */
1055 struct frame *f = user_data;
1056 struct input_event ie;
1058 EVENT_INIT (ie);
1059 ie.kind = DELETE_WINDOW_EVENT;
1060 XSETFRAME (ie.frame_or_window, f);
1061 kbd_buffer_store_event (&ie);
1062 #endif
1064 return TRUE;
1067 /* Create and set up the GTK widgets for frame F.
1068 Return true if creation succeeded. */
1070 bool
1071 xg_create_frame_widgets (struct frame *f)
1073 GtkWidget *wtop;
1074 GtkWidget *wvbox, *whbox;
1075 GtkWidget *wfixed;
1076 #ifndef HAVE_GTK3
1077 GtkRcStyle *style;
1078 #endif
1079 char *title = 0;
1081 block_input ();
1083 if (FRAME_X_EMBEDDED_P (f))
1085 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
1086 wtop = gtk_plug_new_for_display (gdpy, f->output_data.x->parent_desc);
1088 else
1089 wtop = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1091 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1092 has backported it to Gtk+ 2.0 and they add the resize grip for
1093 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1094 forever, so disable the grip. */
1095 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1096 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1097 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop), FALSE);
1098 #endif
1100 xg_set_screen (wtop, f);
1102 wvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1103 whbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1104 gtk_box_set_homogeneous (GTK_BOX (wvbox), FALSE);
1105 gtk_box_set_homogeneous (GTK_BOX (whbox), FALSE);
1107 #ifdef HAVE_GTK3
1108 wfixed = emacs_fixed_new (f);
1109 #else
1110 wfixed = gtk_fixed_new ();
1111 #endif
1113 if (! wtop || ! wvbox || ! whbox || ! wfixed)
1115 if (wtop) gtk_widget_destroy (wtop);
1116 if (wvbox) gtk_widget_destroy (wvbox);
1117 if (whbox) gtk_widget_destroy (whbox);
1118 if (wfixed) gtk_widget_destroy (wfixed);
1120 unblock_input ();
1121 return 0;
1124 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1125 gtk_widget_set_name (wtop, EMACS_CLASS);
1126 gtk_widget_set_name (wvbox, "pane");
1127 gtk_widget_set_name (wfixed, SSDATA (Vx_resource_name));
1129 /* If this frame has a title or name, set it in the title bar. */
1130 if (! NILP (f->title))
1131 title = SSDATA (ENCODE_UTF_8 (f->title));
1132 else if (! NILP (f->name))
1133 title = SSDATA (ENCODE_UTF_8 (f->name));
1135 if (title) gtk_window_set_title (GTK_WINDOW (wtop), title);
1137 FRAME_GTK_OUTER_WIDGET (f) = wtop;
1138 FRAME_GTK_WIDGET (f) = wfixed;
1139 f->output_data.x->vbox_widget = wvbox;
1140 f->output_data.x->hbox_widget = whbox;
1142 gtk_widget_set_has_window (wfixed, TRUE);
1144 gtk_container_add (GTK_CONTAINER (wtop), wvbox);
1145 gtk_box_pack_start (GTK_BOX (wvbox), whbox, TRUE, TRUE, 0);
1146 gtk_box_pack_start (GTK_BOX (whbox), wfixed, TRUE, TRUE, 0);
1148 if (FRAME_EXTERNAL_TOOL_BAR (f))
1149 update_frame_tool_bar (f);
1151 /* We don't want this widget double buffered, because we draw on it
1152 with regular X drawing primitives, so from a GTK/GDK point of
1153 view, the widget is totally blank. When an expose comes, this
1154 will make the widget blank, and then Emacs redraws it. This flickers
1155 a lot, so we turn off double buffering. */
1156 gtk_widget_set_double_buffered (wfixed, FALSE);
1158 gtk_window_set_wmclass (GTK_WINDOW (wtop),
1159 SSDATA (Vx_resource_name),
1160 SSDATA (Vx_resource_class));
1162 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1163 GTK is to destroy the widget. We want Emacs to do that instead. */
1164 g_signal_connect (G_OBJECT (wtop), "delete-event",
1165 G_CALLBACK (delete_cb), f);
1167 /* Convert our geometry parameters into a geometry string
1168 and specify it.
1169 GTK will itself handle calculating the real position this way. */
1170 xg_set_geometry (f);
1171 f->win_gravity
1172 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
1174 gtk_widget_add_events (wfixed,
1175 GDK_POINTER_MOTION_MASK
1176 | GDK_EXPOSURE_MASK
1177 | GDK_BUTTON_PRESS_MASK
1178 | GDK_BUTTON_RELEASE_MASK
1179 | GDK_KEY_PRESS_MASK
1180 | GDK_ENTER_NOTIFY_MASK
1181 | GDK_LEAVE_NOTIFY_MASK
1182 | GDK_FOCUS_CHANGE_MASK
1183 | GDK_STRUCTURE_MASK
1184 | GDK_VISIBILITY_NOTIFY_MASK);
1186 /* Must realize the windows so the X window gets created. It is used
1187 by callers of this function. */
1188 gtk_widget_realize (wfixed);
1189 FRAME_X_WINDOW (f) = GTK_WIDGET_TO_X_WIN (wfixed);
1191 /* Since GTK clears its window by filling with the background color,
1192 we must keep X and GTK background in sync. */
1193 xg_set_widget_bg (f, wfixed, FRAME_BACKGROUND_PIXEL (f));
1195 #ifndef HAVE_GTK3
1196 /* Also, do not let any background pixmap to be set, this looks very
1197 bad as Emacs overwrites the background pixmap with its own idea
1198 of background color. */
1199 style = gtk_widget_get_modifier_style (wfixed);
1201 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1202 style->bg_pixmap_name[GTK_STATE_NORMAL] = g_strdup ("<none>");
1203 gtk_widget_modify_style (wfixed, style);
1204 #else
1205 gtk_widget_set_can_focus (wfixed, TRUE);
1206 gtk_window_set_resizable (GTK_WINDOW (wtop), TRUE);
1207 #endif
1209 #ifdef USE_GTK_TOOLTIP
1210 /* Steal a tool tip window we can move ourselves. */
1211 f->output_data.x->ttip_widget = 0;
1212 f->output_data.x->ttip_lbl = 0;
1213 f->output_data.x->ttip_window = 0;
1214 gtk_widget_set_tooltip_text (wtop, "Dummy text");
1215 g_signal_connect (wtop, "query-tooltip", G_CALLBACK (qttip_cb), f);
1216 #endif
1219 GdkScreen *screen = gtk_widget_get_screen (wtop);
1220 GtkSettings *gs = gtk_settings_get_for_screen (screen);
1221 /* Only connect this signal once per screen. */
1222 if (! g_signal_handler_find (G_OBJECT (gs),
1223 G_SIGNAL_MATCH_FUNC,
1224 0, 0, 0,
1225 G_CALLBACK (style_changed_cb),
1228 g_signal_connect (G_OBJECT (gs), "notify::gtk-theme-name",
1229 G_CALLBACK (style_changed_cb),
1230 gdk_screen_get_display (screen));
1234 unblock_input ();
1236 return 1;
1239 void
1240 xg_free_frame_widgets (struct frame *f)
1242 if (FRAME_GTK_OUTER_WIDGET (f))
1244 #ifdef USE_GTK_TOOLTIP
1245 struct x_output *x = f->output_data.x;
1246 #endif
1247 struct xg_frame_tb_info *tbinfo
1248 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
1249 TB_INFO_KEY);
1250 if (tbinfo)
1251 xfree (tbinfo);
1253 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f));
1254 FRAME_X_WINDOW (f) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1255 FRAME_GTK_OUTER_WIDGET (f) = 0;
1256 #ifdef USE_GTK_TOOLTIP
1257 if (x->ttip_lbl)
1258 gtk_widget_destroy (x->ttip_lbl);
1259 if (x->ttip_widget)
1260 g_object_unref (G_OBJECT (x->ttip_widget));
1261 #endif
1265 /* Set the normal size hints for the window manager, for frame F.
1266 FLAGS is the flags word to use--or 0 meaning preserve the flags
1267 that the window now has.
1268 If USER_POSITION, set the User Position
1269 flag (this is useful when FLAGS is 0). */
1271 void
1272 x_wm_set_size_hint (struct frame *f, long int flags, bool user_position)
1274 /* Must use GTK routines here, otherwise GTK resets the size hints
1275 to its own defaults. */
1276 GdkGeometry size_hints;
1277 gint hint_flags = 0;
1278 int base_width, base_height;
1279 int min_rows = 0, min_cols = 0;
1280 int win_gravity = f->win_gravity;
1281 Lisp_Object fs_state, frame;
1283 /* Don't set size hints during initialization; that apparently leads
1284 to a race condition. See the thread at
1285 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1286 if (NILP (Vafter_init_time) || !FRAME_GTK_OUTER_WIDGET (f))
1287 return;
1289 XSETFRAME (frame, f);
1290 fs_state = Fframe_parameter (frame, Qfullscreen);
1291 if (EQ (fs_state, Qmaximized) || EQ (fs_state, Qfullboth))
1293 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1294 Gtk3 don't get along and the frame shrinks (!).
1296 return;
1299 if (flags)
1301 memset (&size_hints, 0, sizeof (size_hints));
1302 f->output_data.x->size_hints = size_hints;
1303 f->output_data.x->hint_flags = hint_flags;
1305 else
1306 flags = f->size_hint_flags;
1308 size_hints = f->output_data.x->size_hints;
1309 hint_flags = f->output_data.x->hint_flags;
1311 hint_flags |= GDK_HINT_RESIZE_INC | GDK_HINT_MIN_SIZE;
1312 size_hints.width_inc = frame_resize_pixelwise ? 1 : FRAME_COLUMN_WIDTH (f);
1313 size_hints.height_inc = frame_resize_pixelwise ? 1 : FRAME_LINE_HEIGHT (f);
1315 hint_flags |= GDK_HINT_BASE_SIZE;
1316 /* Use one row/col here so base_height/width does not become zero.
1317 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1318 base_width = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 1) + FRAME_TOOLBAR_WIDTH (f);
1319 base_height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 1)
1320 + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f);
1322 if (min_cols > 0) --min_cols; /* We used one col in base_width = ... 1); */
1323 if (min_rows > 0) --min_rows; /* We used one row in base_height = ... 1); */
1325 size_hints.base_width = base_width;
1326 size_hints.base_height = base_height;
1327 size_hints.min_width = base_width + min_cols * FRAME_COLUMN_WIDTH (f);;
1328 size_hints.min_height = base_height + min_rows * FRAME_LINE_HEIGHT (f);
1330 /* These currently have a one to one mapping with the X values, but I
1331 don't think we should rely on that. */
1332 hint_flags |= GDK_HINT_WIN_GRAVITY;
1333 size_hints.win_gravity = 0;
1334 if (win_gravity == NorthWestGravity)
1335 size_hints.win_gravity = GDK_GRAVITY_NORTH_WEST;
1336 else if (win_gravity == NorthGravity)
1337 size_hints.win_gravity = GDK_GRAVITY_NORTH;
1338 else if (win_gravity == NorthEastGravity)
1339 size_hints.win_gravity = GDK_GRAVITY_NORTH_EAST;
1340 else if (win_gravity == WestGravity)
1341 size_hints.win_gravity = GDK_GRAVITY_WEST;
1342 else if (win_gravity == CenterGravity)
1343 size_hints.win_gravity = GDK_GRAVITY_CENTER;
1344 else if (win_gravity == EastGravity)
1345 size_hints.win_gravity = GDK_GRAVITY_EAST;
1346 else if (win_gravity == SouthWestGravity)
1347 size_hints.win_gravity = GDK_GRAVITY_SOUTH_WEST;
1348 else if (win_gravity == SouthGravity)
1349 size_hints.win_gravity = GDK_GRAVITY_SOUTH;
1350 else if (win_gravity == SouthEastGravity)
1351 size_hints.win_gravity = GDK_GRAVITY_SOUTH_EAST;
1352 else if (win_gravity == StaticGravity)
1353 size_hints.win_gravity = GDK_GRAVITY_STATIC;
1355 if (user_position)
1357 hint_flags &= ~GDK_HINT_POS;
1358 hint_flags |= GDK_HINT_USER_POS;
1361 if (hint_flags != f->output_data.x->hint_flags
1362 || memcmp (&size_hints,
1363 &f->output_data.x->size_hints,
1364 sizeof (size_hints)) != 0)
1366 block_input ();
1367 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
1368 NULL, &size_hints, hint_flags);
1369 f->output_data.x->size_hints = size_hints;
1370 f->output_data.x->hint_flags = hint_flags;
1371 unblock_input ();
1375 /* Change background color of a frame.
1376 Since GTK uses the background color to clear the window, we must
1377 keep the GTK and X colors in sync.
1378 F is the frame to change,
1379 BG is the pixel value to change to. */
1381 void
1382 xg_set_background_color (struct frame *f, unsigned long bg)
1384 if (FRAME_GTK_WIDGET (f))
1386 block_input ();
1387 xg_set_widget_bg (f, FRAME_GTK_WIDGET (f), FRAME_BACKGROUND_PIXEL (f));
1388 unblock_input ();
1393 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1394 functions so GTK does not overwrite the icon. */
1396 void
1397 xg_set_frame_icon (struct frame *f, Pixmap icon_pixmap, Pixmap icon_mask)
1399 GdkPixbuf *gp = xg_get_pixbuf_from_pix_and_mask (f,
1400 icon_pixmap,
1401 icon_mask);
1402 if (gp)
1403 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)), gp);
1408 /***********************************************************************
1409 Dialog functions
1410 ***********************************************************************/
1411 /* Return the dialog title to use for a dialog of type KEY.
1412 This is the encoding used by lwlib. We use the same for GTK. */
1414 static const char *
1415 get_dialog_title (char key)
1417 const char *title = "";
1419 switch (key) {
1420 case 'E': case 'e':
1421 title = "Error";
1422 break;
1424 case 'I': case 'i':
1425 title = "Information";
1426 break;
1428 case 'L': case 'l':
1429 title = "Prompt";
1430 break;
1432 case 'P': case 'p':
1433 title = "Prompt";
1434 break;
1436 case 'Q': case 'q':
1437 title = "Question";
1438 break;
1441 return title;
1444 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1445 the dialog, but return TRUE so the event does not propagate further
1446 in GTK. This prevents GTK from destroying the dialog widget automatically
1447 and we can always destroy the widget manually, regardless of how
1448 it was popped down (button press or WM_DELETE_WINDOW).
1449 W is the dialog widget.
1450 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1451 user_data is NULL (not used).
1453 Returns TRUE to end propagation of event. */
1455 static gboolean
1456 dialog_delete_callback (GtkWidget *w, GdkEvent *event, gpointer user_data)
1458 gtk_widget_unmap (w);
1459 return TRUE;
1462 /* Create a popup dialog window. See also xg_create_widget below.
1463 WV is a widget_value describing the dialog.
1464 SELECT_CB is the callback to use when a button has been pressed.
1465 DEACTIVATE_CB is the callback to use when the dialog pops down.
1467 Returns the GTK dialog widget. */
1469 static GtkWidget *
1470 create_dialog (widget_value *wv,
1471 GCallback select_cb,
1472 GCallback deactivate_cb)
1474 const char *title = get_dialog_title (wv->name[0]);
1475 int total_buttons = wv->name[1] - '0';
1476 int right_buttons = wv->name[4] - '0';
1477 int left_buttons;
1478 int button_nr = 0;
1479 int button_spacing = 10;
1480 GtkWidget *wdialog = gtk_dialog_new ();
1481 GtkDialog *wd = GTK_DIALOG (wdialog);
1482 GtkBox *cur_box = GTK_BOX (gtk_dialog_get_action_area (wd));
1483 widget_value *item;
1484 GtkWidget *whbox_down;
1486 /* If the number of buttons is greater than 4, make two rows of buttons
1487 instead. This looks better. */
1488 bool make_two_rows = total_buttons > 4;
1490 if (right_buttons == 0) right_buttons = total_buttons/2;
1491 left_buttons = total_buttons - right_buttons;
1493 gtk_window_set_title (GTK_WINDOW (wdialog), title);
1494 gtk_widget_set_name (wdialog, "emacs-dialog");
1497 if (make_two_rows)
1499 GtkWidget *wvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, button_spacing);
1500 GtkWidget *whbox_up = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1501 gtk_box_set_homogeneous (GTK_BOX (wvbox), TRUE);
1502 gtk_box_set_homogeneous (GTK_BOX (whbox_up), FALSE);
1503 whbox_down = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1504 gtk_box_set_homogeneous (GTK_BOX (whbox_down), FALSE);
1506 gtk_box_pack_start (cur_box, wvbox, FALSE, FALSE, 0);
1507 gtk_box_pack_start (GTK_BOX (wvbox), whbox_up, FALSE, FALSE, 0);
1508 gtk_box_pack_start (GTK_BOX (wvbox), whbox_down, FALSE, FALSE, 0);
1510 cur_box = GTK_BOX (whbox_up);
1513 g_signal_connect (G_OBJECT (wdialog), "delete-event",
1514 G_CALLBACK (dialog_delete_callback), 0);
1516 if (deactivate_cb)
1518 g_signal_connect (G_OBJECT (wdialog), "close", deactivate_cb, 0);
1519 g_signal_connect (G_OBJECT (wdialog), "response", deactivate_cb, 0);
1522 for (item = wv->contents; item; item = item->next)
1524 char *utf8_label = get_utf8_string (item->value);
1525 GtkWidget *w;
1526 GtkRequisition req;
1528 if (item->name && strcmp (item->name, "message") == 0)
1530 GtkBox *wvbox = GTK_BOX (gtk_dialog_get_content_area (wd));
1531 /* This is the text part of the dialog. */
1532 w = gtk_label_new (utf8_label);
1533 gtk_box_pack_start (wvbox, gtk_label_new (""), FALSE, FALSE, 0);
1534 gtk_box_pack_start (wvbox, w, TRUE, TRUE, 0);
1535 gtk_misc_set_alignment (GTK_MISC (w), 0.1, 0.5);
1537 /* Try to make dialog look better. Must realize first so
1538 the widget can calculate the size it needs. */
1539 gtk_widget_realize (w);
1540 gtk_widget_get_preferred_size (w, NULL, &req);
1541 gtk_box_set_spacing (wvbox, req.height);
1542 if (item->value && strlen (item->value) > 0)
1543 button_spacing = 2*req.width/strlen (item->value);
1545 else
1547 /* This is one button to add to the dialog. */
1548 w = gtk_button_new_with_label (utf8_label);
1549 if (! item->enabled)
1550 gtk_widget_set_sensitive (w, FALSE);
1551 if (select_cb)
1552 g_signal_connect (G_OBJECT (w), "clicked",
1553 select_cb, item->call_data);
1555 gtk_box_pack_start (cur_box, w, TRUE, TRUE, button_spacing);
1556 if (++button_nr == left_buttons)
1558 if (make_two_rows)
1559 cur_box = GTK_BOX (whbox_down);
1560 else
1561 gtk_box_pack_start (cur_box,
1562 gtk_label_new (""),
1563 TRUE, TRUE,
1564 button_spacing);
1568 if (utf8_label)
1569 g_free (utf8_label);
1572 return wdialog;
1575 struct xg_dialog_data
1577 GMainLoop *loop;
1578 int response;
1579 GtkWidget *w;
1580 guint timerid;
1583 /* Function that is called when the file or font dialogs pop down.
1584 W is the dialog widget, RESPONSE is the response code.
1585 USER_DATA is what we passed in to g_signal_connect. */
1587 static void
1588 xg_dialog_response_cb (GtkDialog *w,
1589 gint response,
1590 gpointer user_data)
1592 struct xg_dialog_data *dd = user_data;
1593 dd->response = response;
1594 g_main_loop_quit (dd->loop);
1598 /* Destroy the dialog. This makes it pop down. */
1600 static void
1601 pop_down_dialog (void *arg)
1603 struct xg_dialog_data *dd = arg;
1605 block_input ();
1606 if (dd->w) gtk_widget_destroy (dd->w);
1607 if (dd->timerid != 0) g_source_remove (dd->timerid);
1609 g_main_loop_quit (dd->loop);
1610 g_main_loop_unref (dd->loop);
1612 unblock_input ();
1615 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1616 We pass in DATA as gpointer* so we can use this as a callback. */
1618 static gboolean
1619 xg_maybe_add_timer (gpointer data)
1621 struct xg_dialog_data *dd = data;
1622 struct timespec next_time = timer_check ();
1624 dd->timerid = 0;
1626 if (timespec_valid_p (next_time))
1628 time_t s = next_time.tv_sec;
1629 int per_ms = TIMESPEC_RESOLUTION / 1000;
1630 int ms = (next_time.tv_nsec + per_ms - 1) / per_ms;
1631 if (s <= ((guint) -1 - ms) / 1000)
1632 dd->timerid = g_timeout_add (s * 1000 + ms, xg_maybe_add_timer, dd);
1634 return FALSE;
1638 /* Pops up a modal dialog W and waits for response.
1639 We don't use gtk_dialog_run because we want to process emacs timers.
1640 The dialog W is not destroyed when this function returns. */
1642 static int
1643 xg_dialog_run (struct frame *f, GtkWidget *w)
1645 ptrdiff_t count = SPECPDL_INDEX ();
1646 struct xg_dialog_data dd;
1648 xg_set_screen (w, f);
1649 gtk_window_set_transient_for (GTK_WINDOW (w),
1650 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
1651 gtk_window_set_destroy_with_parent (GTK_WINDOW (w), TRUE);
1652 gtk_window_set_modal (GTK_WINDOW (w), TRUE);
1654 dd.loop = g_main_loop_new (NULL, FALSE);
1655 dd.response = GTK_RESPONSE_CANCEL;
1656 dd.w = w;
1657 dd.timerid = 0;
1659 g_signal_connect (G_OBJECT (w),
1660 "response",
1661 G_CALLBACK (xg_dialog_response_cb),
1662 &dd);
1663 /* Don't destroy the widget if closed by the window manager close button. */
1664 g_signal_connect (G_OBJECT (w), "delete-event", G_CALLBACK (gtk_true), NULL);
1665 gtk_widget_show (w);
1667 record_unwind_protect_ptr (pop_down_dialog, &dd);
1669 (void) xg_maybe_add_timer (&dd);
1670 g_main_loop_run (dd.loop);
1672 dd.w = 0;
1673 unbind_to (count, Qnil);
1675 return dd.response;
1679 /***********************************************************************
1680 File dialog functions
1681 ***********************************************************************/
1682 /* Return true if the old file selection dialog is being used. */
1684 bool
1685 xg_uses_old_file_dialog (void)
1687 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1688 return x_gtk_use_old_file_dialog;
1689 #else
1690 return 0;
1691 #endif
1695 typedef char * (*xg_get_file_func) (GtkWidget *);
1697 /* Return the selected file for file chooser dialog W.
1698 The returned string must be free:d. */
1700 static char *
1701 xg_get_file_name_from_chooser (GtkWidget *w)
1703 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w));
1706 /* Callback called when the "Show hidden files" toggle is pressed.
1707 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1709 static void
1710 xg_toggle_visibility_cb (GtkWidget *widget, gpointer data)
1712 GtkFileChooser *dialog = GTK_FILE_CHOOSER (data);
1713 gboolean visible;
1714 g_object_get (G_OBJECT (dialog), "show-hidden", &visible, NULL);
1715 g_object_set (G_OBJECT (dialog), "show-hidden", !visible, NULL);
1719 /* Callback called when a property changes in a file chooser.
1720 GOBJECT is the file chooser dialog, ARG1 describes the property.
1721 USER_DATA is the toggle widget in the file chooser dialog.
1722 We use this to update the "Show hidden files" toggle when the user
1723 changes that property by right clicking in the file list. */
1725 static void
1726 xg_toggle_notify_cb (GObject *gobject, GParamSpec *arg1, gpointer user_data)
1728 if (strcmp (arg1->name, "show-hidden") == 0)
1730 GtkWidget *wtoggle = GTK_WIDGET (user_data);
1731 gboolean visible, toggle_on;
1733 g_object_get (G_OBJECT (gobject), "show-hidden", &visible, NULL);
1734 toggle_on = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle));
1736 if (!!visible != !!toggle_on)
1738 g_signal_handlers_block_by_func (G_OBJECT (wtoggle),
1739 G_CALLBACK (xg_toggle_visibility_cb),
1740 gobject);
1741 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle), visible);
1742 g_signal_handlers_unblock_by_func
1743 (G_OBJECT (wtoggle),
1744 G_CALLBACK (xg_toggle_visibility_cb),
1745 gobject);
1747 x_gtk_show_hidden_files = visible;
1751 /* Read a file name from the user using a file chooser dialog.
1752 F is the current frame.
1753 PROMPT is a prompt to show to the user. May not be NULL.
1754 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1755 If MUSTMATCH_P, the returned file name must be an existing
1756 file. (Actually, this only has cosmetic effects, the user can
1757 still enter a non-existing file.) *FUNC is set to a function that
1758 can be used to retrieve the selected file name from the returned widget.
1760 Returns the created widget. */
1762 static GtkWidget *
1763 xg_get_file_with_chooser (struct frame *f,
1764 char *prompt,
1765 char *default_filename,
1766 bool mustmatch_p, bool only_dir_p,
1767 xg_get_file_func *func)
1769 char msgbuf[1024];
1771 GtkWidget *filewin, *wtoggle, *wbox, *wmessage IF_LINT (= NULL);
1772 GtkWindow *gwin = GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f));
1773 GtkFileChooserAction action = (mustmatch_p ?
1774 GTK_FILE_CHOOSER_ACTION_OPEN :
1775 GTK_FILE_CHOOSER_ACTION_SAVE);
1777 if (only_dir_p)
1778 action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
1780 filewin = gtk_file_chooser_dialog_new (prompt, gwin, action,
1781 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1782 (mustmatch_p || only_dir_p ?
1783 GTK_STOCK_OPEN : GTK_STOCK_OK),
1784 GTK_RESPONSE_OK,
1785 NULL);
1786 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin), TRUE);
1788 wbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1789 gtk_box_set_homogeneous (GTK_BOX (wbox), FALSE);
1790 gtk_widget_show (wbox);
1791 wtoggle = gtk_check_button_new_with_label ("Show hidden files.");
1793 if (x_gtk_show_hidden_files)
1795 g_object_set (G_OBJECT (filewin), "show-hidden", TRUE, NULL);
1796 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle), TRUE);
1798 gtk_widget_show (wtoggle);
1799 g_signal_connect (G_OBJECT (wtoggle), "clicked",
1800 G_CALLBACK (xg_toggle_visibility_cb), filewin);
1801 g_signal_connect (G_OBJECT (filewin), "notify",
1802 G_CALLBACK (xg_toggle_notify_cb), wtoggle);
1804 if (x_gtk_file_dialog_help_text)
1806 msgbuf[0] = '\0';
1807 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1808 Show the C-l help text only for versions < 2.10. */
1809 if (gtk_check_version (2, 10, 0) && action != GTK_FILE_CHOOSER_ACTION_SAVE)
1810 strcat (msgbuf, "\nType C-l to display a file name text entry box.\n");
1811 strcat (msgbuf, "\nIf you don't like this file selector, use the "
1812 "corresponding\nkey binding or customize "
1813 "use-file-dialog to turn it off.");
1815 wmessage = gtk_label_new (msgbuf);
1816 gtk_widget_show (wmessage);
1819 gtk_box_pack_start (GTK_BOX (wbox), wtoggle, FALSE, FALSE, 0);
1820 if (x_gtk_file_dialog_help_text)
1821 gtk_box_pack_start (GTK_BOX (wbox), wmessage, FALSE, FALSE, 0);
1822 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin), wbox);
1824 if (default_filename)
1826 Lisp_Object file;
1827 struct gcpro gcpro1;
1828 char *utf8_filename;
1829 GCPRO1 (file);
1831 file = build_string (default_filename);
1833 /* File chooser does not understand ~/... in the file name. It must be
1834 an absolute name starting with /. */
1835 if (default_filename[0] != '/')
1836 file = Fexpand_file_name (file, Qnil);
1838 utf8_filename = SSDATA (ENCODE_UTF_8 (file));
1839 if (! NILP (Ffile_directory_p (file)))
1840 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin),
1841 utf8_filename);
1842 else
1844 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin),
1845 utf8_filename);
1846 if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
1848 char *cp = strrchr (utf8_filename, '/');
1849 if (cp) ++cp;
1850 else cp = utf8_filename;
1851 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin), cp);
1855 UNGCPRO;
1858 *func = xg_get_file_name_from_chooser;
1859 return filewin;
1862 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1864 /* Return the selected file for file selector dialog W.
1865 The returned string must be free:d. */
1867 static char *
1868 xg_get_file_name_from_selector (GtkWidget *w)
1870 GtkFileSelection *filesel = GTK_FILE_SELECTION (w);
1871 return xstrdup (gtk_file_selection_get_filename (filesel));
1874 /* Create a file selection dialog.
1875 F is the current frame.
1876 PROMPT is a prompt to show to the user. May not be NULL.
1877 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1878 If MUSTMATCH_P, the returned file name must be an existing
1879 file. *FUNC is set to a function that can be used to retrieve the
1880 selected file name from the returned widget.
1882 Returns the created widget. */
1884 static GtkWidget *
1885 xg_get_file_with_selection (struct frame *f,
1886 char *prompt,
1887 char *default_filename,
1888 bool mustmatch_p, bool only_dir_p,
1889 xg_get_file_func *func)
1891 GtkWidget *filewin;
1892 GtkFileSelection *filesel;
1894 filewin = gtk_file_selection_new (prompt);
1895 filesel = GTK_FILE_SELECTION (filewin);
1897 if (default_filename)
1898 gtk_file_selection_set_filename (filesel, default_filename);
1900 if (mustmatch_p)
1902 /* The selection_entry part of filesel is not documented. */
1903 gtk_widget_set_sensitive (filesel->selection_entry, FALSE);
1904 gtk_file_selection_hide_fileop_buttons (filesel);
1907 *func = xg_get_file_name_from_selector;
1909 return filewin;
1911 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1913 /* Read a file name from the user using a file dialog, either the old
1914 file selection dialog, or the new file chooser dialog. Which to use
1915 depends on what the GTK version used has, and what the value of
1916 gtk-use-old-file-dialog.
1917 F is the current frame.
1918 PROMPT is a prompt to show to the user. May not be NULL.
1919 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1920 If MUSTMATCH_P, the returned file name must be an existing
1921 file.
1923 Returns a file name or NULL if no file was selected.
1924 The returned string must be freed by the caller. */
1926 char *
1927 xg_get_file_name (struct frame *f,
1928 char *prompt,
1929 char *default_filename,
1930 bool mustmatch_p,
1931 bool only_dir_p)
1933 GtkWidget *w = 0;
1934 char *fn = 0;
1935 int filesel_done = 0;
1936 xg_get_file_func func;
1938 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1940 if (xg_uses_old_file_dialog ())
1941 w = xg_get_file_with_selection (f, prompt, default_filename,
1942 mustmatch_p, only_dir_p, &func);
1943 else
1944 w = xg_get_file_with_chooser (f, prompt, default_filename,
1945 mustmatch_p, only_dir_p, &func);
1947 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1948 w = xg_get_file_with_chooser (f, prompt, default_filename,
1949 mustmatch_p, only_dir_p, &func);
1950 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1952 gtk_widget_set_name (w, "emacs-filedialog");
1954 filesel_done = xg_dialog_run (f, w);
1955 if (filesel_done == GTK_RESPONSE_OK)
1956 fn = (*func) (w);
1958 gtk_widget_destroy (w);
1959 return fn;
1962 /***********************************************************************
1963 GTK font chooser
1964 ***********************************************************************/
1966 #ifdef HAVE_FREETYPE
1968 #if USE_NEW_GTK_FONT_CHOOSER
1970 #define XG_WEIGHT_TO_SYMBOL(w) \
1971 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
1972 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
1973 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
1974 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
1975 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
1976 : w <= PANGO_WEIGHT_BOLD ? Qbold \
1977 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
1978 : Qultra_bold)
1980 #define XG_STYLE_TO_SYMBOL(s) \
1981 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
1982 : s == PANGO_STYLE_ITALIC ? Qitalic \
1983 : Qnormal)
1985 #endif /* USE_NEW_GTK_FONT_CHOOSER */
1988 static char *x_last_font_name;
1990 /* Pop up a GTK font selector and return the name of the font the user
1991 selects, as a C string. The returned font name follows GTK's own
1992 format:
1994 `FAMILY [VALUE1 VALUE2] SIZE'
1996 This can be parsed using font_parse_fcname in font.c.
1997 DEFAULT_NAME, if non-zero, is the default font name. */
1999 Lisp_Object
2000 xg_get_font (struct frame *f, const char *default_name)
2002 GtkWidget *w;
2003 int done = 0;
2004 Lisp_Object font = Qnil;
2006 w = gtk_font_chooser_dialog_new
2007 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
2009 if (default_name)
2011 /* Convert fontconfig names to Gtk names, i.e. remove - before
2012 number */
2013 char *p = strrchr (default_name, '-');
2014 if (p)
2016 char *ep = p+1;
2017 while (c_isdigit (*ep))
2018 ++ep;
2019 if (*ep == '\0') *p = ' ';
2022 else if (x_last_font_name)
2023 default_name = x_last_font_name;
2025 if (default_name)
2026 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w), default_name);
2028 gtk_widget_set_name (w, "emacs-fontdialog");
2029 done = xg_dialog_run (f, w);
2030 if (done == GTK_RESPONSE_OK)
2032 #if USE_NEW_GTK_FONT_CHOOSER
2033 /* Use the GTK3 font chooser. */
2034 PangoFontDescription *desc
2035 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w));
2037 if (desc)
2039 Lisp_Object args[10];
2040 const char *name = pango_font_description_get_family (desc);
2041 gint size = pango_font_description_get_size (desc);
2042 PangoWeight weight = pango_font_description_get_weight (desc);
2043 PangoStyle style = pango_font_description_get_style (desc);
2045 args[0] = QCname;
2046 args[1] = build_string (name);
2048 args[2] = QCsize;
2049 args[3] = make_float (pango_units_to_double (size));
2051 args[4] = QCweight;
2052 args[5] = XG_WEIGHT_TO_SYMBOL (weight);
2054 args[6] = QCslant;
2055 args[7] = XG_STYLE_TO_SYMBOL (style);
2057 args[8] = QCtype;
2058 args[9] = Qxft;
2060 font = Ffont_spec (8, args);
2062 pango_font_description_free (desc);
2063 dupstring (&x_last_font_name, name);
2066 #else /* Use old font selector, which just returns the font name. */
2068 char *font_name
2069 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w));
2071 if (font_name)
2073 font = build_string (font_name);
2074 g_free (x_last_font_name);
2075 x_last_font_name = font_name;
2077 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2080 gtk_widget_destroy (w);
2081 return font;
2083 #endif /* HAVE_FREETYPE */
2087 /***********************************************************************
2088 Menu functions.
2089 ***********************************************************************/
2091 /* The name of menu items that can be used for customization. Since GTK
2092 RC files are very crude and primitive, we have to set this on all
2093 menu item names so a user can easily customize menu items. */
2095 #define MENU_ITEM_NAME "emacs-menuitem"
2098 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2099 during GC. The next member points to the items. */
2100 static xg_list_node xg_menu_cb_list;
2102 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2103 during GC. The next member points to the items. */
2104 static xg_list_node xg_menu_item_cb_list;
2106 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2107 F is the frame CL_DATA will be initialized for.
2108 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2110 The menu bar and all sub menus under the menu bar in a frame
2111 share the same structure, hence the reference count.
2113 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2114 allocated xg_menu_cb_data if CL_DATA is NULL. */
2116 static xg_menu_cb_data *
2117 make_cl_data (xg_menu_cb_data *cl_data, struct frame *f, GCallback highlight_cb)
2119 if (! cl_data)
2121 cl_data = xmalloc (sizeof *cl_data);
2122 cl_data->f = f;
2123 cl_data->menu_bar_vector = f->menu_bar_vector;
2124 cl_data->menu_bar_items_used = f->menu_bar_items_used;
2125 cl_data->highlight_cb = highlight_cb;
2126 cl_data->ref_count = 0;
2128 xg_list_insert (&xg_menu_cb_list, &cl_data->ptrs);
2131 cl_data->ref_count++;
2133 return cl_data;
2136 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2137 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2139 When the menu bar is updated, menu items may have been added and/or
2140 removed, so menu_bar_vector and menu_bar_items_used change. We must
2141 then update CL_DATA since it is used to determine which menu
2142 item that is invoked in the menu.
2143 HIGHLIGHT_CB could change, there is no check that the same
2144 function is given when modifying a menu bar as was given when
2145 creating the menu bar. */
2147 static void
2148 update_cl_data (xg_menu_cb_data *cl_data,
2149 struct frame *f,
2150 GCallback highlight_cb)
2152 if (cl_data)
2154 cl_data->f = f;
2155 cl_data->menu_bar_vector = f->menu_bar_vector;
2156 cl_data->menu_bar_items_used = f->menu_bar_items_used;
2157 cl_data->highlight_cb = highlight_cb;
2161 /* Decrease reference count for CL_DATA.
2162 If reference count is zero, free CL_DATA. */
2164 static void
2165 unref_cl_data (xg_menu_cb_data *cl_data)
2167 if (cl_data && cl_data->ref_count > 0)
2169 cl_data->ref_count--;
2170 if (cl_data->ref_count == 0)
2172 xg_list_remove (&xg_menu_cb_list, &cl_data->ptrs);
2173 xfree (cl_data);
2178 /* Function that marks all lisp data during GC. */
2180 void
2181 xg_mark_data (void)
2183 xg_list_node *iter;
2184 Lisp_Object rest, frame;
2186 for (iter = xg_menu_cb_list.next; iter; iter = iter->next)
2187 mark_object (((xg_menu_cb_data *) iter)->menu_bar_vector);
2189 for (iter = xg_menu_item_cb_list.next; iter; iter = iter->next)
2191 xg_menu_item_cb_data *cb_data = (xg_menu_item_cb_data *) iter;
2193 if (! NILP (cb_data->help))
2194 mark_object (cb_data->help);
2197 FOR_EACH_FRAME (rest, frame)
2199 struct frame *f = XFRAME (frame);
2201 if (FRAME_X_P (f) && FRAME_GTK_OUTER_WIDGET (f))
2203 struct xg_frame_tb_info *tbinfo
2204 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
2205 TB_INFO_KEY);
2206 if (tbinfo)
2208 mark_object (tbinfo->last_tool_bar);
2209 mark_object (tbinfo->style);
2216 /* Callback called when a menu item is destroyed. Used to free data.
2217 W is the widget that is being destroyed (not used).
2218 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2220 static void
2221 menuitem_destroy_callback (GtkWidget *w, gpointer client_data)
2223 if (client_data)
2225 xg_menu_item_cb_data *data = client_data;
2226 xg_list_remove (&xg_menu_item_cb_list, &data->ptrs);
2227 xfree (data);
2231 /* Callback called when the pointer enters/leaves a menu item.
2232 W is the parent of the menu item.
2233 EVENT is either an enter event or leave event.
2234 CLIENT_DATA is not used.
2236 Returns FALSE to tell GTK to keep processing this event. */
2238 static gboolean
2239 menuitem_highlight_callback (GtkWidget *w,
2240 GdkEventCrossing *event,
2241 gpointer client_data)
2243 GdkEvent ev;
2244 GtkWidget *subwidget;
2245 xg_menu_item_cb_data *data;
2247 ev.crossing = *event;
2248 subwidget = gtk_get_event_widget (&ev);
2249 data = g_object_get_data (G_OBJECT (subwidget), XG_ITEM_DATA);
2250 if (data)
2252 if (! NILP (data->help) && data->cl_data->highlight_cb)
2254 gpointer call_data = event->type == GDK_LEAVE_NOTIFY ? 0 : data;
2255 GtkCallback func = (GtkCallback) data->cl_data->highlight_cb;
2256 (*func) (subwidget, call_data);
2260 return FALSE;
2263 /* Callback called when a menu is destroyed. Used to free data.
2264 W is the widget that is being destroyed (not used).
2265 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2267 static void
2268 menu_destroy_callback (GtkWidget *w, gpointer client_data)
2270 unref_cl_data (client_data);
2273 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2274 must be non-NULL) and can be inserted into a menu item.
2276 Returns the GtkHBox. */
2278 static GtkWidget *
2279 make_widget_for_menu_item (const char *utf8_label, const char *utf8_key)
2281 GtkWidget *wlbl;
2282 GtkWidget *wkey;
2283 GtkWidget *wbox;
2285 wbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2286 gtk_box_set_homogeneous (GTK_BOX (wbox), FALSE);
2287 wlbl = gtk_label_new (utf8_label);
2288 wkey = gtk_label_new (utf8_key);
2290 gtk_misc_set_alignment (GTK_MISC (wlbl), 0.0, 0.5);
2291 gtk_misc_set_alignment (GTK_MISC (wkey), 0.0, 0.5);
2293 gtk_box_pack_start (GTK_BOX (wbox), wlbl, TRUE, TRUE, 0);
2294 gtk_box_pack_start (GTK_BOX (wbox), wkey, FALSE, FALSE, 0);
2296 gtk_widget_set_name (wlbl, MENU_ITEM_NAME);
2297 gtk_widget_set_name (wkey, MENU_ITEM_NAME);
2298 gtk_widget_set_name (wbox, MENU_ITEM_NAME);
2300 return wbox;
2303 /* Make and return a menu item widget with the key to the right.
2304 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2305 UTF8_KEY is the text representing the key binding.
2306 ITEM is the widget_value describing the menu item.
2308 GROUP is an in/out parameter. If the menu item to be created is not
2309 part of any radio menu group, *GROUP contains NULL on entry and exit.
2310 If the menu item to be created is part of a radio menu group, on entry
2311 *GROUP contains the group to use, or NULL if this is the first item
2312 in the group. On exit, *GROUP contains the radio item group.
2314 Unfortunately, keys don't line up as nicely as in Motif,
2315 but the MacOS X version doesn't either, so I guess that is OK. */
2317 static GtkWidget *
2318 make_menu_item (const char *utf8_label,
2319 const char *utf8_key,
2320 widget_value *item,
2321 GSList **group)
2323 GtkWidget *w;
2324 GtkWidget *wtoadd = 0;
2326 /* It has been observed that some menu items have a NULL name field.
2327 This will lead to this function being called with a NULL utf8_label.
2328 GTK crashes on that so we set a blank label. Why there is a NULL
2329 name remains to be investigated. */
2330 if (! utf8_label) utf8_label = " ";
2332 if (utf8_key)
2333 wtoadd = make_widget_for_menu_item (utf8_label, utf8_key);
2335 if (item->button_type == BUTTON_TYPE_TOGGLE)
2337 *group = NULL;
2338 if (utf8_key) w = gtk_check_menu_item_new ();
2339 else w = gtk_check_menu_item_new_with_label (utf8_label);
2340 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), item->selected);
2342 else if (item->button_type == BUTTON_TYPE_RADIO)
2344 if (utf8_key) w = gtk_radio_menu_item_new (*group);
2345 else w = gtk_radio_menu_item_new_with_label (*group, utf8_label);
2346 *group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w));
2347 if (item->selected)
2348 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), TRUE);
2350 else
2352 *group = NULL;
2353 if (utf8_key) w = gtk_menu_item_new ();
2354 else w = gtk_menu_item_new_with_label (utf8_label);
2357 if (wtoadd) gtk_container_add (GTK_CONTAINER (w), wtoadd);
2358 if (! item->enabled) gtk_widget_set_sensitive (w, FALSE);
2360 return w;
2363 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2365 static int xg_detached_menus;
2367 /* Return true if there are detached menus. */
2369 bool
2370 xg_have_tear_offs (struct frame *f)
2372 /* If the frame's menubar height is zero, the menu bar is probably
2373 being redirected outside the window to some kind of global menu;
2374 this situation is the moral equivalent of a tear-off. */
2375 return FRAME_MENUBAR_HEIGHT (f) == 0 || xg_detached_menus > 0;
2378 /* Callback invoked when a detached menu window is removed. Here we
2379 decrease the xg_detached_menus count.
2380 WIDGET is the top level window that is removed (the parent of the menu).
2381 CLIENT_DATA is not used. */
2383 static void
2384 tearoff_remove (GtkWidget *widget, gpointer client_data)
2386 if (xg_detached_menus > 0) --xg_detached_menus;
2389 /* Callback invoked when a menu is detached. It increases the
2390 xg_detached_menus count.
2391 WIDGET is the GtkTearoffMenuItem.
2392 CLIENT_DATA is not used. */
2394 static void
2395 tearoff_activate (GtkWidget *widget, gpointer client_data)
2397 GtkWidget *menu = gtk_widget_get_parent (widget);
2398 if (gtk_menu_get_tearoff_state (GTK_MENU (menu)))
2400 ++xg_detached_menus;
2401 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget)),
2402 "destroy",
2403 G_CALLBACK (tearoff_remove), 0);
2406 #else /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2407 bool
2408 xg_have_tear_offs (struct frame *f)
2410 return FRAME_MENUBAR_HEIGHT (f) == 0;
2412 #endif /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2414 /* Create a menu item widget, and connect the callbacks.
2415 ITEM describes the menu item.
2416 F is the frame the created menu belongs to.
2417 SELECT_CB is the callback to use when a menu item is selected.
2418 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2419 CL_DATA points to the callback data to be used for this menu.
2420 GROUP is an in/out parameter. If the menu item to be created is not
2421 part of any radio menu group, *GROUP contains NULL on entry and exit.
2422 If the menu item to be created is part of a radio menu group, on entry
2423 *GROUP contains the group to use, or NULL if this is the first item
2424 in the group. On exit, *GROUP contains the radio item group.
2426 Returns the created GtkWidget. */
2428 static GtkWidget *
2429 xg_create_one_menuitem (widget_value *item,
2430 struct frame *f,
2431 GCallback select_cb,
2432 GCallback highlight_cb,
2433 xg_menu_cb_data *cl_data,
2434 GSList **group)
2436 char *utf8_label;
2437 char *utf8_key;
2438 GtkWidget *w;
2439 xg_menu_item_cb_data *cb_data;
2441 utf8_label = get_utf8_string (item->name);
2442 utf8_key = get_utf8_string (item->key);
2444 w = make_menu_item (utf8_label, utf8_key, item, group);
2446 if (utf8_label) g_free (utf8_label);
2447 if (utf8_key) g_free (utf8_key);
2449 cb_data = xmalloc (sizeof *cb_data);
2451 xg_list_insert (&xg_menu_item_cb_list, &cb_data->ptrs);
2453 cb_data->select_id = 0;
2454 cb_data->help = item->help;
2455 cb_data->cl_data = cl_data;
2456 cb_data->call_data = item->call_data;
2458 g_signal_connect (G_OBJECT (w),
2459 "destroy",
2460 G_CALLBACK (menuitem_destroy_callback),
2461 cb_data);
2463 /* Put cb_data in widget, so we can get at it when modifying menubar */
2464 g_object_set_data (G_OBJECT (w), XG_ITEM_DATA, cb_data);
2466 /* final item, not a submenu */
2467 if (item->call_data && ! item->contents)
2469 if (select_cb)
2470 cb_data->select_id
2471 = g_signal_connect (G_OBJECT (w), "activate", select_cb, cb_data);
2474 return w;
2477 /* Create a full menu tree specified by DATA.
2478 F is the frame the created menu belongs to.
2479 SELECT_CB is the callback to use when a menu item is selected.
2480 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2481 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2482 If POP_UP_P, create a popup menu.
2483 If MENU_BAR_P, create a menu bar.
2484 If ADD_TEAROFF_P, add a tearoff menu item. Ignored if MENU_BAR_P or
2485 the Gtk+ version used does not have tearoffs.
2486 TOPMENU is the topmost GtkWidget that others shall be placed under.
2487 It may be NULL, in that case we create the appropriate widget
2488 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2489 CL_DATA is the callback data we shall use for this menu, or NULL
2490 if we haven't set the first callback yet.
2491 NAME is the name to give to the top level menu if this function
2492 creates it. May be NULL to not set any name.
2494 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2495 not NULL.
2497 This function calls itself to create submenus. */
2499 static GtkWidget *
2500 create_menus (widget_value *data,
2501 struct frame *f,
2502 GCallback select_cb,
2503 GCallback deactivate_cb,
2504 GCallback highlight_cb,
2505 bool pop_up_p,
2506 bool menu_bar_p,
2507 bool add_tearoff_p,
2508 GtkWidget *topmenu,
2509 xg_menu_cb_data *cl_data,
2510 const char *name)
2512 widget_value *item;
2513 GtkWidget *wmenu = topmenu;
2514 GSList *group = NULL;
2516 if (! topmenu)
2518 if (! menu_bar_p)
2520 wmenu = gtk_menu_new ();
2521 xg_set_screen (wmenu, f);
2522 /* Connect this to the menu instead of items so we get enter/leave for
2523 disabled items also. TODO: Still does not get enter/leave for
2524 disabled items in detached menus. */
2525 g_signal_connect (G_OBJECT (wmenu),
2526 "enter-notify-event",
2527 G_CALLBACK (menuitem_highlight_callback),
2528 NULL);
2529 g_signal_connect (G_OBJECT (wmenu),
2530 "leave-notify-event",
2531 G_CALLBACK (menuitem_highlight_callback),
2532 NULL);
2534 else
2536 wmenu = gtk_menu_bar_new ();
2537 /* Set width of menu bar to a small value so it doesn't enlarge
2538 a small initial frame size. The width will be set to the
2539 width of the frame later on when it is added to a container.
2540 height -1: Natural height. */
2541 gtk_widget_set_size_request (wmenu, 1, -1);
2544 /* Put cl_data on the top menu for easier access. */
2545 cl_data = make_cl_data (cl_data, f, highlight_cb);
2546 g_object_set_data (G_OBJECT (wmenu), XG_FRAME_DATA, (gpointer)cl_data);
2547 g_signal_connect (G_OBJECT (wmenu), "destroy",
2548 G_CALLBACK (menu_destroy_callback), cl_data);
2550 if (name)
2551 gtk_widget_set_name (wmenu, name);
2553 if (deactivate_cb)
2554 g_signal_connect (G_OBJECT (wmenu),
2555 "selection-done", deactivate_cb, 0);
2558 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2559 if (! menu_bar_p && add_tearoff_p)
2561 GtkWidget *tearoff = gtk_tearoff_menu_item_new ();
2562 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu), tearoff);
2564 g_signal_connect (G_OBJECT (tearoff), "activate",
2565 G_CALLBACK (tearoff_activate), 0);
2567 #endif
2569 for (item = data; item; item = item->next)
2571 GtkWidget *w;
2573 if (pop_up_p && !item->contents && !item->call_data
2574 && !menu_separator_name_p (item->name))
2576 char *utf8_label;
2577 /* A title for a popup. We do the same as GTK does when
2578 creating titles, but it does not look good. */
2579 group = NULL;
2580 utf8_label = get_utf8_string (item->name);
2582 gtk_menu_set_title (GTK_MENU (wmenu), utf8_label);
2583 w = gtk_menu_item_new_with_label (utf8_label);
2584 gtk_widget_set_sensitive (w, FALSE);
2585 if (utf8_label) g_free (utf8_label);
2587 else if (menu_separator_name_p (item->name))
2589 group = NULL;
2590 /* GTK only have one separator type. */
2591 w = gtk_separator_menu_item_new ();
2593 else
2595 w = xg_create_one_menuitem (item,
2597 item->contents ? 0 : select_cb,
2598 highlight_cb,
2599 cl_data,
2600 &group);
2602 /* Create a possibly empty submenu for menu bar items, since some
2603 themes don't highlight items correctly without it. */
2604 if (item->contents || menu_bar_p)
2606 GtkWidget *submenu = create_menus (item->contents,
2608 select_cb,
2609 deactivate_cb,
2610 highlight_cb,
2613 add_tearoff_p,
2615 cl_data,
2617 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), submenu);
2621 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu), w);
2622 gtk_widget_set_name (w, MENU_ITEM_NAME);
2625 return wmenu;
2628 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2629 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2630 with some text and buttons.
2631 F is the frame the created item belongs to.
2632 NAME is the name to use for the top widget.
2633 VAL is a widget_value structure describing items to be created.
2634 SELECT_CB is the callback to use when a menu item is selected or
2635 a dialog button is pressed.
2636 DEACTIVATE_CB is the callback to use when an item is deactivated.
2637 For a menu, when a sub menu is not shown anymore, for a dialog it is
2638 called when the dialog is popped down.
2639 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2641 Returns the widget created. */
2643 GtkWidget *
2644 xg_create_widget (const char *type, const char *name, struct frame *f,
2645 widget_value *val, GCallback select_cb,
2646 GCallback deactivate_cb, GCallback highlight_cb)
2648 GtkWidget *w = 0;
2649 bool menu_bar_p = strcmp (type, "menubar") == 0;
2650 bool pop_up_p = strcmp (type, "popup") == 0;
2652 if (strcmp (type, "dialog") == 0)
2654 w = create_dialog (val, select_cb, deactivate_cb);
2655 xg_set_screen (w, f);
2656 gtk_window_set_transient_for (GTK_WINDOW (w),
2657 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
2658 gtk_window_set_destroy_with_parent (GTK_WINDOW (w), TRUE);
2659 gtk_widget_set_name (w, "emacs-dialog");
2660 gtk_window_set_modal (GTK_WINDOW (w), TRUE);
2662 else if (menu_bar_p || pop_up_p)
2664 w = create_menus (val->contents,
2666 select_cb,
2667 deactivate_cb,
2668 highlight_cb,
2669 pop_up_p,
2670 menu_bar_p,
2671 menu_bar_p,
2674 name);
2676 /* Set the cursor to an arrow for popup menus when they are mapped.
2677 This is done by default for menu bar menus. */
2678 if (pop_up_p)
2680 /* Must realize so the GdkWindow inside the widget is created. */
2681 gtk_widget_realize (w);
2682 xg_set_cursor (w, FRAME_DISPLAY_INFO (f)->xg_cursor);
2685 else
2687 fprintf (stderr, "bad type in xg_create_widget: %s, doing nothing\n",
2688 type);
2691 return w;
2694 /* Return the label for menu item WITEM. */
2696 static const char *
2697 xg_get_menu_item_label (GtkMenuItem *witem)
2699 GtkLabel *wlabel = GTK_LABEL (XG_BIN_CHILD (witem));
2700 return gtk_label_get_label (wlabel);
2703 /* Return true if the menu item WITEM has the text LABEL. */
2705 static bool
2706 xg_item_label_same_p (GtkMenuItem *witem, const char *label)
2708 bool is_same = 0;
2709 char *utf8_label = get_utf8_string (label);
2710 const char *old_label = witem ? xg_get_menu_item_label (witem) : 0;
2712 if (! old_label && ! utf8_label)
2713 is_same = 1;
2714 else if (old_label && utf8_label)
2715 is_same = strcmp (utf8_label, old_label) == 0;
2717 if (utf8_label) g_free (utf8_label);
2719 return is_same;
2722 /* Destroy widgets in LIST. */
2724 static void
2725 xg_destroy_widgets (GList *list)
2727 GList *iter;
2729 for (iter = list; iter; iter = g_list_next (iter))
2731 GtkWidget *w = GTK_WIDGET (iter->data);
2733 /* Destroying the widget will remove it from the container it is in. */
2734 gtk_widget_destroy (w);
2738 /* Update the top level names in MENUBAR (i.e. not submenus).
2739 F is the frame the menu bar belongs to.
2740 *LIST is a list with the current menu bar names (menu item widgets).
2741 ITER is the item within *LIST that shall be updated.
2742 POS is the numerical position, starting at 0, of ITER in *LIST.
2743 VAL describes what the menu bar shall look like after the update.
2744 SELECT_CB is the callback to use when a menu item is selected.
2745 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2746 CL_DATA points to the callback data to be used for this menu bar.
2748 This function calls itself to walk through the menu bar names. */
2750 static void
2751 xg_update_menubar (GtkWidget *menubar,
2752 struct frame *f,
2753 GList **list,
2754 GList *iter,
2755 int pos,
2756 widget_value *val,
2757 GCallback select_cb,
2758 GCallback deactivate_cb,
2759 GCallback highlight_cb,
2760 xg_menu_cb_data *cl_data)
2762 if (! iter && ! val)
2763 return;
2764 else if (iter && ! val)
2766 /* Item(s) have been removed. Remove all remaining items. */
2767 xg_destroy_widgets (iter);
2769 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2770 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar),
2771 gtk_menu_item_new_with_label (""),
2773 /* All updated. */
2774 val = 0;
2775 iter = 0;
2777 else if (! iter && val)
2779 /* Item(s) added. Add all new items in one call. */
2780 create_menus (val, f, select_cb, deactivate_cb, highlight_cb,
2781 0, 1, 0, menubar, cl_data, 0);
2783 /* All updated. */
2784 val = 0;
2785 iter = 0;
2787 /* Below this neither iter or val is NULL */
2788 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter->data), val->name))
2790 /* This item is still the same, check next item. */
2791 val = val->next;
2792 iter = g_list_next (iter);
2793 ++pos;
2795 else /* This item is changed. */
2797 GtkMenuItem *witem = GTK_MENU_ITEM (iter->data);
2798 GtkMenuItem *witem2 = 0;
2799 bool val_in_menubar = 0;
2800 bool iter_in_new_menubar = 0;
2801 GList *iter2;
2802 widget_value *cur;
2804 /* See if the changed entry (val) is present later in the menu bar */
2805 for (iter2 = iter;
2806 iter2 && ! val_in_menubar;
2807 iter2 = g_list_next (iter2))
2809 witem2 = GTK_MENU_ITEM (iter2->data);
2810 val_in_menubar = xg_item_label_same_p (witem2, val->name);
2813 /* See if the current entry (iter) is present later in the
2814 specification for the new menu bar. */
2815 for (cur = val; cur && ! iter_in_new_menubar; cur = cur->next)
2816 iter_in_new_menubar = xg_item_label_same_p (witem, cur->name);
2818 if (val_in_menubar && ! iter_in_new_menubar)
2820 int nr = pos;
2822 /* This corresponds to:
2823 Current: A B C
2824 New: A C
2825 Remove B. */
2827 g_object_ref (G_OBJECT (witem));
2828 gtk_container_remove (GTK_CONTAINER (menubar), GTK_WIDGET (witem));
2829 gtk_widget_destroy (GTK_WIDGET (witem));
2831 /* Must get new list since the old changed. */
2832 g_list_free (*list);
2833 *list = iter = gtk_container_get_children (GTK_CONTAINER (menubar));
2834 while (nr-- > 0) iter = g_list_next (iter);
2836 else if (! val_in_menubar && ! iter_in_new_menubar)
2838 /* This corresponds to:
2839 Current: A B C
2840 New: A X C
2841 Rename B to X. This might seem to be a strange thing to do,
2842 since if there is a menu under B it will be totally wrong for X.
2843 But consider editing a C file. Then there is a C-mode menu
2844 (corresponds to B above).
2845 If then doing C-x C-f the minibuf menu (X above) replaces the
2846 C-mode menu. When returning from the minibuffer, we get
2847 back the C-mode menu. Thus we do:
2848 Rename B to X (C-mode to minibuf menu)
2849 Rename X to B (minibuf to C-mode menu).
2850 If the X menu hasn't been invoked, the menu under B
2851 is up to date when leaving the minibuffer. */
2852 GtkLabel *wlabel = GTK_LABEL (XG_BIN_CHILD (witem));
2853 char *utf8_label = get_utf8_string (val->name);
2854 GtkWidget *submenu = gtk_menu_item_get_submenu (witem);
2856 /* GTK menu items don't notice when their labels have been
2857 changed from underneath them, so we have to explicitly
2858 use g_object_notify to tell listeners (e.g., a GMenuModel
2859 bridge that might be loaded) that the item's label has
2860 changed. */
2861 gtk_label_set_text (wlabel, utf8_label);
2862 g_object_notify (G_OBJECT (witem), "label");
2864 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2865 /* If this item has a submenu that has been detached, change
2866 the title in the WM decorations also. */
2867 if (submenu && gtk_menu_get_tearoff_state (GTK_MENU (submenu)))
2868 /* Set the title of the detached window. */
2869 gtk_menu_set_title (GTK_MENU (submenu), utf8_label);
2870 #endif
2872 if (utf8_label) g_free (utf8_label);
2873 iter = g_list_next (iter);
2874 val = val->next;
2875 ++pos;
2877 else if (! val_in_menubar && iter_in_new_menubar)
2879 /* This corresponds to:
2880 Current: A B C
2881 New: A X B C
2882 Insert X. */
2884 int nr = pos;
2885 GSList *group = 0;
2886 GtkWidget *w = xg_create_one_menuitem (val,
2888 select_cb,
2889 highlight_cb,
2890 cl_data,
2891 &group);
2893 /* Create a possibly empty submenu for menu bar items, since some
2894 themes don't highlight items correctly without it. */
2895 GtkWidget *submenu = create_menus (NULL, f,
2896 select_cb, deactivate_cb,
2897 highlight_cb,
2898 0, 0, 0, 0, cl_data, 0);
2900 gtk_widget_set_name (w, MENU_ITEM_NAME);
2901 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar), w, pos);
2902 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), submenu);
2904 g_list_free (*list);
2905 *list = iter = gtk_container_get_children (GTK_CONTAINER (menubar));
2906 while (nr-- > 0) iter = g_list_next (iter);
2907 iter = g_list_next (iter);
2908 val = val->next;
2909 ++pos;
2911 else /* if (val_in_menubar && iter_in_new_menubar) */
2913 int nr = pos;
2914 /* This corresponds to:
2915 Current: A B C
2916 New: A C B
2917 Move C before B */
2919 g_object_ref (G_OBJECT (witem2));
2920 gtk_container_remove (GTK_CONTAINER (menubar), GTK_WIDGET (witem2));
2921 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar),
2922 GTK_WIDGET (witem2), pos);
2923 g_object_unref (G_OBJECT (witem2));
2925 g_list_free (*list);
2926 *list = iter = gtk_container_get_children (GTK_CONTAINER (menubar));
2927 while (nr-- > 0) iter = g_list_next (iter);
2928 if (iter) iter = g_list_next (iter);
2929 val = val->next;
2930 ++pos;
2934 /* Update the rest of the menu bar. */
2935 xg_update_menubar (menubar, f, list, iter, pos, val,
2936 select_cb, deactivate_cb, highlight_cb, cl_data);
2939 /* Update the menu item W so it corresponds to VAL.
2940 SELECT_CB is the callback to use when a menu item is selected.
2941 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2942 CL_DATA is the data to set in the widget for menu invocation. */
2944 static void
2945 xg_update_menu_item (widget_value *val,
2946 GtkWidget *w,
2947 GCallback select_cb,
2948 GCallback highlight_cb,
2949 xg_menu_cb_data *cl_data)
2951 GtkWidget *wchild;
2952 GtkLabel *wlbl = 0;
2953 GtkLabel *wkey = 0;
2954 char *utf8_label;
2955 char *utf8_key;
2956 const char *old_label = 0;
2957 const char *old_key = 0;
2958 xg_menu_item_cb_data *cb_data;
2959 bool label_changed = false;
2961 wchild = XG_BIN_CHILD (w);
2962 utf8_label = get_utf8_string (val->name);
2963 utf8_key = get_utf8_string (val->key);
2965 /* See if W is a menu item with a key. See make_menu_item above. */
2966 if (GTK_IS_BOX (wchild))
2968 GList *list = gtk_container_get_children (GTK_CONTAINER (wchild));
2970 wlbl = GTK_LABEL (list->data);
2971 wkey = GTK_LABEL (list->next->data);
2972 g_list_free (list);
2974 if (! utf8_key)
2976 /* Remove the key and keep just the label. */
2977 g_object_ref (G_OBJECT (wlbl));
2978 gtk_container_remove (GTK_CONTAINER (w), wchild);
2979 gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (wlbl));
2980 g_object_unref (G_OBJECT (wlbl));
2981 wkey = 0;
2985 else /* Just a label. */
2987 wlbl = GTK_LABEL (wchild);
2989 /* Check if there is now a key. */
2990 if (utf8_key)
2992 GtkWidget *wtoadd = make_widget_for_menu_item (utf8_label, utf8_key);
2993 GList *list = gtk_container_get_children (GTK_CONTAINER (wtoadd));
2995 wlbl = GTK_LABEL (list->data);
2996 wkey = GTK_LABEL (list->next->data);
2997 g_list_free (list);
2999 gtk_container_remove (GTK_CONTAINER (w), wchild);
3000 gtk_container_add (GTK_CONTAINER (w), wtoadd);
3004 if (wkey) old_key = gtk_label_get_label (wkey);
3005 if (wlbl) old_label = gtk_label_get_label (wlbl);
3007 if (wkey && utf8_key && (! old_key || strcmp (utf8_key, old_key) != 0))
3009 label_changed = true;
3010 gtk_label_set_text (wkey, utf8_key);
3013 if (! old_label || strcmp (utf8_label, old_label) != 0)
3015 label_changed = true;
3016 gtk_label_set_text (wlbl, utf8_label);
3019 if (utf8_key) g_free (utf8_key);
3020 if (utf8_label) g_free (utf8_label);
3022 if (! val->enabled && gtk_widget_get_sensitive (w))
3023 gtk_widget_set_sensitive (w, FALSE);
3024 else if (val->enabled && ! gtk_widget_get_sensitive (w))
3025 gtk_widget_set_sensitive (w, TRUE);
3027 cb_data = g_object_get_data (G_OBJECT (w), XG_ITEM_DATA);
3028 if (cb_data)
3030 cb_data->call_data = val->call_data;
3031 cb_data->help = val->help;
3032 cb_data->cl_data = cl_data;
3034 /* We assume the callback functions don't change. */
3035 if (val->call_data && ! val->contents)
3037 /* This item shall have a select callback. */
3038 if (! cb_data->select_id)
3039 cb_data->select_id
3040 = g_signal_connect (G_OBJECT (w), "activate",
3041 select_cb, cb_data);
3043 else if (cb_data->select_id)
3045 g_signal_handler_disconnect (w, cb_data->select_id);
3046 cb_data->select_id = 0;
3050 if (label_changed) /* See comment in xg_update_menubar. */
3051 g_object_notify (G_OBJECT (w), "label");
3054 /* Update the toggle menu item W so it corresponds to VAL. */
3056 static void
3057 xg_update_toggle_item (widget_value *val, GtkWidget *w)
3059 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), val->selected);
3062 /* Update the radio menu item W so it corresponds to VAL. */
3064 static void
3065 xg_update_radio_item (widget_value *val, GtkWidget *w)
3067 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), val->selected);
3070 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3071 SUBMENU may be NULL, in that case a new menu is created.
3072 F is the frame the menu bar belongs to.
3073 VAL describes the contents of the menu bar.
3074 SELECT_CB is the callback to use when a menu item is selected.
3075 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3076 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3077 CL_DATA is the call back data to use for any newly created items.
3079 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3080 was NULL. */
3082 static GtkWidget *
3083 xg_update_submenu (GtkWidget *submenu,
3084 struct frame *f,
3085 widget_value *val,
3086 GCallback select_cb,
3087 GCallback deactivate_cb,
3088 GCallback highlight_cb,
3089 xg_menu_cb_data *cl_data)
3091 GtkWidget *newsub = submenu;
3092 GList *list = 0;
3093 GList *iter;
3094 widget_value *cur;
3095 bool has_tearoff_p = 0;
3096 GList *first_radio = 0;
3098 if (submenu)
3099 list = gtk_container_get_children (GTK_CONTAINER (submenu));
3101 for (cur = val, iter = list;
3102 cur && iter;
3103 iter = g_list_next (iter), cur = cur->next)
3105 GtkWidget *w = GTK_WIDGET (iter->data);
3107 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
3108 /* Skip tearoff items, they have no counterpart in val. */
3109 if (GTK_IS_TEAROFF_MENU_ITEM (w))
3111 has_tearoff_p = 1;
3112 iter = g_list_next (iter);
3113 if (iter) w = GTK_WIDGET (iter->data);
3114 else break;
3116 #endif
3118 /* Remember first radio button in a group. If we get a mismatch in
3119 a radio group we must rebuild the whole group so that the connections
3120 in GTK becomes correct. */
3121 if (cur->button_type == BUTTON_TYPE_RADIO && ! first_radio)
3122 first_radio = iter;
3123 else if (cur->button_type != BUTTON_TYPE_RADIO
3124 && ! GTK_IS_RADIO_MENU_ITEM (w))
3125 first_radio = 0;
3127 if (GTK_IS_SEPARATOR_MENU_ITEM (w))
3129 if (! menu_separator_name_p (cur->name))
3130 break;
3132 else if (GTK_IS_CHECK_MENU_ITEM (w))
3134 if (cur->button_type != BUTTON_TYPE_TOGGLE)
3135 break;
3136 xg_update_toggle_item (cur, w);
3137 xg_update_menu_item (cur, w, select_cb, highlight_cb, cl_data);
3139 else if (GTK_IS_RADIO_MENU_ITEM (w))
3141 if (cur->button_type != BUTTON_TYPE_RADIO)
3142 break;
3143 xg_update_radio_item (cur, w);
3144 xg_update_menu_item (cur, w, select_cb, highlight_cb, cl_data);
3146 else if (GTK_IS_MENU_ITEM (w))
3148 GtkMenuItem *witem = GTK_MENU_ITEM (w);
3149 GtkWidget *sub;
3151 if (cur->button_type != BUTTON_TYPE_NONE ||
3152 menu_separator_name_p (cur->name))
3153 break;
3155 xg_update_menu_item (cur, w, select_cb, highlight_cb, cl_data);
3157 sub = gtk_menu_item_get_submenu (witem);
3158 if (sub && ! cur->contents)
3160 /* Not a submenu anymore. */
3161 g_object_ref (G_OBJECT (sub));
3162 remove_submenu (witem);
3163 gtk_widget_destroy (sub);
3165 else if (cur->contents)
3167 GtkWidget *nsub;
3169 nsub = xg_update_submenu (sub, f, cur->contents,
3170 select_cb, deactivate_cb,
3171 highlight_cb, cl_data);
3173 /* If this item just became a submenu, we must set it. */
3174 if (nsub != sub)
3175 gtk_menu_item_set_submenu (witem, nsub);
3178 else
3180 /* Structural difference. Remove everything from here and down
3181 in SUBMENU. */
3182 break;
3186 /* Remove widgets from first structural change. */
3187 if (iter)
3189 /* If we are adding new menu items below, we must remove from
3190 first radio button so that radio groups become correct. */
3191 if (cur && first_radio) xg_destroy_widgets (first_radio);
3192 else xg_destroy_widgets (iter);
3195 if (cur)
3197 /* More items added. Create them. */
3198 newsub = create_menus (cur,
3200 select_cb,
3201 deactivate_cb,
3202 highlight_cb,
3205 ! has_tearoff_p,
3206 submenu,
3207 cl_data,
3211 if (list) g_list_free (list);
3213 return newsub;
3216 /* Update the MENUBAR.
3217 F is the frame the menu bar belongs to.
3218 VAL describes the contents of the menu bar.
3219 If DEEP_P, rebuild all but the top level menu names in
3220 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3221 SELECT_CB is the callback to use when a menu item is selected.
3222 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3223 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3225 void
3226 xg_modify_menubar_widgets (GtkWidget *menubar, struct frame *f,
3227 widget_value *val, bool deep_p,
3228 GCallback select_cb, GCallback deactivate_cb,
3229 GCallback highlight_cb)
3231 xg_menu_cb_data *cl_data;
3232 GList *list = gtk_container_get_children (GTK_CONTAINER (menubar));
3234 if (! list) return;
3236 cl_data = g_object_get_data (G_OBJECT (menubar), XG_FRAME_DATA);
3238 xg_update_menubar (menubar, f, &list, list, 0, val->contents,
3239 select_cb, deactivate_cb, highlight_cb, cl_data);
3241 if (deep_p)
3243 widget_value *cur;
3245 /* Update all sub menus.
3246 We must keep the submenus (GTK menu item widgets) since the
3247 X Window in the XEvent that activates the menu are those widgets. */
3249 /* Update cl_data, menu_item things in F may have changed. */
3250 update_cl_data (cl_data, f, highlight_cb);
3252 for (cur = val->contents; cur; cur = cur->next)
3254 GList *iter;
3255 GtkWidget *sub = 0;
3256 GtkWidget *newsub;
3257 GtkMenuItem *witem = 0;
3259 /* Find sub menu that corresponds to val and update it. */
3260 for (iter = list ; iter; iter = g_list_next (iter))
3262 witem = GTK_MENU_ITEM (iter->data);
3263 if (xg_item_label_same_p (witem, cur->name))
3265 sub = gtk_menu_item_get_submenu (witem);
3266 break;
3270 newsub = xg_update_submenu (sub,
3272 cur->contents,
3273 select_cb,
3274 deactivate_cb,
3275 highlight_cb,
3276 cl_data);
3277 /* sub may still be NULL. If we just updated non deep and added
3278 a new menu bar item, it has no sub menu yet. So we set the
3279 newly created sub menu under witem. */
3280 if (newsub != sub && witem != 0)
3282 xg_set_screen (newsub, f);
3283 gtk_menu_item_set_submenu (witem, newsub);
3288 g_list_free (list);
3289 gtk_widget_show_all (menubar);
3292 /* Callback called when the menu bar W is mapped.
3293 Used to find the height of the menu bar if we didn't get it
3294 after showing the widget. */
3296 static void
3297 menubar_map_cb (GtkWidget *w, gpointer user_data)
3299 GtkRequisition req;
3300 struct frame *f = user_data;
3301 gtk_widget_get_preferred_size (w, NULL, &req);
3302 if (FRAME_MENUBAR_HEIGHT (f) != req.height)
3304 FRAME_MENUBAR_HEIGHT (f) = req.height;
3305 xg_height_or_width_changed (f);
3309 /* Recompute all the widgets of frame F, when the menu bar has been
3310 changed. */
3312 void
3313 xg_update_frame_menubar (struct frame *f)
3315 struct x_output *x = f->output_data.x;
3316 GtkRequisition req;
3318 if (!x->menubar_widget || gtk_widget_get_mapped (x->menubar_widget))
3319 return;
3321 if (x->menubar_widget && gtk_widget_get_parent (x->menubar_widget))
3322 return; /* Already done this, happens for frames created invisible. */
3324 block_input ();
3326 gtk_box_pack_start (GTK_BOX (x->vbox_widget), x->menubar_widget,
3327 FALSE, FALSE, 0);
3328 gtk_box_reorder_child (GTK_BOX (x->vbox_widget), x->menubar_widget, 0);
3330 g_signal_connect (x->menubar_widget, "map", G_CALLBACK (menubar_map_cb), f);
3331 gtk_widget_show_all (x->menubar_widget);
3332 gtk_widget_get_preferred_size (x->menubar_widget, NULL, &req);
3334 if (FRAME_MENUBAR_HEIGHT (f) != req.height)
3336 FRAME_MENUBAR_HEIGHT (f) = req.height;
3337 xg_height_or_width_changed (f);
3339 unblock_input ();
3342 /* Get rid of the menu bar of frame F, and free its storage.
3343 This is used when deleting a frame, and when turning off the menu bar. */
3345 void
3346 free_frame_menubar (struct frame *f)
3348 struct x_output *x = f->output_data.x;
3350 if (x->menubar_widget)
3352 block_input ();
3354 gtk_container_remove (GTK_CONTAINER (x->vbox_widget), x->menubar_widget);
3355 /* The menubar and its children shall be deleted when removed from
3356 the container. */
3357 x->menubar_widget = 0;
3358 FRAME_MENUBAR_HEIGHT (f) = 0;
3359 xg_height_or_width_changed (f);
3360 unblock_input ();
3364 bool
3365 xg_event_is_for_menubar (struct frame *f, const XEvent *event)
3367 struct x_output *x = f->output_data.x;
3368 GList *iter;
3369 GdkRectangle rec;
3370 GList *list;
3371 GdkDisplay *gdpy;
3372 GdkWindow *gw;
3373 GdkEvent gevent;
3374 GtkWidget *gwdesc;
3376 if (! x->menubar_widget) return 0;
3378 if (! (event->xbutton.x >= 0
3379 && event->xbutton.x < FRAME_PIXEL_WIDTH (f)
3380 && event->xbutton.y >= 0
3381 && event->xbutton.y < FRAME_MENUBAR_HEIGHT (f)
3382 && event->xbutton.same_screen))
3383 return 0;
3385 gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
3386 gw = gdk_x11_window_lookup_for_display (gdpy, event->xbutton.window);
3387 if (! gw) return 0;
3388 gevent.any.window = gw;
3389 gevent.any.type = GDK_NOTHING;
3390 gwdesc = gtk_get_event_widget (&gevent);
3391 if (! gwdesc) return 0;
3392 if (! GTK_IS_MENU_BAR (gwdesc)
3393 && ! GTK_IS_MENU_ITEM (gwdesc)
3394 && ! gtk_widget_is_ancestor (x->menubar_widget, gwdesc))
3395 return 0;
3397 list = gtk_container_get_children (GTK_CONTAINER (x->menubar_widget));
3398 if (! list) return 0;
3399 rec.x = event->xbutton.x;
3400 rec.y = event->xbutton.y;
3401 rec.width = 1;
3402 rec.height = 1;
3404 for (iter = list ; iter; iter = g_list_next (iter))
3406 GtkWidget *w = GTK_WIDGET (iter->data);
3407 if (gtk_widget_get_mapped (w) && gtk_widget_intersect (w, &rec, NULL))
3408 break;
3410 g_list_free (list);
3411 return iter != 0;
3416 /***********************************************************************
3417 Scroll bar functions
3418 ***********************************************************************/
3421 /* Setting scroll bar values invokes the callback. Use this variable
3422 to indicate that callback should do nothing. */
3424 bool xg_ignore_gtk_scrollbar;
3426 /* Width and height of scroll bars for the current theme. */
3427 static int scroll_bar_width_for_theme;
3428 static int scroll_bar_height_for_theme;
3430 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3431 may be larger than 32 bits. Keep a mapping from integer index to widget
3432 pointers to get around the 32 bit limitation. */
3434 static struct
3436 GtkWidget **widgets;
3437 ptrdiff_t max_size;
3438 ptrdiff_t used;
3439 } id_to_widget;
3441 /* Grow this much every time we need to allocate more */
3443 #define ID_TO_WIDGET_INCR 32
3445 /* Store the widget pointer W in id_to_widget and return the integer index. */
3447 static ptrdiff_t
3448 xg_store_widget_in_map (GtkWidget *w)
3450 ptrdiff_t i;
3452 if (id_to_widget.max_size == id_to_widget.used)
3454 ptrdiff_t new_size;
3455 if (TYPE_MAXIMUM (Window) - ID_TO_WIDGET_INCR < id_to_widget.max_size)
3456 memory_full (SIZE_MAX);
3458 new_size = id_to_widget.max_size + ID_TO_WIDGET_INCR;
3459 id_to_widget.widgets = xnrealloc (id_to_widget.widgets,
3460 new_size, sizeof (GtkWidget *));
3462 for (i = id_to_widget.max_size; i < new_size; ++i)
3463 id_to_widget.widgets[i] = 0;
3464 id_to_widget.max_size = new_size;
3467 /* Just loop over the array and find a free place. After all,
3468 how many scroll bars are we creating? Should be a small number.
3469 The check above guarantees we will find a free place. */
3470 for (i = 0; i < id_to_widget.max_size; ++i)
3472 if (! id_to_widget.widgets[i])
3474 id_to_widget.widgets[i] = w;
3475 ++id_to_widget.used;
3477 return i;
3481 /* Should never end up here */
3482 emacs_abort ();
3485 /* Remove pointer at IDX from id_to_widget.
3486 Called when scroll bar is destroyed. */
3488 static void
3489 xg_remove_widget_from_map (ptrdiff_t idx)
3491 if (idx < id_to_widget.max_size && id_to_widget.widgets[idx] != 0)
3493 id_to_widget.widgets[idx] = 0;
3494 --id_to_widget.used;
3498 /* Get the widget pointer at IDX from id_to_widget. */
3500 static GtkWidget *
3501 xg_get_widget_from_map (ptrdiff_t idx)
3503 if (idx < id_to_widget.max_size && id_to_widget.widgets[idx] != 0)
3504 return id_to_widget.widgets[idx];
3506 return 0;
3509 static void
3510 update_theme_scrollbar_width (void)
3512 #ifdef HAVE_GTK3
3513 GtkAdjustment *vadj;
3514 #else
3515 GtkObject *vadj;
3516 #endif
3517 GtkWidget *wscroll;
3518 int w = 0, b = 0;
3520 vadj = gtk_adjustment_new (XG_SB_MIN, XG_SB_MIN, XG_SB_MAX, 0.1, 0.1, 0.1);
3521 wscroll = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (vadj));
3522 g_object_ref_sink (G_OBJECT (wscroll));
3523 gtk_widget_style_get (wscroll, "slider-width", &w, "trough-border", &b, NULL);
3524 gtk_widget_destroy (wscroll);
3525 g_object_unref (G_OBJECT (wscroll));
3526 w += 2*b;
3527 if (w < 16) w = 16;
3528 scroll_bar_width_for_theme = w;
3531 static void
3532 update_theme_scrollbar_height (void)
3534 #ifdef HAVE_GTK3
3535 GtkAdjustment *hadj;
3536 #else
3537 GtkObject *hadj;
3538 #endif
3539 GtkWidget *wscroll;
3540 int w = 0, b = 0;
3542 hadj = gtk_adjustment_new (YG_SB_MIN, YG_SB_MIN, YG_SB_MAX, 0.1, 0.1, 0.1);
3543 wscroll = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (hadj));
3544 g_object_ref_sink (G_OBJECT (wscroll));
3545 gtk_widget_style_get (wscroll, "slider-width", &w, "trough-border", &b, NULL);
3546 gtk_widget_destroy (wscroll);
3547 g_object_unref (G_OBJECT (wscroll));
3548 w += 2*b;
3549 if (w < 12) w = 12;
3550 scroll_bar_height_for_theme = w;
3554 xg_get_default_scrollbar_width (void)
3556 return scroll_bar_width_for_theme;
3560 xg_get_default_scrollbar_height (void)
3562 /* Apparently there's no default height for themes. */
3563 return scroll_bar_width_for_theme;
3566 /* Return the scrollbar id for X Window WID on display DPY.
3567 Return -1 if WID not in id_to_widget. */
3569 ptrdiff_t
3570 xg_get_scroll_id_for_window (Display *dpy, Window wid)
3572 ptrdiff_t idx;
3573 GtkWidget *w;
3575 w = xg_win_to_widget (dpy, wid);
3577 if (w)
3579 for (idx = 0; idx < id_to_widget.max_size; ++idx)
3580 if (id_to_widget.widgets[idx] == w)
3581 return idx;
3584 return -1;
3587 /* Callback invoked when scroll bar WIDGET is destroyed.
3588 DATA is the index into id_to_widget for WIDGET.
3589 We free pointer to last scroll bar values here and remove the index. */
3591 static void
3592 xg_gtk_scroll_destroy (GtkWidget *widget, gpointer data)
3594 intptr_t id = (intptr_t) data;
3595 xg_remove_widget_from_map (id);
3598 /* Create a scroll bar widget for frame F. Store the scroll bar
3599 in BAR.
3600 SCROLL_CALLBACK is the callback to invoke when the value of the
3601 bar changes.
3602 END_CALLBACK is the callback to invoke when scrolling ends.
3603 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3604 to set resources for the widget. */
3606 void
3607 xg_create_scroll_bar (struct frame *f,
3608 struct scroll_bar *bar,
3609 GCallback scroll_callback,
3610 GCallback end_callback,
3611 const char *scroll_bar_name)
3613 GtkWidget *wscroll;
3614 GtkWidget *webox;
3615 intptr_t scroll_id;
3616 #ifdef HAVE_GTK3
3617 GtkAdjustment *vadj;
3618 #else
3619 GtkObject *vadj;
3620 #endif
3622 /* Page, step increment values are not so important here, they
3623 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3624 vadj = gtk_adjustment_new (XG_SB_MIN, XG_SB_MIN, XG_SB_MAX,
3625 0.1, 0.1, 0.1);
3627 wscroll = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (vadj));
3628 webox = gtk_event_box_new ();
3629 gtk_widget_set_name (wscroll, scroll_bar_name);
3630 #ifndef HAVE_GTK3
3631 gtk_range_set_update_policy (GTK_RANGE (wscroll), GTK_UPDATE_CONTINUOUS);
3632 #endif
3633 g_object_set_data (G_OBJECT (wscroll), XG_FRAME_DATA, (gpointer)f);
3635 scroll_id = xg_store_widget_in_map (wscroll);
3637 g_signal_connect (G_OBJECT (wscroll),
3638 "destroy",
3639 G_CALLBACK (xg_gtk_scroll_destroy),
3640 (gpointer) scroll_id);
3641 g_signal_connect (G_OBJECT (wscroll),
3642 "change-value",
3643 scroll_callback,
3644 (gpointer) bar);
3645 g_signal_connect (G_OBJECT (wscroll),
3646 "button-release-event",
3647 end_callback,
3648 (gpointer) bar);
3650 /* The scroll bar widget does not draw on a window of its own. Instead
3651 it draws on the parent window, in this case the edit widget. So
3652 whenever the edit widget is cleared, the scroll bar needs to redraw
3653 also, which causes flicker. Put an event box between the edit widget
3654 and the scroll bar, so the scroll bar instead draws itself on the
3655 event box window. */
3656 gtk_fixed_put (GTK_FIXED (f->output_data.x->edit_widget), webox, -1, -1);
3657 gtk_container_add (GTK_CONTAINER (webox), wscroll);
3660 /* Set the cursor to an arrow. */
3661 xg_set_cursor (webox, FRAME_DISPLAY_INFO (f)->xg_cursor);
3663 bar->x_window = scroll_id;
3664 bar->horizontal = 0;
3667 /* Create a horizontal scroll bar widget for frame F. Store the scroll
3668 bar in BAR. SCROLL_CALLBACK is the callback to invoke when the value
3669 of the bar changes. END_CALLBACK is the callback to invoke when
3670 scrolling ends. SCROLL_BAR_NAME is the name we use for the scroll
3671 bar. Can be used to set resources for the widget. */
3673 void
3674 xg_create_horizontal_scroll_bar (struct frame *f,
3675 struct scroll_bar *bar,
3676 GCallback scroll_callback,
3677 GCallback end_callback,
3678 const char *scroll_bar_name)
3680 GtkWidget *wscroll;
3681 GtkWidget *webox;
3682 intptr_t scroll_id;
3683 #ifdef HAVE_GTK3
3684 GtkAdjustment *hadj;
3685 #else
3686 GtkObject *hadj;
3687 #endif
3689 /* Page, step increment values are not so important here, they
3690 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3691 hadj = gtk_adjustment_new (YG_SB_MIN, YG_SB_MIN, YG_SB_MAX,
3692 0.1, 0.1, 0.1);
3694 wscroll = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (hadj));
3695 webox = gtk_event_box_new ();
3696 gtk_widget_set_name (wscroll, scroll_bar_name);
3697 #ifndef HAVE_GTK3
3698 gtk_range_set_update_policy (GTK_RANGE (wscroll), GTK_UPDATE_CONTINUOUS);
3699 #endif
3700 g_object_set_data (G_OBJECT (wscroll), XG_FRAME_DATA, (gpointer)f);
3702 scroll_id = xg_store_widget_in_map (wscroll);
3704 g_signal_connect (G_OBJECT (wscroll),
3705 "destroy",
3706 G_CALLBACK (xg_gtk_scroll_destroy),
3707 (gpointer) scroll_id);
3708 g_signal_connect (G_OBJECT (wscroll),
3709 "change-value",
3710 scroll_callback,
3711 (gpointer) bar);
3712 g_signal_connect (G_OBJECT (wscroll),
3713 "button-release-event",
3714 end_callback,
3715 (gpointer) bar);
3717 /* The scroll bar widget does not draw on a window of its own. Instead
3718 it draws on the parent window, in this case the edit widget. So
3719 whenever the edit widget is cleared, the scroll bar needs to redraw
3720 also, which causes flicker. Put an event box between the edit widget
3721 and the scroll bar, so the scroll bar instead draws itself on the
3722 event box window. */
3723 gtk_fixed_put (GTK_FIXED (f->output_data.x->edit_widget), webox, -1, -1);
3724 gtk_container_add (GTK_CONTAINER (webox), wscroll);
3727 /* Set the cursor to an arrow. */
3728 xg_set_cursor (webox, FRAME_DISPLAY_INFO (f)->xg_cursor);
3730 bar->x_window = scroll_id;
3731 bar->horizontal = 1;
3734 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3736 void
3737 xg_remove_scroll_bar (struct frame *f, ptrdiff_t scrollbar_id)
3739 GtkWidget *w = xg_get_widget_from_map (scrollbar_id);
3740 if (w)
3742 GtkWidget *wparent = gtk_widget_get_parent (w);
3743 gtk_widget_destroy (w);
3744 gtk_widget_destroy (wparent);
3745 SET_FRAME_GARBAGED (f);
3749 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3750 in frame F.
3751 TOP/LEFT are the new pixel positions where the bar shall appear.
3752 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3754 void
3755 xg_update_scrollbar_pos (struct frame *f,
3756 ptrdiff_t scrollbar_id,
3757 int top,
3758 int left,
3759 int width,
3760 int height)
3763 GtkWidget *wscroll = xg_get_widget_from_map (scrollbar_id);
3765 if (wscroll)
3767 GtkWidget *wfixed = f->output_data.x->edit_widget;
3768 GtkWidget *wparent = gtk_widget_get_parent (wscroll);
3769 gint msl;
3771 /* Clear out old position. */
3772 int oldx = -1, oldy = -1, oldw, oldh;
3773 if (gtk_widget_get_parent (wparent) == wfixed)
3775 gtk_container_child_get (GTK_CONTAINER (wfixed), wparent,
3776 "x", &oldx, "y", &oldy, NULL);
3777 gtk_widget_get_size_request (wscroll, &oldw, &oldh);
3780 /* Move and resize to new values. */
3781 gtk_fixed_move (GTK_FIXED (wfixed), wparent, left, top);
3782 gtk_widget_style_get (wscroll, "min-slider-length", &msl, NULL);
3783 if (msl > height)
3785 /* No room. Hide scroll bar as some themes output a warning if
3786 the height is less than the min size. */
3787 gtk_widget_hide (wparent);
3788 gtk_widget_hide (wscroll);
3790 else
3792 gtk_widget_show_all (wparent);
3793 gtk_widget_set_size_request (wscroll, width, height);
3795 gtk_widget_queue_draw (wfixed);
3796 gdk_window_process_all_updates ();
3797 if (oldx != -1 && oldw > 0 && oldh > 0)
3798 /* Clear under old scroll bar position. This must be done after
3799 the gtk_widget_queue_draw and gdk_window_process_all_updates
3800 above. */
3801 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3802 oldx, oldy, oldw, oldh);
3804 /* GTK does not redraw until the main loop is entered again, but
3805 if there are no X events pending we will not enter it. So we sync
3806 here to get some events. */
3808 x_sync (f);
3809 SET_FRAME_GARBAGED (f);
3810 cancel_mouse_face (f);
3815 /* Update the position of the horizontal scroll bar represented by SCROLLBAR_ID
3816 in frame F.
3817 TOP/LEFT are the new pixel positions where the bar shall appear.
3818 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3820 void
3821 xg_update_horizontal_scrollbar_pos (struct frame *f,
3822 ptrdiff_t scrollbar_id,
3823 int top,
3824 int left,
3825 int width,
3826 int height)
3829 GtkWidget *wscroll = xg_get_widget_from_map (scrollbar_id);
3831 if (wscroll)
3833 GtkWidget *wfixed = f->output_data.x->edit_widget;
3834 GtkWidget *wparent = gtk_widget_get_parent (wscroll);
3835 gint msl;
3837 /* Clear out old position. */
3838 int oldx = -1, oldy = -1, oldw, oldh;
3839 if (gtk_widget_get_parent (wparent) == wfixed)
3841 gtk_container_child_get (GTK_CONTAINER (wfixed), wparent,
3842 "x", &oldx, "y", &oldy, NULL);
3843 gtk_widget_get_size_request (wscroll, &oldw, &oldh);
3846 /* Move and resize to new values. */
3847 gtk_fixed_move (GTK_FIXED (wfixed), wparent, left, top);
3848 gtk_widget_style_get (wscroll, "min-slider-length", &msl, NULL);
3849 if (msl > width)
3851 /* No room. Hide scroll bar as some themes output a warning if
3852 the width is less than the min size. */
3853 gtk_widget_hide (wparent);
3854 gtk_widget_hide (wscroll);
3856 else
3858 gtk_widget_show_all (wparent);
3859 gtk_widget_set_size_request (wscroll, width, height);
3861 gtk_widget_queue_draw (wfixed);
3862 gdk_window_process_all_updates ();
3863 if (oldx != -1 && oldw > 0 && oldh > 0)
3864 /* Clear under old scroll bar position. This must be done after
3865 the gtk_widget_queue_draw and gdk_window_process_all_updates
3866 above. */
3867 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3868 oldx, oldy, oldw, oldh);
3870 /* GTK does not redraw until the main loop is entered again, but
3871 if there are no X events pending we will not enter it. So we sync
3872 here to get some events. */
3874 x_sync (f);
3875 SET_FRAME_GARBAGED (f);
3876 cancel_mouse_face (f);
3881 /* Get the current value of the range, truncated to an integer. */
3883 static int
3884 int_gtk_range_get_value (GtkRange *range)
3886 return gtk_range_get_value (range);
3890 /* Set the thumb size and position of scroll bar BAR. We are currently
3891 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3893 void
3894 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar,
3895 int portion,
3896 int position,
3897 int whole)
3899 GtkWidget *wscroll = xg_get_widget_from_map (bar->x_window);
3901 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3903 if (wscroll && bar->dragging == -1)
3905 GtkAdjustment *adj;
3906 gdouble shown;
3907 gdouble top;
3908 int size, value;
3909 int old_size;
3910 int new_step;
3911 bool changed = 0;
3913 adj = gtk_range_get_adjustment (GTK_RANGE (wscroll));
3915 if (scroll_bar_adjust_thumb_portion_p)
3917 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3918 line rather than the real portion value. This makes the
3919 thumb less likely to resize and that looks better. */
3920 portion = WINDOW_TOTAL_LINES (XWINDOW (bar->window)) * 30;
3922 /* When the thumb is at the bottom, position == whole.
3923 So we need to increase `whole' to make space for the thumb. */
3924 whole += portion;
3927 if (whole <= 0)
3928 top = 0, shown = 1;
3929 else
3931 top = (gdouble) position / whole;
3932 shown = (gdouble) portion / whole;
3935 size = clip_to_bounds (1, shown * XG_SB_RANGE, XG_SB_RANGE);
3936 value = clip_to_bounds (XG_SB_MIN, top * XG_SB_RANGE, XG_SB_MAX - size);
3938 /* Assume all lines are of equal size. */
3939 new_step = size / max (1, FRAME_LINES (f));
3941 old_size = gtk_adjustment_get_page_size (adj);
3942 if (old_size != size)
3944 int old_step = gtk_adjustment_get_step_increment (adj);
3945 if (old_step != new_step)
3947 gtk_adjustment_set_page_size (adj, size);
3948 gtk_adjustment_set_step_increment (adj, new_step);
3949 /* Assume a page increment is about 95% of the page size */
3950 gtk_adjustment_set_page_increment (adj, size - size / 20);
3951 changed = 1;
3955 if (changed || int_gtk_range_get_value (GTK_RANGE (wscroll)) != value)
3957 block_input ();
3959 /* gtk_range_set_value invokes the callback. Set
3960 ignore_gtk_scrollbar to make the callback do nothing */
3961 xg_ignore_gtk_scrollbar = 1;
3963 if (int_gtk_range_get_value (GTK_RANGE (wscroll)) != value)
3964 gtk_range_set_value (GTK_RANGE (wscroll), (gdouble)value);
3965 else if (changed)
3966 gtk_adjustment_changed (adj);
3968 xg_ignore_gtk_scrollbar = 0;
3970 unblock_input ();
3975 /* Set the thumb size and position of horizontal scroll bar BAR. We are
3976 currently displaying PORTION out of a whole WHOLE, and our position
3977 POSITION. */
3978 void
3979 xg_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar *bar,
3980 int portion,
3981 int position,
3982 int whole)
3984 GtkWidget *wscroll = xg_get_widget_from_map (bar->x_window);
3986 if (wscroll && bar->dragging == -1)
3988 GtkAdjustment *adj;
3989 int lower = 0;
3990 int upper = max (whole - 1, 0);
3991 int pagesize = min (upper, max (portion, 0));
3992 int value = max (0, min (position, upper - pagesize));
3993 /* These should be set to something more <portion, whole>
3994 related. */
3995 int page_increment = 4;
3996 int step_increment = 1;
3998 block_input ();
3999 adj = gtk_range_get_adjustment (GTK_RANGE (wscroll));
4001 /* gtk_adjustment_set_lower (adj, (gdouble) lower);
4002 gtk_adjustment_set_upper (adj, (gdouble) upper);
4003 gtk_adjustment_set_page_size (adj, (gdouble) pagesize);
4004 gtk_adjustment_set_value (adj, (gdouble) value);
4005 gtk_adjustment_set_page_increment (adj, (gdouble) page_increment);
4006 gtk_adjustment_set_step_increment (adj, (gdouble)
4007 step_increment); */
4008 gtk_adjustment_configure (adj, (gdouble) value, (gdouble) lower,
4009 (gdouble) upper, (gdouble) step_increment,
4010 (gdouble) page_increment, (gdouble) pagesize);
4011 gtk_adjustment_changed (adj);
4012 unblock_input ();
4016 /* Return true if EVENT is for a scroll bar in frame F.
4017 When the same X window is used for several Gtk+ widgets, we cannot
4018 say for sure based on the X window alone if an event is for the
4019 frame. This function does additional checks. */
4021 bool
4022 xg_event_is_for_scrollbar (struct frame *f, const XEvent *event)
4024 bool retval = 0;
4026 if (f && event->type == ButtonPress && event->xbutton.button < 4)
4028 /* Check if press occurred outside the edit widget. */
4029 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
4030 GdkWindow *gwin;
4031 #ifdef HAVE_GTK3
4032 GdkDevice *gdev = gdk_device_manager_get_client_pointer
4033 (gdk_display_get_device_manager (gdpy));
4034 gwin = gdk_device_get_window_at_position (gdev, NULL, NULL);
4035 #else
4036 gwin = gdk_display_get_window_at_pointer (gdpy, NULL, NULL);
4037 #endif
4038 retval = gwin != gtk_widget_get_window (f->output_data.x->edit_widget);
4040 else if (f
4041 && ((event->type == ButtonRelease && event->xbutton.button < 4)
4042 || event->type == MotionNotify))
4044 /* If we are releasing or moving the scroll bar, it has the grab. */
4045 GtkWidget *w = gtk_grab_get_current ();
4046 retval = w != 0 && GTK_IS_SCROLLBAR (w);
4049 return retval;
4054 /***********************************************************************
4055 Tool bar functions
4056 ***********************************************************************/
4057 /* The key for the data we put in the GtkImage widgets. The data is
4058 the image used by Emacs. We use this to see if we need to update
4059 the GtkImage with a new image. */
4060 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
4062 /* The key for storing the latest modifiers so the activate callback can
4063 get them. */
4064 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
4066 /* The key for storing the button widget in its proxy menu item. */
4067 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
4069 /* The key for the data we put in the GtkImage widgets. The data is
4070 the stock name used by Emacs. We use this to see if we need to update
4071 the GtkImage with a new image. */
4072 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
4074 /* As above, but this is used for named theme widgets, as opposed to
4075 stock items. */
4076 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
4078 /* Callback function invoked when a tool bar item is pressed.
4079 W is the button widget in the tool bar that got pressed,
4080 CLIENT_DATA is an integer that is the index of the button in the
4081 tool bar. 0 is the first button. */
4083 static gboolean
4084 xg_tool_bar_button_cb (GtkWidget *widget,
4085 GdkEventButton *event,
4086 gpointer user_data)
4088 intptr_t state = event->state;
4089 gpointer ptr = (gpointer) state;
4090 g_object_set_data (G_OBJECT (widget), XG_TOOL_BAR_LAST_MODIFIER, ptr);
4091 return FALSE;
4095 /* Callback function invoked when a tool bar item is pressed.
4096 W is the button widget in the tool bar that got pressed,
4097 CLIENT_DATA is an integer that is the index of the button in the
4098 tool bar. 0 is the first button. */
4100 static void
4101 xg_tool_bar_callback (GtkWidget *w, gpointer client_data)
4103 intptr_t idx = (intptr_t) client_data;
4104 gpointer gmod = g_object_get_data (G_OBJECT (w), XG_TOOL_BAR_LAST_MODIFIER);
4105 intptr_t mod = (intptr_t) gmod;
4107 struct frame *f = g_object_get_data (G_OBJECT (w), XG_FRAME_DATA);
4108 Lisp_Object key, frame;
4109 struct input_event event;
4110 EVENT_INIT (event);
4112 if (! f || ! f->n_tool_bar_items || NILP (f->tool_bar_items))
4113 return;
4115 idx *= TOOL_BAR_ITEM_NSLOTS;
4117 key = AREF (f->tool_bar_items, idx + TOOL_BAR_ITEM_KEY);
4118 XSETFRAME (frame, f);
4120 /* We generate two events here. The first one is to set the prefix
4121 to `(tool_bar)', see keyboard.c. */
4122 event.kind = TOOL_BAR_EVENT;
4123 event.frame_or_window = frame;
4124 event.arg = frame;
4125 kbd_buffer_store_event (&event);
4127 event.kind = TOOL_BAR_EVENT;
4128 event.frame_or_window = frame;
4129 event.arg = key;
4130 /* Convert between the modifier bits GDK uses and the modifier bits
4131 Emacs uses. This assumes GDK and X masks are the same, which they are when
4132 this is written. */
4133 event.modifiers = x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f), mod);
4134 kbd_buffer_store_event (&event);
4136 /* Return focus to the frame after we have clicked on a detached
4137 tool bar button. */
4138 x_focus_frame (f);
4141 /* Callback function invoked when a tool bar item is pressed in a detached
4142 tool bar or the overflow drop down menu.
4143 We just call xg_tool_bar_callback.
4144 W is the menu item widget that got pressed,
4145 CLIENT_DATA is an integer that is the index of the button in the
4146 tool bar. 0 is the first button. */
4148 static void
4149 xg_tool_bar_proxy_callback (GtkWidget *w, gpointer client_data)
4151 GtkWidget *wbutton = GTK_WIDGET (g_object_get_data (G_OBJECT (w),
4152 XG_TOOL_BAR_PROXY_BUTTON));
4153 xg_tool_bar_callback (wbutton, client_data);
4157 static gboolean
4158 xg_tool_bar_help_callback (GtkWidget *w,
4159 GdkEventCrossing *event,
4160 gpointer client_data);
4162 /* This callback is called when a help is to be shown for an item in
4163 the detached tool bar when the detached tool bar it is not expanded. */
4165 static gboolean
4166 xg_tool_bar_proxy_help_callback (GtkWidget *w,
4167 GdkEventCrossing *event,
4168 gpointer client_data)
4170 GtkWidget *wbutton = GTK_WIDGET (g_object_get_data (G_OBJECT (w),
4171 XG_TOOL_BAR_PROXY_BUTTON));
4173 return xg_tool_bar_help_callback (wbutton, event, client_data);
4176 static GtkWidget *
4177 xg_get_tool_bar_widgets (GtkWidget *vb, GtkWidget **wimage)
4179 GList *clist = gtk_container_get_children (GTK_CONTAINER (vb));
4180 GtkWidget *c1 = clist->data;
4181 GtkWidget *c2 = clist->next ? clist->next->data : NULL;
4183 *wimage = GTK_IS_IMAGE (c1) ? c1 : c2;
4184 g_list_free (clist);
4185 return GTK_IS_LABEL (c1) ? c1 : c2;
4189 /* This callback is called when a tool item should create a proxy item,
4190 such as for the overflow menu. Also called when the tool bar is detached.
4191 If we don't create a proxy menu item, the detached tool bar will be
4192 blank. */
4194 static gboolean
4195 xg_tool_bar_menu_proxy (GtkToolItem *toolitem, gpointer user_data)
4197 GtkButton *wbutton = GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem)));
4198 GtkWidget *vb = XG_BIN_CHILD (wbutton);
4199 GtkWidget *c1;
4200 GtkLabel *wlbl = GTK_LABEL (xg_get_tool_bar_widgets (vb, &c1));
4201 GtkImage *wimage = GTK_IMAGE (c1);
4202 GtkWidget *wmenuitem = gtk_image_menu_item_new_with_label
4203 (wlbl ? gtk_label_get_text (wlbl) : "");
4204 GtkWidget *wmenuimage;
4207 if (gtk_button_get_use_stock (wbutton))
4208 wmenuimage = gtk_image_new_from_stock (gtk_button_get_label (wbutton),
4209 GTK_ICON_SIZE_MENU);
4210 else
4212 GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (wbutton));
4213 GtkImageType store_type = gtk_image_get_storage_type (wimage);
4215 g_object_set (G_OBJECT (settings), "gtk-menu-images", TRUE, NULL);
4217 if (store_type == GTK_IMAGE_STOCK)
4219 gchar *stock_id;
4220 gtk_image_get_stock (wimage, &stock_id, NULL);
4221 wmenuimage = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);
4223 else if (store_type == GTK_IMAGE_ICON_SET)
4225 GtkIconSet *icon_set;
4226 gtk_image_get_icon_set (wimage, &icon_set, NULL);
4227 wmenuimage = gtk_image_new_from_icon_set (icon_set,
4228 GTK_ICON_SIZE_MENU);
4230 else if (store_type == GTK_IMAGE_PIXBUF)
4232 gint width, height;
4234 if (settings &&
4235 gtk_icon_size_lookup_for_settings (settings, GTK_ICON_SIZE_MENU,
4236 &width, &height))
4238 GdkPixbuf *src_pixbuf, *dest_pixbuf;
4240 src_pixbuf = gtk_image_get_pixbuf (wimage);
4241 dest_pixbuf = gdk_pixbuf_scale_simple (src_pixbuf, width, height,
4242 GDK_INTERP_BILINEAR);
4244 wmenuimage = gtk_image_new_from_pixbuf (dest_pixbuf);
4246 else
4248 fprintf (stderr, "internal error: GTK_IMAGE_PIXBUF failed\n");
4249 emacs_abort ();
4252 else if (store_type == GTK_IMAGE_ICON_NAME)
4254 const gchar *icon_name;
4255 GtkIconSize icon_size;
4257 gtk_image_get_icon_name (wimage, &icon_name, &icon_size);
4258 wmenuimage = gtk_image_new_from_icon_name (icon_name,
4259 GTK_ICON_SIZE_MENU);
4261 else
4263 fprintf (stderr, "internal error: store_type is %d\n", store_type);
4264 emacs_abort ();
4267 if (wmenuimage)
4268 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem), wmenuimage);
4270 g_signal_connect (G_OBJECT (wmenuitem),
4271 "activate",
4272 G_CALLBACK (xg_tool_bar_proxy_callback),
4273 user_data);
4276 g_object_set_data (G_OBJECT (wmenuitem), XG_TOOL_BAR_PROXY_BUTTON,
4277 (gpointer) wbutton);
4278 gtk_tool_item_set_proxy_menu_item (toolitem, "Emacs toolbar item", wmenuitem);
4279 gtk_widget_set_sensitive (wmenuitem,
4280 gtk_widget_get_sensitive (GTK_WIDGET (wbutton)));
4282 /* Use enter/leave notify to show help. We use the events
4283 rather than the GtkButton specific signals "enter" and
4284 "leave", so we can have only one callback. The event
4285 will tell us what kind of event it is. */
4286 g_signal_connect (G_OBJECT (wmenuitem),
4287 "enter-notify-event",
4288 G_CALLBACK (xg_tool_bar_proxy_help_callback),
4289 user_data);
4290 g_signal_connect (G_OBJECT (wmenuitem),
4291 "leave-notify-event",
4292 G_CALLBACK (xg_tool_bar_proxy_help_callback),
4293 user_data);
4295 return TRUE;
4298 /* This callback is called when a tool bar is detached. We must set
4299 the height of the tool bar to zero when this happens so frame sizes
4300 are correctly calculated.
4301 WBOX is the handle box widget that enables detach/attach of the tool bar.
4302 W is the tool bar widget.
4303 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4305 static void
4306 xg_tool_bar_detach_callback (GtkHandleBox *wbox,
4307 GtkWidget *w,
4308 gpointer client_data)
4310 struct frame *f = client_data;
4312 g_object_set (G_OBJECT (w), "show-arrow", !x_gtk_whole_detached_tool_bar,
4313 NULL);
4315 if (f)
4317 GtkRequisition req, req2;
4319 gtk_widget_get_preferred_size (GTK_WIDGET (wbox), NULL, &req);
4320 gtk_widget_get_preferred_size (w, NULL, &req2);
4321 req.width -= req2.width;
4322 req.height -= req2.height;
4323 if (FRAME_TOOLBAR_TOP_HEIGHT (f) != 0)
4324 FRAME_TOOLBAR_TOP_HEIGHT (f) = req.height;
4325 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f) != 0)
4326 FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = req.height;
4327 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f) != 0)
4328 FRAME_TOOLBAR_RIGHT_WIDTH (f) = req.width;
4329 else if (FRAME_TOOLBAR_LEFT_WIDTH (f) != 0)
4330 FRAME_TOOLBAR_LEFT_WIDTH (f) = req.width;
4331 xg_height_or_width_changed (f);
4335 /* This callback is called when a tool bar is reattached. We must set
4336 the height of the tool bar when this happens so frame sizes
4337 are correctly calculated.
4338 WBOX is the handle box widget that enables detach/attach of the tool bar.
4339 W is the tool bar widget.
4340 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4342 static void
4343 xg_tool_bar_attach_callback (GtkHandleBox *wbox,
4344 GtkWidget *w,
4345 gpointer client_data)
4347 struct frame *f = client_data;
4348 g_object_set (G_OBJECT (w), "show-arrow", TRUE, NULL);
4350 if (f)
4352 GtkRequisition req, req2;
4354 gtk_widget_get_preferred_size (GTK_WIDGET (wbox), NULL, &req);
4355 gtk_widget_get_preferred_size (w, NULL, &req2);
4356 req.width += req2.width;
4357 req.height += req2.height;
4358 if (FRAME_TOOLBAR_TOP_HEIGHT (f) != 0)
4359 FRAME_TOOLBAR_TOP_HEIGHT (f) = req.height;
4360 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f) != 0)
4361 FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = req.height;
4362 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f) != 0)
4363 FRAME_TOOLBAR_RIGHT_WIDTH (f) = req.width;
4364 else if (FRAME_TOOLBAR_LEFT_WIDTH (f) != 0)
4365 FRAME_TOOLBAR_LEFT_WIDTH (f) = req.width;
4366 xg_height_or_width_changed (f);
4370 /* This callback is called when the mouse enters or leaves a tool bar item.
4371 It is used for displaying and hiding the help text.
4372 W is the tool bar item, a button.
4373 EVENT is either an enter event or leave event.
4374 CLIENT_DATA is an integer that is the index of the button in the
4375 tool bar. 0 is the first button.
4377 Returns FALSE to tell GTK to keep processing this event. */
4379 static gboolean
4380 xg_tool_bar_help_callback (GtkWidget *w,
4381 GdkEventCrossing *event,
4382 gpointer client_data)
4384 intptr_t idx = (intptr_t) client_data;
4385 struct frame *f = g_object_get_data (G_OBJECT (w), XG_FRAME_DATA);
4386 Lisp_Object help, frame;
4388 if (! f || ! f->n_tool_bar_items || NILP (f->tool_bar_items))
4389 return FALSE;
4391 if (event->type == GDK_ENTER_NOTIFY)
4393 idx *= TOOL_BAR_ITEM_NSLOTS;
4394 help = AREF (f->tool_bar_items, idx + TOOL_BAR_ITEM_HELP);
4396 if (NILP (help))
4397 help = AREF (f->tool_bar_items, idx + TOOL_BAR_ITEM_CAPTION);
4399 else
4400 help = Qnil;
4402 XSETFRAME (frame, f);
4403 kbd_buffer_store_help_event (frame, help);
4405 return FALSE;
4409 /* This callback is called when a tool bar item shall be redrawn.
4410 It modifies the expose event so that the GtkImage widget redraws the
4411 whole image. This to overcome a bug that makes GtkImage draw the image
4412 in the wrong place when it tries to redraw just a part of the image.
4413 W is the GtkImage to be redrawn.
4414 EVENT is the expose event for W.
4415 CLIENT_DATA is unused.
4417 Returns FALSE to tell GTK to keep processing this event. */
4419 #ifndef HAVE_GTK3
4420 static gboolean
4421 xg_tool_bar_item_expose_callback (GtkWidget *w,
4422 GdkEventExpose *event,
4423 gpointer client_data)
4425 gint width, height;
4427 gdk_drawable_get_size (event->window, &width, &height);
4428 event->area.x -= width > event->area.width ? width-event->area.width : 0;
4429 event->area.y -= height > event->area.height ? height-event->area.height : 0;
4431 event->area.x = max (0, event->area.x);
4432 event->area.y = max (0, event->area.y);
4434 event->area.width = max (width, event->area.width);
4435 event->area.height = max (height, event->area.height);
4437 return FALSE;
4439 #endif
4441 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4442 #define toolbar_set_orientation(w, o) \
4443 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4444 #else
4445 #define toolbar_set_orientation(w, o) \
4446 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4447 #endif
4449 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4450 #define TOOLBAR_TOP_WIDGET(x) ((x)->handlebox_widget)
4451 #else
4452 #define TOOLBAR_TOP_WIDGET(x) ((x)->toolbar_widget)
4453 #endif
4455 /* Attach a tool bar to frame F. */
4457 static void
4458 xg_pack_tool_bar (struct frame *f, Lisp_Object pos)
4460 struct x_output *x = f->output_data.x;
4461 bool into_hbox = EQ (pos, Qleft) || EQ (pos, Qright);
4462 GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
4464 toolbar_set_orientation (x->toolbar_widget,
4465 into_hbox
4466 ? GTK_ORIENTATION_VERTICAL
4467 : GTK_ORIENTATION_HORIZONTAL);
4468 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4469 if (!x->handlebox_widget)
4471 top_widget = x->handlebox_widget = gtk_handle_box_new ();
4472 g_signal_connect (G_OBJECT (x->handlebox_widget), "child-detached",
4473 G_CALLBACK (xg_tool_bar_detach_callback), f);
4474 g_signal_connect (G_OBJECT (x->handlebox_widget), "child-attached",
4475 G_CALLBACK (xg_tool_bar_attach_callback), f);
4476 gtk_container_add (GTK_CONTAINER (x->handlebox_widget),
4477 x->toolbar_widget);
4479 #endif
4481 if (into_hbox)
4483 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4484 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x->handlebox_widget),
4485 GTK_POS_TOP);
4486 #endif
4487 gtk_box_pack_start (GTK_BOX (x->hbox_widget), top_widget,
4488 FALSE, FALSE, 0);
4490 if (EQ (pos, Qleft))
4491 gtk_box_reorder_child (GTK_BOX (x->hbox_widget),
4492 top_widget,
4494 x->toolbar_in_hbox = true;
4496 else
4498 bool vbox_pos = x->menubar_widget != 0;
4499 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4500 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x->handlebox_widget),
4501 GTK_POS_LEFT);
4502 #endif
4503 gtk_box_pack_start (GTK_BOX (x->vbox_widget), top_widget,
4504 FALSE, FALSE, 0);
4506 if (EQ (pos, Qtop))
4507 gtk_box_reorder_child (GTK_BOX (x->vbox_widget),
4508 top_widget,
4509 vbox_pos);
4510 x->toolbar_in_hbox = false;
4512 x->toolbar_is_packed = true;
4515 static bool xg_update_tool_bar_sizes (struct frame *f);
4517 static void
4518 tb_size_cb (GtkWidget *widget,
4519 GdkRectangle *allocation,
4520 gpointer user_data)
4522 /* When tool bar is created it has one preferred size. But when size is
4523 allocated between widgets, it may get another. So we must update
4524 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4525 struct frame *f = user_data;
4526 if (xg_update_tool_bar_sizes (f))
4527 xg_height_or_width_changed (f);
4530 /* Create a tool bar for frame F. */
4532 static void
4533 xg_create_tool_bar (struct frame *f)
4535 struct x_output *x = f->output_data.x;
4536 #if GTK_CHECK_VERSION (3, 3, 6)
4537 GtkStyleContext *gsty;
4538 #endif
4539 struct xg_frame_tb_info *tbinfo
4540 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
4541 TB_INFO_KEY);
4542 if (! tbinfo)
4544 tbinfo = xmalloc (sizeof (*tbinfo));
4545 tbinfo->last_tool_bar = Qnil;
4546 tbinfo->style = Qnil;
4547 tbinfo->hmargin = tbinfo->vmargin = 0;
4548 tbinfo->dir = GTK_TEXT_DIR_NONE;
4549 tbinfo->n_last_items = 0;
4550 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
4551 TB_INFO_KEY,
4552 tbinfo);
4555 x->toolbar_widget = gtk_toolbar_new ();
4557 gtk_widget_set_name (x->toolbar_widget, "emacs-toolbar");
4559 gtk_toolbar_set_style (GTK_TOOLBAR (x->toolbar_widget), GTK_TOOLBAR_ICONS);
4560 toolbar_set_orientation (x->toolbar_widget, GTK_ORIENTATION_HORIZONTAL);
4561 g_signal_connect (x->toolbar_widget, "size-allocate",
4562 G_CALLBACK (tb_size_cb), f);
4563 #if GTK_CHECK_VERSION (3, 3, 6)
4564 gsty = gtk_widget_get_style_context (x->toolbar_widget);
4565 gtk_style_context_add_class (gsty, "primary-toolbar");
4566 #endif
4570 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4572 /* Find the right-to-left image named by RTL in the tool bar images for F.
4573 Returns IMAGE if RTL is not found. */
4575 static Lisp_Object
4576 find_rtl_image (struct frame *f, Lisp_Object image, Lisp_Object rtl)
4578 int i;
4579 Lisp_Object file, rtl_name;
4580 struct gcpro gcpro1, gcpro2;
4581 GCPRO2 (file, rtl_name);
4583 rtl_name = Ffile_name_nondirectory (rtl);
4585 for (i = 0; i < f->n_tool_bar_items; ++i)
4587 Lisp_Object rtl_image = PROP (TOOL_BAR_ITEM_IMAGES);
4588 if (!NILP (file = file_for_image (rtl_image)))
4590 file = call1 (intern ("file-name-sans-extension"),
4591 Ffile_name_nondirectory (file));
4592 if (! NILP (Fequal (file, rtl_name)))
4594 image = rtl_image;
4595 break;
4600 return image;
4603 static GtkToolItem *
4604 xg_make_tool_item (struct frame *f,
4605 GtkWidget *wimage,
4606 GtkWidget **wbutton,
4607 const char *label,
4608 int i, bool horiz, bool text_image)
4610 GtkToolItem *ti = gtk_tool_item_new ();
4611 GtkWidget *vb = gtk_box_new (horiz
4612 ? GTK_ORIENTATION_HORIZONTAL
4613 : GTK_ORIENTATION_VERTICAL,
4615 GtkWidget *wb = gtk_button_new ();
4616 /* The eventbox is here so we can have tooltips on disabled items. */
4617 GtkWidget *weventbox = gtk_event_box_new ();
4618 #if GTK_CHECK_VERSION (3, 3, 6)
4619 GtkCssProvider *css_prov = gtk_css_provider_new ();
4620 GtkStyleContext *gsty;
4622 gtk_css_provider_load_from_data (css_prov,
4623 "GtkEventBox {"
4624 " background-color: transparent;"
4625 "}",
4626 -1, NULL);
4628 gsty = gtk_widget_get_style_context (weventbox);
4629 gtk_style_context_add_provider (gsty,
4630 GTK_STYLE_PROVIDER (css_prov),
4631 GTK_STYLE_PROVIDER_PRIORITY_USER);
4632 g_object_unref (css_prov);
4633 #endif
4635 gtk_box_set_homogeneous (GTK_BOX (vb), FALSE);
4637 if (wimage && !text_image)
4638 gtk_box_pack_start (GTK_BOX (vb), wimage, TRUE, TRUE, 0);
4639 if (label)
4640 gtk_box_pack_start (GTK_BOX (vb), gtk_label_new (label), TRUE, TRUE, 0);
4641 if (wimage && text_image)
4642 gtk_box_pack_start (GTK_BOX (vb), wimage, TRUE, TRUE, 0);
4644 gtk_button_set_focus_on_click (GTK_BUTTON (wb), FALSE);
4645 gtk_button_set_relief (GTK_BUTTON (wb), GTK_RELIEF_NONE);
4646 gtk_container_add (GTK_CONTAINER (wb), vb);
4647 gtk_container_add (GTK_CONTAINER (weventbox), wb);
4648 gtk_container_add (GTK_CONTAINER (ti), weventbox);
4650 if (wimage || label)
4652 intptr_t ii = i;
4653 gpointer gi = (gpointer) ii;
4655 g_signal_connect (G_OBJECT (ti), "create-menu-proxy",
4656 G_CALLBACK (xg_tool_bar_menu_proxy),
4657 gi);
4659 g_signal_connect (G_OBJECT (wb), "clicked",
4660 G_CALLBACK (xg_tool_bar_callback),
4661 gi);
4663 g_object_set_data (G_OBJECT (weventbox), XG_FRAME_DATA, (gpointer)f);
4665 #ifndef HAVE_GTK3
4666 /* Catch expose events to overcome an annoying redraw bug, see
4667 comment for xg_tool_bar_item_expose_callback. */
4668 g_signal_connect (G_OBJECT (ti),
4669 "expose-event",
4670 G_CALLBACK (xg_tool_bar_item_expose_callback),
4672 #endif
4673 gtk_tool_item_set_homogeneous (ti, FALSE);
4675 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4676 no distinction based on modifiers in the activate callback,
4677 so we have to do it ourselves. */
4678 g_signal_connect (wb, "button-release-event",
4679 G_CALLBACK (xg_tool_bar_button_cb),
4680 NULL);
4682 g_object_set_data (G_OBJECT (wb), XG_FRAME_DATA, (gpointer)f);
4684 /* Use enter/leave notify to show help. We use the events
4685 rather than the GtkButton specific signals "enter" and
4686 "leave", so we can have only one callback. The event
4687 will tell us what kind of event it is. */
4688 g_signal_connect (G_OBJECT (weventbox),
4689 "enter-notify-event",
4690 G_CALLBACK (xg_tool_bar_help_callback),
4691 gi);
4692 g_signal_connect (G_OBJECT (weventbox),
4693 "leave-notify-event",
4694 G_CALLBACK (xg_tool_bar_help_callback),
4695 gi);
4698 if (wbutton) *wbutton = wb;
4700 return ti;
4703 static bool
4704 is_box_type (GtkWidget *vb, bool is_horizontal)
4706 #ifdef HAVE_GTK3
4707 bool ret = 0;
4708 if (GTK_IS_BOX (vb))
4710 GtkOrientation ori = gtk_orientable_get_orientation (GTK_ORIENTABLE (vb));
4711 ret = (ori == GTK_ORIENTATION_HORIZONTAL && is_horizontal)
4712 || (ori == GTK_ORIENTATION_VERTICAL && ! is_horizontal);
4714 return ret;
4715 #else
4716 return is_horizontal ? GTK_IS_VBOX (vb) : GTK_IS_HBOX (vb);
4717 #endif
4721 static bool
4722 xg_tool_item_stale_p (GtkWidget *wbutton, const char *stock_name,
4723 const char *icon_name, const struct image *img,
4724 const char *label, bool horiz)
4726 gpointer old;
4727 GtkWidget *wimage;
4728 GtkWidget *vb = XG_BIN_CHILD (wbutton);
4729 GtkWidget *wlbl = xg_get_tool_bar_widgets (vb, &wimage);
4731 /* Check if the tool icon matches. */
4732 if (stock_name && wimage)
4734 old = g_object_get_data (G_OBJECT (wimage),
4735 XG_TOOL_BAR_STOCK_NAME);
4736 if (!old || strcmp (old, stock_name))
4737 return 1;
4739 else if (icon_name && wimage)
4741 old = g_object_get_data (G_OBJECT (wimage),
4742 XG_TOOL_BAR_ICON_NAME);
4743 if (!old || strcmp (old, icon_name))
4744 return 1;
4746 else if (wimage)
4748 gpointer gold_img = g_object_get_data (G_OBJECT (wimage),
4749 XG_TOOL_BAR_IMAGE_DATA);
4750 Pixmap old_img = (Pixmap) gold_img;
4751 if (old_img != img->pixmap)
4752 return 1;
4755 /* Check button configuration and label. */
4756 if (is_box_type (vb, horiz)
4757 || (label ? (wlbl == NULL) : (wlbl != NULL)))
4758 return 1;
4760 /* Ensure label is correct. */
4761 if (label && wlbl)
4762 gtk_label_set_text (GTK_LABEL (wlbl), label);
4763 return 0;
4766 static bool
4767 xg_update_tool_bar_sizes (struct frame *f)
4769 struct x_output *x = f->output_data.x;
4770 GtkRequisition req;
4771 int nl = 0, nr = 0, nt = 0, nb = 0;
4772 GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
4774 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget), NULL, &req);
4775 if (x->toolbar_in_hbox)
4777 int pos;
4778 gtk_container_child_get (GTK_CONTAINER (x->hbox_widget),
4779 top_widget,
4780 "position", &pos, NULL);
4781 if (pos == 0) nl = req.width;
4782 else nr = req.width;
4784 else
4786 int pos;
4787 gtk_container_child_get (GTK_CONTAINER (x->vbox_widget),
4788 top_widget,
4789 "position", &pos, NULL);
4790 if (pos == 0 || (pos == 1 && x->menubar_widget)) nt = req.height;
4791 else nb = req.height;
4794 if (nl != FRAME_TOOLBAR_LEFT_WIDTH (f)
4795 || nr != FRAME_TOOLBAR_RIGHT_WIDTH (f)
4796 || nt != FRAME_TOOLBAR_TOP_HEIGHT (f)
4797 || nb != FRAME_TOOLBAR_BOTTOM_HEIGHT (f))
4799 FRAME_TOOLBAR_RIGHT_WIDTH (f) = FRAME_TOOLBAR_LEFT_WIDTH (f)
4800 = FRAME_TOOLBAR_TOP_HEIGHT (f) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = 0;
4801 FRAME_TOOLBAR_LEFT_WIDTH (f) = nl;
4802 FRAME_TOOLBAR_RIGHT_WIDTH (f) = nr;
4803 FRAME_TOOLBAR_TOP_HEIGHT (f) = nt;
4804 FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = nb;
4805 return 1;
4808 return 0;
4812 /* Update the tool bar for frame F. Add new buttons and remove old. */
4814 void
4815 update_frame_tool_bar (struct frame *f)
4817 int i, j;
4818 struct x_output *x = f->output_data.x;
4819 int hmargin = 0, vmargin = 0;
4820 GtkToolbar *wtoolbar;
4821 GtkToolItem *ti;
4822 GtkTextDirection dir;
4823 Lisp_Object style;
4824 bool text_image, horiz;
4825 struct xg_frame_tb_info *tbinfo;
4827 if (! FRAME_GTK_WIDGET (f))
4828 return;
4830 block_input ();
4832 if (RANGED_INTEGERP (1, Vtool_bar_button_margin, INT_MAX))
4834 hmargin = XFASTINT (Vtool_bar_button_margin);
4835 vmargin = XFASTINT (Vtool_bar_button_margin);
4837 else if (CONSP (Vtool_bar_button_margin))
4839 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin), INT_MAX))
4840 hmargin = XFASTINT (XCAR (Vtool_bar_button_margin));
4842 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin), INT_MAX))
4843 vmargin = XFASTINT (XCDR (Vtool_bar_button_margin));
4846 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4847 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4848 i.e. zero. This means that margins less than
4849 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4850 hmargin = max (0, hmargin - DEFAULT_TOOL_BAR_BUTTON_MARGIN);
4851 vmargin = max (0, vmargin - DEFAULT_TOOL_BAR_BUTTON_MARGIN);
4853 if (! x->toolbar_widget)
4854 xg_create_tool_bar (f);
4856 wtoolbar = GTK_TOOLBAR (x->toolbar_widget);
4857 dir = gtk_widget_get_direction (GTK_WIDGET (wtoolbar));
4859 style = Ftool_bar_get_system_style ();
4861 /* Are we up to date? */
4862 tbinfo = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
4863 TB_INFO_KEY);
4865 if (! NILP (tbinfo->last_tool_bar) && ! NILP (f->tool_bar_items)
4866 && tbinfo->n_last_items == f->n_tool_bar_items
4867 && tbinfo->hmargin == hmargin && tbinfo->vmargin == vmargin
4868 && tbinfo->dir == dir
4869 && ! NILP (Fequal (tbinfo->style, style))
4870 && ! NILP (Fequal (tbinfo->last_tool_bar, f->tool_bar_items)))
4872 unblock_input ();
4873 return;
4876 tbinfo->last_tool_bar = f->tool_bar_items;
4877 tbinfo->n_last_items = f->n_tool_bar_items;
4878 tbinfo->style = style;
4879 tbinfo->hmargin = hmargin;
4880 tbinfo->vmargin = vmargin;
4881 tbinfo->dir = dir;
4883 text_image = EQ (style, Qtext_image_horiz);
4884 horiz = EQ (style, Qboth_horiz) || text_image;
4886 for (i = j = 0; i < f->n_tool_bar_items; ++i)
4888 bool enabled_p = !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P));
4889 bool selected_p = !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P));
4890 int idx;
4891 ptrdiff_t img_id;
4892 int icon_size = 0;
4893 struct image *img = NULL;
4894 Lisp_Object image;
4895 Lisp_Object stock = Qnil;
4896 GtkStockItem stock_item;
4897 char *stock_name = NULL;
4898 char *icon_name = NULL;
4899 Lisp_Object rtl;
4900 GtkWidget *wbutton = NULL;
4901 Lisp_Object specified_file;
4902 bool vert_only = ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY));
4903 const char *label
4904 = (EQ (style, Qimage) || (vert_only && horiz)) ? NULL
4905 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL))
4906 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL))
4907 : "";
4909 ti = gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar), j);
4911 /* If this is a separator, use a gtk separator item. */
4912 if (EQ (PROP (TOOL_BAR_ITEM_TYPE), Qt))
4914 if (ti == NULL || !GTK_IS_SEPARATOR_TOOL_ITEM (ti))
4916 if (ti)
4917 gtk_container_remove (GTK_CONTAINER (wtoolbar),
4918 GTK_WIDGET (ti));
4919 ti = gtk_separator_tool_item_new ();
4920 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar), ti, j);
4922 j++;
4923 continue;
4926 /* Otherwise, the tool-bar item is an ordinary button. */
4928 if (ti && GTK_IS_SEPARATOR_TOOL_ITEM (ti))
4930 gtk_container_remove (GTK_CONTAINER (wtoolbar), GTK_WIDGET (ti));
4931 ti = NULL;
4934 if (ti) wbutton = XG_BIN_CHILD (XG_BIN_CHILD (ti));
4936 /* Ignore invalid image specifications. */
4937 image = PROP (TOOL_BAR_ITEM_IMAGES);
4938 if (!valid_image_p (image))
4940 if (ti)
4941 gtk_container_remove (GTK_CONTAINER (wtoolbar),
4942 GTK_WIDGET (ti));
4943 continue;
4946 specified_file = file_for_image (image);
4947 if (!NILP (specified_file) && !NILP (Ffboundp (Qx_gtk_map_stock)))
4948 stock = call1 (Qx_gtk_map_stock, specified_file);
4950 if (STRINGP (stock))
4952 stock_name = SSDATA (stock);
4953 if (stock_name[0] == 'n' && stock_name[1] == ':')
4955 GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (wtoolbar));
4956 GtkIconTheme *icon_theme = gtk_icon_theme_get_for_screen (screen);
4958 icon_name = stock_name + 2;
4959 stock_name = NULL;
4960 stock = Qnil;
4962 if (! gtk_icon_theme_has_icon (icon_theme, icon_name))
4963 icon_name = NULL;
4964 else
4965 icon_size = gtk_toolbar_get_icon_size (wtoolbar);
4967 else if (gtk_stock_lookup (SSDATA (stock), &stock_item))
4968 icon_size = gtk_toolbar_get_icon_size (wtoolbar);
4969 else
4971 stock = Qnil;
4972 stock_name = NULL;
4976 if (stock_name == NULL && icon_name == NULL)
4978 /* No stock image, or stock item not known. Try regular
4979 image. If image is a vector, choose it according to the
4980 button state. */
4981 if (dir == GTK_TEXT_DIR_RTL
4982 && !NILP (rtl = PROP (TOOL_BAR_ITEM_RTL_IMAGE))
4983 && STRINGP (rtl))
4984 image = find_rtl_image (f, image, rtl);
4986 if (VECTORP (image))
4988 if (enabled_p)
4989 idx = (selected_p
4990 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4991 : TOOL_BAR_IMAGE_ENABLED_DESELECTED);
4992 else
4993 idx = (selected_p
4994 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4995 : TOOL_BAR_IMAGE_DISABLED_DESELECTED);
4997 eassert (ASIZE (image) >= idx);
4998 image = AREF (image, idx);
5000 else
5001 idx = -1;
5003 img_id = lookup_image (f, image);
5004 img = IMAGE_FROM_ID (f, img_id);
5005 prepare_image_for_display (f, img);
5007 if (img->load_failed_p || img->pixmap == None)
5009 if (ti)
5010 gtk_container_remove (GTK_CONTAINER (wtoolbar),
5011 GTK_WIDGET (ti));
5012 continue;
5016 /* If there is an existing widget, check if it's stale; if so,
5017 remove it and make a new tool item from scratch. */
5018 if (ti && xg_tool_item_stale_p (wbutton, stock_name, icon_name,
5019 img, label, horiz))
5021 gtk_container_remove (GTK_CONTAINER (wtoolbar),
5022 GTK_WIDGET (ti));
5023 ti = NULL;
5026 if (ti == NULL)
5028 GtkWidget *w;
5030 /* Save the image so we can see if an update is needed the
5031 next time we call xg_tool_item_match_p. */
5032 if (EQ (style, Qtext))
5033 w = NULL;
5034 else if (stock_name)
5036 w = gtk_image_new_from_stock (stock_name, icon_size);
5037 g_object_set_data_full (G_OBJECT (w), XG_TOOL_BAR_STOCK_NAME,
5038 (gpointer) xstrdup (stock_name),
5039 (GDestroyNotify) xfree);
5041 else if (icon_name)
5043 w = gtk_image_new_from_icon_name (icon_name, icon_size);
5044 g_object_set_data_full (G_OBJECT (w), XG_TOOL_BAR_ICON_NAME,
5045 (gpointer) xstrdup (icon_name),
5046 (GDestroyNotify) xfree);
5048 else
5050 w = xg_get_image_for_pixmap (f, img, x->widget, NULL);
5051 g_object_set_data (G_OBJECT (w), XG_TOOL_BAR_IMAGE_DATA,
5052 (gpointer)img->pixmap);
5055 if (w) gtk_misc_set_padding (GTK_MISC (w), hmargin, vmargin);
5056 ti = xg_make_tool_item (f, w, &wbutton, label, i, horiz, text_image);
5057 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar), ti, j);
5060 #undef PROP
5062 gtk_widget_set_sensitive (wbutton, enabled_p);
5063 j++;
5066 /* Remove buttons not longer needed. */
5069 ti = gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar), j);
5070 if (ti)
5071 gtk_container_remove (GTK_CONTAINER (wtoolbar), GTK_WIDGET (ti));
5072 } while (ti != NULL);
5074 if (f->n_tool_bar_items != 0)
5076 if (! x->toolbar_is_packed)
5077 xg_pack_tool_bar (f, FRAME_TOOL_BAR_POSITION (f));
5078 gtk_widget_show_all (TOOLBAR_TOP_WIDGET (x));
5079 if (xg_update_tool_bar_sizes (f))
5080 xg_height_or_width_changed (f);
5083 unblock_input ();
5086 /* Deallocate all resources for the tool bar on frame F.
5087 Remove the tool bar. */
5089 void
5090 free_frame_tool_bar (struct frame *f)
5092 struct x_output *x = f->output_data.x;
5094 if (x->toolbar_widget)
5096 struct xg_frame_tb_info *tbinfo;
5097 GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
5099 block_input ();
5100 /* We may have created the toolbar_widget in xg_create_tool_bar, but
5101 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
5102 if (x->toolbar_is_packed)
5104 if (x->toolbar_in_hbox)
5105 gtk_container_remove (GTK_CONTAINER (x->hbox_widget),
5106 top_widget);
5107 else
5108 gtk_container_remove (GTK_CONTAINER (x->vbox_widget),
5109 top_widget);
5111 else
5112 gtk_widget_destroy (x->toolbar_widget);
5114 x->toolbar_widget = 0;
5115 TOOLBAR_TOP_WIDGET (x) = 0;
5116 x->toolbar_is_packed = false;
5117 FRAME_TOOLBAR_TOP_HEIGHT (f) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = 0;
5118 FRAME_TOOLBAR_LEFT_WIDTH (f) = FRAME_TOOLBAR_RIGHT_WIDTH (f) = 0;
5120 tbinfo = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
5121 TB_INFO_KEY);
5122 if (tbinfo)
5124 xfree (tbinfo);
5125 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
5126 TB_INFO_KEY,
5127 NULL);
5130 xg_height_or_width_changed (f);
5132 unblock_input ();
5136 void
5137 xg_change_toolbar_position (struct frame *f, Lisp_Object pos)
5139 struct x_output *x = f->output_data.x;
5140 GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
5142 if (! x->toolbar_widget || ! top_widget)
5143 return;
5145 block_input ();
5146 g_object_ref (top_widget);
5147 if (x->toolbar_is_packed)
5149 if (x->toolbar_in_hbox)
5150 gtk_container_remove (GTK_CONTAINER (x->hbox_widget),
5151 top_widget);
5152 else
5153 gtk_container_remove (GTK_CONTAINER (x->vbox_widget),
5154 top_widget);
5157 xg_pack_tool_bar (f, pos);
5158 g_object_unref (top_widget);
5159 if (xg_update_tool_bar_sizes (f))
5160 xg_height_or_width_changed (f);
5162 unblock_input ();
5167 /***********************************************************************
5168 Initializing
5169 ***********************************************************************/
5170 void
5171 xg_initialize (void)
5173 GtkBindingSet *binding_set;
5174 GtkSettings *settings;
5176 #if HAVE_XFT
5177 /* Work around a bug with corrupted data if libXft gets unloaded. This way
5178 we keep it permanently linked in. */
5179 XftInit (0);
5180 #endif
5182 gdpy_def = NULL;
5183 xg_ignore_gtk_scrollbar = 0;
5184 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
5185 xg_detached_menus = 0;
5186 #endif
5187 xg_menu_cb_list.prev = xg_menu_cb_list.next =
5188 xg_menu_item_cb_list.prev = xg_menu_item_cb_list.next = 0;
5190 id_to_widget.max_size = id_to_widget.used = 0;
5191 id_to_widget.widgets = 0;
5193 settings = gtk_settings_get_for_screen (gdk_display_get_default_screen
5194 (gdk_display_get_default ()));
5195 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5196 bindings. It doesn't seem to be any way to remove properties,
5197 so we set it to "" which in means "no key". */
5198 gtk_settings_set_string_property (settings,
5199 "gtk-menu-bar-accel",
5201 EMACS_CLASS);
5203 /* Make GTK text input widgets use Emacs style keybindings. This is
5204 Emacs after all. */
5205 gtk_settings_set_string_property (settings,
5206 "gtk-key-theme-name",
5207 "Emacs",
5208 EMACS_CLASS);
5210 /* Make dialogs close on C-g. Since file dialog inherits from
5211 dialog, this works for them also. */
5212 binding_set = gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG));
5213 gtk_binding_entry_add_signal (binding_set, GDK_KEY_g, GDK_CONTROL_MASK,
5214 "close", 0);
5216 /* Make menus close on C-g. */
5217 binding_set = gtk_binding_set_by_class (g_type_class_ref
5218 (GTK_TYPE_MENU_SHELL));
5219 gtk_binding_entry_add_signal (binding_set, GDK_KEY_g, GDK_CONTROL_MASK,
5220 "cancel", 0);
5221 update_theme_scrollbar_width ();
5222 update_theme_scrollbar_height ();
5224 #ifdef HAVE_FREETYPE
5225 x_last_font_name = NULL;
5226 #endif
5229 #endif /* USE_GTK */