* image.el (image-type-from-buffer): Remove --without-x warning/error.
[emacs.git] / src / gtkutil.c
blobe20d01521f08ac9a244ee3ee1be2b2f80cbe490d
1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2013 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 "gtkutil.h"
34 #include "termhooks.h"
35 #include "keyboard.h"
36 #include "charset.h"
37 #include "coding.h"
38 #include "font.h"
40 #include <gdk/gdkkeysyms.h>
41 #include "xsettings.h"
43 #ifdef HAVE_XFT
44 #include <X11/Xft/Xft.h>
45 #endif
47 #ifdef HAVE_GTK3
48 #include <gtk/gtkx.h>
49 #include "emacsgtkfixed.h"
50 #endif
52 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
53 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
55 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
56 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
58 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
59 #define gtk_widget_set_has_window(w, b) \
60 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
61 #endif
62 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
63 #define gtk_dialog_get_action_area(w) ((w)->action_area)
64 #define gtk_dialog_get_content_area(w) ((w)->vbox)
65 #endif
66 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
67 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
68 #endif
69 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
70 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
71 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
72 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
73 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
74 #endif
75 #if GTK_CHECK_VERSION (2, 12, 0)
76 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
77 #else
78 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
79 #endif
81 #if GTK_CHECK_VERSION (3, 2, 0)
82 #define USE_NEW_GTK_FONT_CHOOSER 1
83 #else
84 #define USE_NEW_GTK_FONT_CHOOSER 0
85 #define gtk_font_chooser_dialog_new(x, y) \
86 gtk_font_selection_dialog_new (x)
87 #undef GTK_FONT_CHOOSER
88 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
89 #define gtk_font_chooser_set_font(x, y) \
90 gtk_font_selection_dialog_set_font_name (x, y)
91 #endif
93 #ifndef HAVE_GTK3
94 #ifdef USE_GTK_TOOLTIP
95 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
96 #endif
97 #define gdk_window_get_geometry(w, a, b, c, d) \
98 gdk_window_get_geometry (w, a, b, c, d, 0)
99 #define gdk_x11_window_lookup_for_display(d, w) \
100 gdk_xid_table_lookup_for_display (d, w)
101 #define gtk_box_new(ori, spacing) \
102 ((ori) == GTK_ORIENTATION_HORIZONTAL \
103 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
104 #define gtk_scrollbar_new(ori, spacing) \
105 ((ori) == GTK_ORIENTATION_HORIZONTAL \
106 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
107 #ifndef GDK_KEY_g
108 #define GDK_KEY_g GDK_g
109 #endif
110 #endif /* HAVE_GTK3 */
112 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
114 static void update_theme_scrollbar_width (void);
116 #define TB_INFO_KEY "xg_frame_tb_info"
117 struct xg_frame_tb_info
119 Lisp_Object last_tool_bar;
120 Lisp_Object style;
121 int n_last_items;
122 int hmargin, vmargin;
123 GtkTextDirection dir;
127 /***********************************************************************
128 Display handling functions
129 ***********************************************************************/
131 /* Keep track of the default display, or NULL if there is none. Emacs
132 may close all its displays. */
134 static GdkDisplay *gdpy_def;
136 /* When the GTK widget W is to be created on a display for F that
137 is not the default display, set the display for W.
138 W can be a GtkMenu or a GtkWindow widget. */
140 static void
141 xg_set_screen (GtkWidget *w, struct frame *f)
143 if (FRAME_X_DISPLAY (f) != DEFAULT_GDK_DISPLAY ())
145 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
146 GdkScreen *gscreen = gdk_display_get_default_screen (gdpy);
148 if (GTK_IS_MENU (w))
149 gtk_menu_set_screen (GTK_MENU (w), gscreen);
150 else
151 gtk_window_set_screen (GTK_WINDOW (w), gscreen);
156 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
157 *DPY is set to NULL if the display can't be opened.
159 Returns non-zero if display could be opened, zero if display could not
160 be opened, and less than zero if the GTK version doesn't support
161 multiple displays. */
163 void
164 xg_display_open (char *display_name, Display **dpy)
166 GdkDisplay *gdpy;
168 gdpy = gdk_display_open (display_name);
169 if (!gdpy_def && gdpy)
171 gdpy_def = gdpy;
172 gdk_display_manager_set_default_display (gdk_display_manager_get (),
173 gdpy);
176 *dpy = gdpy ? GDK_DISPLAY_XDISPLAY (gdpy) : NULL;
180 /* Close display DPY. */
182 void
183 xg_display_close (Display *dpy)
185 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (dpy);
187 /* If this is the default display, try to change it before closing.
188 If there is no other display to use, gdpy_def is set to NULL, and
189 the next call to xg_display_open resets the default display. */
190 if (gdk_display_get_default () == gdpy)
192 struct x_display_info *dpyinfo;
193 GdkDisplay *gdpy_new = NULL;
195 /* Find another display. */
196 for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
197 if (dpyinfo->display != dpy)
199 gdpy_new = gdk_x11_lookup_xdisplay (dpyinfo->display);
200 gdk_display_manager_set_default_display (gdk_display_manager_get (),
201 gdpy_new);
202 break;
204 gdpy_def = gdpy_new;
207 #if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
208 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
209 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
210 can continue running, but there will be memory leaks. */
211 g_object_run_dispose (G_OBJECT (gdpy));
212 #else
213 /* This seems to be fixed in GTK 2.10. */
214 gdk_display_close (gdpy);
215 #endif
219 /***********************************************************************
220 Utility functions
221 ***********************************************************************/
222 /* The next two variables and functions are taken from lwlib. */
223 static widget_value *widget_value_free_list;
224 static int malloc_cpt;
226 /* Allocate a widget_value structure, either by taking one from the
227 widget_value_free_list or by malloc:ing a new one.
229 Return a pointer to the allocated structure. */
231 widget_value *
232 malloc_widget_value (void)
234 widget_value *wv;
235 if (widget_value_free_list)
237 wv = widget_value_free_list;
238 widget_value_free_list = wv->free_list;
239 wv->free_list = 0;
241 else
243 wv = xmalloc (sizeof *wv);
244 malloc_cpt++;
246 memset (wv, 0, sizeof (widget_value));
247 return wv;
250 /* This is analogous to free. It frees only what was allocated
251 by malloc_widget_value, and no substructures. */
253 void
254 free_widget_value (widget_value *wv)
256 if (wv->free_list)
257 emacs_abort ();
259 if (malloc_cpt > 25)
261 /* When the number of already allocated cells is too big,
262 We free it. */
263 xfree (wv);
264 malloc_cpt--;
266 else
268 wv->free_list = widget_value_free_list;
269 widget_value_free_list = wv;
274 /* Create and return the cursor to be used for popup menus and
275 scroll bars on display DPY. */
277 GdkCursor *
278 xg_create_default_cursor (Display *dpy)
280 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (dpy);
281 return gdk_cursor_new_for_display (gdpy, GDK_LEFT_PTR);
284 static GdkPixbuf *
285 xg_get_pixbuf_from_pixmap (struct frame *f, Pixmap pix)
287 int iunused;
288 GdkPixbuf *tmp_buf;
289 Window wunused;
290 unsigned int width, height, uunused;
291 XImage *xim;
293 XGetGeometry (FRAME_X_DISPLAY (f), pix, &wunused, &iunused, &iunused,
294 &width, &height, &uunused, &uunused);
296 xim = XGetImage (FRAME_X_DISPLAY (f), pix, 0, 0, width, height,
297 ~0, XYPixmap);
298 if (!xim) return 0;
300 tmp_buf = gdk_pixbuf_new_from_data ((guchar *) xim->data,
301 GDK_COLORSPACE_RGB,
302 FALSE,
303 xim->bitmap_unit,
304 width,
305 height,
306 xim->bytes_per_line,
307 NULL,
308 NULL);
309 XDestroyImage (xim);
310 return tmp_buf;
313 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
315 static GdkPixbuf *
316 xg_get_pixbuf_from_pix_and_mask (struct frame *f,
317 Pixmap pix,
318 Pixmap mask)
320 int width, height;
321 GdkPixbuf *icon_buf, *tmp_buf;
323 tmp_buf = xg_get_pixbuf_from_pixmap (f, pix);
324 icon_buf = gdk_pixbuf_add_alpha (tmp_buf, FALSE, 0, 0, 0);
325 g_object_unref (G_OBJECT (tmp_buf));
327 width = gdk_pixbuf_get_width (icon_buf);
328 height = gdk_pixbuf_get_height (icon_buf);
330 if (mask)
332 GdkPixbuf *mask_buf = xg_get_pixbuf_from_pixmap (f, mask);
333 guchar *pixels = gdk_pixbuf_get_pixels (icon_buf);
334 guchar *mask_pixels = gdk_pixbuf_get_pixels (mask_buf);
335 int rowstride = gdk_pixbuf_get_rowstride (icon_buf);
336 int mask_rowstride = gdk_pixbuf_get_rowstride (mask_buf);
337 int y;
339 for (y = 0; y < height; ++y)
341 guchar *iconptr, *maskptr;
342 int x;
344 iconptr = pixels + y * rowstride;
345 maskptr = mask_pixels + y * mask_rowstride;
347 for (x = 0; x < width; ++x)
349 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
350 just R is sufficient. */
351 if (maskptr[0] == 0)
352 iconptr[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
354 iconptr += rowstride/width;
355 maskptr += mask_rowstride/width;
359 g_object_unref (G_OBJECT (mask_buf));
362 return icon_buf;
365 static Lisp_Object
366 file_for_image (Lisp_Object image)
368 Lisp_Object specified_file = Qnil;
369 Lisp_Object tail;
371 for (tail = XCDR (image);
372 NILP (specified_file) && CONSP (tail) && CONSP (XCDR (tail));
373 tail = XCDR (XCDR (tail)))
374 if (EQ (XCAR (tail), QCfile))
375 specified_file = XCAR (XCDR (tail));
377 return specified_file;
380 /* For the image defined in IMG, make and return a GtkImage. For displays with
381 8 planes or less we must make a GdkPixbuf and apply the mask manually.
382 Otherwise the highlighting and dimming the tool bar code in GTK does
383 will look bad. For display with more than 8 planes we just use the
384 pixmap and mask directly. For monochrome displays, GTK doesn't seem
385 able to use external pixmaps, it looks bad whatever we do.
386 The image is defined on the display where frame F is.
387 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
388 If OLD_WIDGET is NULL, a new widget is constructed and returned.
389 If OLD_WIDGET is not NULL, that widget is modified. */
391 static GtkWidget *
392 xg_get_image_for_pixmap (struct frame *f,
393 struct image *img,
394 GtkWidget *widget,
395 GtkImage *old_widget)
397 GdkPixbuf *icon_buf;
399 /* If we have a file, let GTK do all the image handling.
400 This seems to be the only way to make insensitive and activated icons
401 look good in all cases. */
402 Lisp_Object specified_file = file_for_image (img->spec);
403 Lisp_Object file;
405 /* We already loaded the image once before calling this
406 function, so this only fails if the image file has been removed.
407 In that case, use the pixmap already loaded. */
409 if (STRINGP (specified_file)
410 && STRINGP (file = x_find_image_file (specified_file)))
412 if (! old_widget)
413 old_widget = GTK_IMAGE (gtk_image_new_from_file (SSDATA (file)));
414 else
415 gtk_image_set_from_file (old_widget, SSDATA (file));
417 return GTK_WIDGET (old_widget);
420 /* No file, do the image handling ourselves. This will look very bad
421 on a monochrome display, and sometimes bad on all displays with
422 certain themes. */
424 /* This is a workaround to make icons look good on pseudo color
425 displays. Apparently GTK expects the images to have an alpha
426 channel. If they don't, insensitive and activated icons will
427 look bad. This workaround does not work on monochrome displays,
428 and is strictly not needed on true color/static color displays (i.e.
429 16 bits and higher). But we do it anyway so we get a pixbuf that is
430 not associated with the img->pixmap. The img->pixmap may be removed
431 by clearing the image cache and then the tool bar redraw fails, since
432 Gtk+ assumes the pixmap is always there. */
433 icon_buf = xg_get_pixbuf_from_pix_and_mask (f, img->pixmap, img->mask);
435 if (icon_buf)
437 if (! old_widget)
438 old_widget = GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf));
439 else
440 gtk_image_set_from_pixbuf (old_widget, icon_buf);
442 g_object_unref (G_OBJECT (icon_buf));
445 return GTK_WIDGET (old_widget);
449 /* Set CURSOR on W and all widgets W contain. We must do like this
450 for scroll bars and menu because they create widgets internally,
451 and it is those widgets that are visible. */
453 static void
454 xg_set_cursor (GtkWidget *w, GdkCursor *cursor)
456 GdkWindow *window = gtk_widget_get_window (w);
457 GList *children = gdk_window_peek_children (window);
459 gdk_window_set_cursor (window, cursor);
461 /* The scroll bar widget has more than one GDK window (had to look at
462 the source to figure this out), and there is no way to set cursor
463 on widgets in GTK. So we must set the cursor for all GDK windows.
464 Ditto for menus. */
466 for ( ; children; children = g_list_next (children))
467 gdk_window_set_cursor (GDK_WINDOW (children->data), cursor);
470 /* Insert NODE into linked LIST. */
472 static void
473 xg_list_insert (xg_list_node *list, xg_list_node *node)
475 xg_list_node *list_start = list->next;
477 if (list_start) list_start->prev = node;
478 node->next = list_start;
479 node->prev = 0;
480 list->next = node;
483 /* Remove NODE from linked LIST. */
485 static void
486 xg_list_remove (xg_list_node *list, xg_list_node *node)
488 xg_list_node *list_start = list->next;
489 if (node == list_start)
491 list->next = node->next;
492 if (list->next) list->next->prev = 0;
494 else
496 node->prev->next = node->next;
497 if (node->next) node->next->prev = node->prev;
501 /* Allocate and return a utf8 version of STR. If STR is already
502 utf8 or NULL, just return a copy of STR.
503 A new string is allocated and the caller must free the result
504 with g_free. */
506 static char *
507 get_utf8_string (const char *str)
509 char *utf8_str;
511 if (!str) return NULL;
513 /* If not UTF-8, try current locale. */
514 if (!g_utf8_validate (str, -1, NULL))
515 utf8_str = g_locale_to_utf8 (str, -1, 0, 0, 0);
516 else
517 return g_strdup (str);
519 if (!utf8_str)
521 /* Probably some control characters in str. Escape them. */
522 ptrdiff_t len;
523 ptrdiff_t nr_bad = 0;
524 gsize bytes_read;
525 gsize bytes_written;
526 unsigned char *p = (unsigned char *)str;
527 char *cp, *up;
528 GError *err = NULL;
530 while (! (cp = g_locale_to_utf8 ((char *)p, -1, &bytes_read,
531 &bytes_written, &err))
532 && err->code == G_CONVERT_ERROR_ILLEGAL_SEQUENCE)
534 ++nr_bad;
535 p += bytes_written+1;
536 g_error_free (err);
537 err = NULL;
540 if (err)
542 g_error_free (err);
543 err = NULL;
545 if (cp) g_free (cp);
547 len = strlen (str);
548 if ((min (PTRDIFF_MAX, SIZE_MAX) - len - 1) / 4 < nr_bad)
549 memory_full (SIZE_MAX);
550 up = utf8_str = xmalloc (len + nr_bad * 4 + 1);
551 p = (unsigned char *)str;
553 while (! (cp = g_locale_to_utf8 ((char *)p, -1, &bytes_read,
554 &bytes_written, &err))
555 && err->code == G_CONVERT_ERROR_ILLEGAL_SEQUENCE)
557 memcpy (up, p, bytes_written);
558 sprintf (up + bytes_written, "\\%03o", p[bytes_written]);
559 up += bytes_written+4;
560 p += bytes_written+1;
561 g_error_free (err);
562 err = NULL;
565 if (cp)
567 strcat (utf8_str, cp);
568 g_free (cp);
570 if (err)
572 g_error_free (err);
573 err = NULL;
576 return utf8_str;
579 /* Check for special colors used in face spec for region face.
580 The colors are fetched from the Gtk+ theme.
581 Return true if color was found, false if not. */
583 bool
584 xg_check_special_colors (struct frame *f,
585 const char *color_name,
586 XColor *color)
588 bool success_p = 0;
589 bool get_bg = strcmp ("gtk_selection_bg_color", color_name) == 0;
590 bool get_fg = !get_bg && strcmp ("gtk_selection_fg_color", color_name) == 0;
592 if (! FRAME_GTK_WIDGET (f) || ! (get_bg || get_fg))
593 return success_p;
595 block_input ();
597 #ifdef HAVE_GTK3
598 GtkStyleContext *gsty
599 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f));
600 GdkRGBA col;
601 char buf[sizeof "rgbi://" + 3 * (DBL_MAX_10_EXP + sizeof "-1.000000" - 1)];
602 int state = GTK_STATE_FLAG_SELECTED|GTK_STATE_FLAG_FOCUSED;
603 if (get_fg)
604 gtk_style_context_get_color (gsty, state, &col);
605 else
606 gtk_style_context_get_background_color (gsty, state, &col);
608 sprintf (buf, "rgbi:%lf/%lf/%lf", col.red, col.green, col.blue);
609 success_p = (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
610 buf, color)
611 != 0);
612 #else
613 GtkStyle *gsty = gtk_widget_get_style (FRAME_GTK_WIDGET (f));
614 GdkColor *grgb = get_bg
615 ? &gsty->bg[GTK_STATE_SELECTED]
616 : &gsty->fg[GTK_STATE_SELECTED];
618 color->red = grgb->red;
619 color->green = grgb->green;
620 color->blue = grgb->blue;
621 color->pixel = grgb->pixel;
622 success_p = 1;
623 #endif
626 unblock_input ();
627 return success_p;
632 /***********************************************************************
633 Tooltips
634 ***********************************************************************/
635 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
636 We use that to pop down the tooltip. This happens if Gtk+ for some
637 reason wants to change or hide the tooltip. */
639 #ifdef USE_GTK_TOOLTIP
641 static void
642 hierarchy_ch_cb (GtkWidget *widget,
643 GtkWidget *previous_toplevel,
644 gpointer user_data)
646 struct frame *f = user_data;
647 struct x_output *x = f->output_data.x;
648 GtkWidget *top = gtk_widget_get_toplevel (x->ttip_lbl);
650 if (! top || ! GTK_IS_WINDOW (top))
651 gtk_widget_hide (previous_toplevel);
654 /* Callback called when Gtk+ thinks a tooltip should be displayed.
655 We use it to get the tooltip window and the tooltip widget so
656 we can manipulate the ourselves.
658 Return FALSE ensures that the tooltip is not shown. */
660 static gboolean
661 qttip_cb (GtkWidget *widget,
662 gint xpos,
663 gint ypos,
664 gboolean keyboard_mode,
665 GtkTooltip *tooltip,
666 gpointer user_data)
668 struct frame *f = user_data;
669 struct x_output *x = f->output_data.x;
670 if (x->ttip_widget == NULL)
672 GtkWidget *p;
673 GList *list, *iter;
675 g_object_set (G_OBJECT (widget), "has-tooltip", FALSE, NULL);
676 x->ttip_widget = tooltip;
677 g_object_ref (G_OBJECT (tooltip));
678 x->ttip_lbl = gtk_label_new ("");
679 g_object_ref (G_OBJECT (x->ttip_lbl));
680 gtk_tooltip_set_custom (tooltip, x->ttip_lbl);
681 x->ttip_window = GTK_WINDOW (gtk_widget_get_toplevel (x->ttip_lbl));
683 /* Change stupid Gtk+ default line wrapping. */
684 p = gtk_widget_get_parent (x->ttip_lbl);
685 list = gtk_container_get_children (GTK_CONTAINER (p));
686 for (iter = list; iter; iter = g_list_next (iter))
688 GtkWidget *w = GTK_WIDGET (iter->data);
689 if (GTK_IS_LABEL (w))
690 gtk_label_set_line_wrap (GTK_LABEL (w), FALSE);
692 g_list_free (list);
694 /* ATK needs an empty title for some reason. */
695 gtk_window_set_title (x->ttip_window, "");
696 /* Realize so we can safely get screen later on. */
697 gtk_widget_realize (GTK_WIDGET (x->ttip_window));
698 gtk_widget_realize (x->ttip_lbl);
700 g_signal_connect (x->ttip_lbl, "hierarchy-changed",
701 G_CALLBACK (hierarchy_ch_cb), f);
703 return FALSE;
706 #endif /* USE_GTK_TOOLTIP */
708 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
709 Return true if a system tooltip is available. */
711 bool
712 xg_prepare_tooltip (struct frame *f,
713 Lisp_Object string,
714 int *width,
715 int *height)
717 #ifndef USE_GTK_TOOLTIP
718 return 0;
719 #else
720 struct x_output *x = f->output_data.x;
721 GtkWidget *widget;
722 GdkWindow *gwin;
723 GdkScreen *screen;
724 GtkSettings *settings;
725 gboolean tt_enabled = TRUE;
726 GtkRequisition req;
727 Lisp_Object encoded_string;
729 if (!x->ttip_lbl) return 0;
731 block_input ();
732 encoded_string = ENCODE_UTF_8 (string);
733 widget = GTK_WIDGET (x->ttip_lbl);
734 gwin = gtk_widget_get_window (GTK_WIDGET (x->ttip_window));
735 screen = gdk_window_get_screen (gwin);
736 settings = gtk_settings_get_for_screen (screen);
737 g_object_get (settings, "gtk-enable-tooltips", &tt_enabled, NULL);
738 if (tt_enabled)
740 g_object_set (settings, "gtk-enable-tooltips", FALSE, NULL);
741 /* Record that we disabled it so it can be enabled again. */
742 g_object_set_data (G_OBJECT (x->ttip_window), "restore-tt",
743 (gpointer)f);
746 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
747 g_object_set_data (G_OBJECT
748 (gtk_widget_get_display (GTK_WIDGET (x->ttip_window))),
749 "gdk-display-current-tooltip", NULL);
751 /* Put our dummy widget in so we can get callbacks for unrealize and
752 hierarchy-changed. */
753 gtk_tooltip_set_custom (x->ttip_widget, widget);
754 gtk_tooltip_set_text (x->ttip_widget, SSDATA (encoded_string));
755 gtk_widget_get_preferred_size (GTK_WIDGET (x->ttip_window), NULL, &req);
756 if (width) *width = req.width;
757 if (height) *height = req.height;
759 unblock_input ();
761 return 1;
762 #endif /* USE_GTK_TOOLTIP */
765 /* Show the tooltip at ROOT_X and ROOT_Y.
766 xg_prepare_tooltip must have been called before this function. */
768 void
769 xg_show_tooltip (struct frame *f, int root_x, int root_y)
771 #ifdef USE_GTK_TOOLTIP
772 struct x_output *x = f->output_data.x;
773 if (x->ttip_window)
775 block_input ();
776 gtk_window_move (x->ttip_window, root_x, root_y);
777 gtk_widget_show_all (GTK_WIDGET (x->ttip_window));
778 unblock_input ();
780 #endif
783 /* Hide tooltip if shown. Do nothing if not shown.
784 Return true if tip was hidden, false if not (i.e. not using
785 system tooltips). */
787 bool
788 xg_hide_tooltip (struct frame *f)
790 bool ret = 0;
791 #ifdef USE_GTK_TOOLTIP
792 if (f->output_data.x->ttip_window)
794 GtkWindow *win = f->output_data.x->ttip_window;
795 block_input ();
796 gtk_widget_hide (GTK_WIDGET (win));
798 if (g_object_get_data (G_OBJECT (win), "restore-tt"))
800 GdkWindow *gwin = gtk_widget_get_window (GTK_WIDGET (win));
801 GdkScreen *screen = gdk_window_get_screen (gwin);
802 GtkSettings *settings = gtk_settings_get_for_screen (screen);
803 g_object_set (settings, "gtk-enable-tooltips", TRUE, NULL);
805 unblock_input ();
807 ret = 1;
809 #endif
810 return ret;
814 /***********************************************************************
815 General functions for creating widgets, resizing, events, e.t.c.
816 ***********************************************************************/
818 static void
819 my_log_handler (const gchar *log_domain, GLogLevelFlags log_level,
820 const gchar *msg, gpointer user_data)
822 if (!strstr (msg, "visible children"))
823 fprintf (stderr, "XX %s-WARNING **: %s\n", log_domain, msg);
826 /* Make a geometry string and pass that to GTK. It seems this is the
827 only way to get geometry position right if the user explicitly
828 asked for a position when starting Emacs.
829 F is the frame we shall set geometry for. */
831 static void
832 xg_set_geometry (struct frame *f)
834 if (f->size_hint_flags & (USPosition | PPosition))
836 int left = f->left_pos;
837 int xneg = f->size_hint_flags & XNegative;
838 int top = f->top_pos;
839 int yneg = f->size_hint_flags & YNegative;
840 char geom_str[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
841 guint id;
843 if (xneg)
844 left = -left;
845 if (yneg)
846 top = -top;
848 sprintf (geom_str, "=%dx%d%c%d%c%d",
849 FRAME_PIXEL_WIDTH (f),
850 FRAME_PIXEL_HEIGHT (f),
851 (xneg ? '-' : '+'), left,
852 (yneg ? '-' : '+'), top);
854 /* Silence warning about visible children. */
855 id = g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL
856 | G_LOG_FLAG_RECURSION, my_log_handler, NULL);
858 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
859 geom_str))
860 fprintf (stderr, "Failed to parse: '%s'\n", geom_str);
862 g_log_remove_handler ("Gtk", id);
866 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
867 and use a GtkFixed widget, this doesn't happen automatically. */
869 static void
870 xg_clear_under_internal_border (struct frame *f)
872 if (FRAME_INTERNAL_BORDER_WIDTH (f) > 0)
874 GtkWidget *wfixed = f->output_data.x->edit_widget;
876 gtk_widget_queue_draw (wfixed);
877 gdk_window_process_all_updates ();
879 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), 0, 0,
880 FRAME_PIXEL_WIDTH (f), FRAME_INTERNAL_BORDER_WIDTH (f));
882 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), 0, 0,
883 FRAME_INTERNAL_BORDER_WIDTH (f), FRAME_PIXEL_HEIGHT (f));
885 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), 0,
886 FRAME_PIXEL_HEIGHT (f) - FRAME_INTERNAL_BORDER_WIDTH (f),
887 FRAME_PIXEL_WIDTH (f), FRAME_INTERNAL_BORDER_WIDTH (f));
889 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
890 FRAME_PIXEL_WIDTH (f) - FRAME_INTERNAL_BORDER_WIDTH (f),
891 0, FRAME_INTERNAL_BORDER_WIDTH (f), FRAME_PIXEL_HEIGHT (f));
895 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
896 and a Gtk+ menu bar, we get resize events for the edit part of the
897 frame only. We let Gtk+ deal with the Gtk+ parts.
898 F is the frame to resize.
899 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
901 void
902 xg_frame_resized (struct frame *f, int pixelwidth, int pixelheight)
904 int rows, columns;
906 if (pixelwidth == -1 && pixelheight == -1)
908 if (FRAME_GTK_WIDGET (f) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f)))
909 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f)),
910 0, 0,
911 &pixelwidth, &pixelheight);
912 else return;
916 rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, pixelheight);
917 columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pixelwidth);
919 if (columns != FRAME_COLS (f)
920 || rows != FRAME_LINES (f)
921 || pixelwidth != FRAME_PIXEL_WIDTH (f)
922 || pixelheight != FRAME_PIXEL_HEIGHT (f))
924 FRAME_PIXEL_WIDTH (f) = pixelwidth;
925 FRAME_PIXEL_HEIGHT (f) = pixelheight;
927 xg_clear_under_internal_border (f);
928 change_frame_size (f, rows, columns, 0, 1, 0);
929 SET_FRAME_GARBAGED (f);
930 cancel_mouse_face (f);
934 /* Resize the outer window of frame F after changing the height.
935 COLUMNS/ROWS is the size the edit area shall have after the resize. */
937 void
938 xg_frame_set_char_size (struct frame *f, int cols, int rows)
940 int pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows)
941 + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f);
942 int pixelwidth;
944 if (FRAME_PIXEL_HEIGHT (f) == 0)
945 return;
947 /* Take into account the size of the scroll bar. Always use the
948 number of columns occupied by the scroll bar here otherwise we
949 might end up with a frame width that is not a multiple of the
950 frame's character width which is bad for vertically split
951 windows. */
952 f->scroll_bar_actual_width
953 = FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f);
955 compute_fringe_widths (f, 0);
957 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
958 after calculating that value. */
959 pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, cols)
960 + FRAME_TOOLBAR_WIDTH (f);
963 /* Do this before resize, as we don't know yet if we will be resized. */
964 xg_clear_under_internal_border (f);
966 /* Must resize our top level widget. Font size may have changed,
967 but not rows/cols. */
968 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
969 pixelwidth, pixelheight);
970 x_wm_set_size_hint (f, 0, 0);
972 SET_FRAME_GARBAGED (f);
973 cancel_mouse_face (f);
975 /* We can not call change_frame_size for a mapped frame,
976 we can not set pixel width/height either. The window manager may
977 override our resize request, XMonad does this all the time.
978 The best we can do is try to sync, so lisp code sees the updated
979 size as fast as possible.
980 For unmapped windows, we can set rows/cols. When
981 the frame is mapped again we will (hopefully) get the correct size. */
982 if (FRAME_VISIBLE_P (f))
984 /* Must call this to flush out events */
985 (void)gtk_events_pending ();
986 gdk_flush ();
987 x_wait_for_event (f, ConfigureNotify);
989 else
991 change_frame_size (f, rows, cols, 0, 1, 0);
992 FRAME_PIXEL_WIDTH (f) = pixelwidth;
993 FRAME_PIXEL_HEIGHT (f) = pixelheight;
997 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
998 The policy is to keep the number of editable lines. */
1000 static void
1001 xg_height_or_width_changed (struct frame *f)
1003 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
1004 FRAME_TOTAL_PIXEL_WIDTH (f),
1005 FRAME_TOTAL_PIXEL_HEIGHT (f));
1006 f->output_data.x->hint_flags = 0;
1007 x_wm_set_size_hint (f, 0, 0);
1010 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
1011 Must be done like this, because GtkWidget:s can have "hidden"
1012 X Window that aren't accessible.
1014 Return 0 if no widget match WDESC. */
1016 GtkWidget *
1017 xg_win_to_widget (Display *dpy, Window wdesc)
1019 gpointer gdkwin;
1020 GtkWidget *gwdesc = 0;
1022 block_input ();
1024 gdkwin = gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy),
1025 wdesc);
1026 if (gdkwin)
1028 GdkEvent event;
1029 event.any.window = gdkwin;
1030 event.any.type = GDK_NOTHING;
1031 gwdesc = gtk_get_event_widget (&event);
1034 unblock_input ();
1035 return gwdesc;
1038 /* Set the background of widget W to PIXEL. */
1040 static void
1041 xg_set_widget_bg (struct frame *f, GtkWidget *w, long unsigned int pixel)
1043 #ifdef HAVE_GTK3
1044 GdkRGBA bg;
1045 XColor xbg;
1046 xbg.pixel = pixel;
1047 if (XQueryColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), &xbg))
1049 bg.red = (double)xbg.red/65535.0;
1050 bg.green = (double)xbg.green/65535.0;
1051 bg.blue = (double)xbg.blue/65535.0;
1052 bg.alpha = 1.0;
1053 gtk_widget_override_background_color (w, GTK_STATE_FLAG_NORMAL, &bg);
1055 #else
1056 GdkColor bg;
1057 GdkColormap *map = gtk_widget_get_colormap (w);
1058 gdk_colormap_query_color (map, pixel, &bg);
1059 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f), GTK_STATE_NORMAL, &bg);
1060 #endif
1063 /* Callback called when the gtk theme changes.
1064 We notify lisp code so it can fix faces used for region for example. */
1066 static void
1067 style_changed_cb (GObject *go,
1068 GParamSpec *spec,
1069 gpointer user_data)
1071 struct input_event event;
1072 GdkDisplay *gdpy = user_data;
1073 const char *display_name = gdk_display_get_name (gdpy);
1074 Display *dpy = GDK_DISPLAY_XDISPLAY (gdpy);
1076 EVENT_INIT (event);
1077 event.kind = CONFIG_CHANGED_EVENT;
1078 event.frame_or_window = build_string (display_name);
1079 /* Theme doesn't change often, so intern is called seldom. */
1080 event.arg = intern ("theme-name");
1081 kbd_buffer_store_event (&event);
1083 update_theme_scrollbar_width ();
1085 /* If scroll bar width changed, we need set the new size on all frames
1086 on this display. */
1087 if (dpy)
1089 Lisp_Object rest, frame;
1090 FOR_EACH_FRAME (rest, frame)
1092 struct frame *f = XFRAME (frame);
1093 if (FRAME_LIVE_P (f)
1094 && FRAME_X_P (f)
1095 && FRAME_X_DISPLAY (f) == dpy)
1097 x_set_scroll_bar_default_width (f);
1098 xg_frame_set_char_size (f, FRAME_COLS (f), FRAME_LINES (f));
1104 /* Called when a delete-event occurs on WIDGET. */
1106 static gboolean
1107 delete_cb (GtkWidget *widget,
1108 GdkEvent *event,
1109 gpointer user_data)
1111 #ifdef HAVE_GTK3
1112 /* The event doesn't arrive in the normal event loop. Send event
1113 here. */
1114 struct frame *f = user_data;
1115 struct input_event ie;
1117 EVENT_INIT (ie);
1118 ie.kind = DELETE_WINDOW_EVENT;
1119 XSETFRAME (ie.frame_or_window, f);
1120 kbd_buffer_store_event (&ie);
1121 #endif
1123 return TRUE;
1126 /* Create and set up the GTK widgets for frame F.
1127 Return true if creation succeeded. */
1129 bool
1130 xg_create_frame_widgets (struct frame *f)
1132 GtkWidget *wtop;
1133 GtkWidget *wvbox, *whbox;
1134 GtkWidget *wfixed;
1135 #ifndef HAVE_GTK3
1136 GtkRcStyle *style;
1137 #endif
1138 char *title = 0;
1140 block_input ();
1142 if (FRAME_X_EMBEDDED_P (f))
1144 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
1145 wtop = gtk_plug_new_for_display (gdpy, f->output_data.x->parent_desc);
1147 else
1148 wtop = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1150 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1151 has backported it to Gtk+ 2.0 and they add the resize grip for
1152 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1153 forever, so disable the grip. */
1154 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1155 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1156 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop), FALSE);
1157 #endif
1159 xg_set_screen (wtop, f);
1161 wvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1162 whbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1163 gtk_box_set_homogeneous (GTK_BOX (wvbox), FALSE);
1164 gtk_box_set_homogeneous (GTK_BOX (whbox), FALSE);
1166 #ifdef HAVE_GTK3
1167 wfixed = emacs_fixed_new (f);
1168 #else
1169 wfixed = gtk_fixed_new ();
1170 #endif
1172 if (! wtop || ! wvbox || ! whbox || ! wfixed)
1174 if (wtop) gtk_widget_destroy (wtop);
1175 if (wvbox) gtk_widget_destroy (wvbox);
1176 if (whbox) gtk_widget_destroy (whbox);
1177 if (wfixed) gtk_widget_destroy (wfixed);
1179 unblock_input ();
1180 return 0;
1183 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1184 gtk_widget_set_name (wtop, EMACS_CLASS);
1185 gtk_widget_set_name (wvbox, "pane");
1186 gtk_widget_set_name (wfixed, SSDATA (Vx_resource_name));
1188 /* If this frame has a title or name, set it in the title bar. */
1189 if (! NILP (f->title))
1190 title = SSDATA (ENCODE_UTF_8 (f->title));
1191 else if (! NILP (f->name))
1192 title = SSDATA (ENCODE_UTF_8 (f->name));
1194 if (title) gtk_window_set_title (GTK_WINDOW (wtop), title);
1196 FRAME_GTK_OUTER_WIDGET (f) = wtop;
1197 FRAME_GTK_WIDGET (f) = wfixed;
1198 f->output_data.x->vbox_widget = wvbox;
1199 f->output_data.x->hbox_widget = whbox;
1201 gtk_widget_set_has_window (wfixed, TRUE);
1203 gtk_container_add (GTK_CONTAINER (wtop), wvbox);
1204 gtk_box_pack_start (GTK_BOX (wvbox), whbox, TRUE, TRUE, 0);
1205 gtk_box_pack_start (GTK_BOX (whbox), wfixed, TRUE, TRUE, 0);
1207 if (FRAME_EXTERNAL_TOOL_BAR (f))
1208 update_frame_tool_bar (f);
1210 /* We don't want this widget double buffered, because we draw on it
1211 with regular X drawing primitives, so from a GTK/GDK point of
1212 view, the widget is totally blank. When an expose comes, this
1213 will make the widget blank, and then Emacs redraws it. This flickers
1214 a lot, so we turn off double buffering. */
1215 gtk_widget_set_double_buffered (wfixed, FALSE);
1217 gtk_window_set_wmclass (GTK_WINDOW (wtop),
1218 SSDATA (Vx_resource_name),
1219 SSDATA (Vx_resource_class));
1221 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1222 GTK is to destroy the widget. We want Emacs to do that instead. */
1223 g_signal_connect (G_OBJECT (wtop), "delete-event",
1224 G_CALLBACK (delete_cb), f);
1226 /* Convert our geometry parameters into a geometry string
1227 and specify it.
1228 GTK will itself handle calculating the real position this way. */
1229 xg_set_geometry (f);
1230 f->win_gravity
1231 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
1233 gtk_widget_add_events (wfixed,
1234 GDK_POINTER_MOTION_MASK
1235 | GDK_EXPOSURE_MASK
1236 | GDK_BUTTON_PRESS_MASK
1237 | GDK_BUTTON_RELEASE_MASK
1238 | GDK_KEY_PRESS_MASK
1239 | GDK_ENTER_NOTIFY_MASK
1240 | GDK_LEAVE_NOTIFY_MASK
1241 | GDK_FOCUS_CHANGE_MASK
1242 | GDK_STRUCTURE_MASK
1243 | GDK_VISIBILITY_NOTIFY_MASK);
1245 /* Must realize the windows so the X window gets created. It is used
1246 by callers of this function. */
1247 gtk_widget_realize (wfixed);
1248 FRAME_X_WINDOW (f) = GTK_WIDGET_TO_X_WIN (wfixed);
1250 /* Since GTK clears its window by filling with the background color,
1251 we must keep X and GTK background in sync. */
1252 xg_set_widget_bg (f, wfixed, FRAME_BACKGROUND_PIXEL (f));
1254 #ifndef HAVE_GTK3
1255 /* Also, do not let any background pixmap to be set, this looks very
1256 bad as Emacs overwrites the background pixmap with its own idea
1257 of background color. */
1258 style = gtk_widget_get_modifier_style (wfixed);
1260 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1261 style->bg_pixmap_name[GTK_STATE_NORMAL] = g_strdup ("<none>");
1262 gtk_widget_modify_style (wfixed, style);
1263 #else
1264 gtk_widget_set_can_focus (wfixed, TRUE);
1265 gtk_window_set_resizable (GTK_WINDOW (wtop), TRUE);
1266 #endif
1268 #ifdef USE_GTK_TOOLTIP
1269 /* Steal a tool tip window we can move ourselves. */
1270 f->output_data.x->ttip_widget = 0;
1271 f->output_data.x->ttip_lbl = 0;
1272 f->output_data.x->ttip_window = 0;
1273 gtk_widget_set_tooltip_text (wtop, "Dummy text");
1274 g_signal_connect (wtop, "query-tooltip", G_CALLBACK (qttip_cb), f);
1275 #endif
1278 GdkScreen *screen = gtk_widget_get_screen (wtop);
1279 GtkSettings *gs = gtk_settings_get_for_screen (screen);
1280 /* Only connect this signal once per screen. */
1281 if (! g_signal_handler_find (G_OBJECT (gs),
1282 G_SIGNAL_MATCH_FUNC,
1283 0, 0, 0,
1284 G_CALLBACK (style_changed_cb),
1287 g_signal_connect (G_OBJECT (gs), "notify::gtk-theme-name",
1288 G_CALLBACK (style_changed_cb),
1289 gdk_screen_get_display (screen));
1293 unblock_input ();
1295 return 1;
1298 void
1299 xg_free_frame_widgets (struct frame *f)
1301 if (FRAME_GTK_OUTER_WIDGET (f))
1303 #ifdef USE_GTK_TOOLTIP
1304 struct x_output *x = f->output_data.x;
1305 #endif
1306 struct xg_frame_tb_info *tbinfo
1307 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
1308 TB_INFO_KEY);
1309 if (tbinfo)
1310 xfree (tbinfo);
1312 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f));
1313 FRAME_X_WINDOW (f) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1314 FRAME_GTK_OUTER_WIDGET (f) = 0;
1315 #ifdef USE_GTK_TOOLTIP
1316 if (x->ttip_lbl)
1317 gtk_widget_destroy (x->ttip_lbl);
1318 if (x->ttip_widget)
1319 g_object_unref (G_OBJECT (x->ttip_widget));
1320 #endif
1324 /* Set the normal size hints for the window manager, for frame F.
1325 FLAGS is the flags word to use--or 0 meaning preserve the flags
1326 that the window now has.
1327 If USER_POSITION, set the User Position
1328 flag (this is useful when FLAGS is 0). */
1330 void
1331 x_wm_set_size_hint (struct frame *f, long int flags, bool user_position)
1333 /* Must use GTK routines here, otherwise GTK resets the size hints
1334 to its own defaults. */
1335 GdkGeometry size_hints;
1336 gint hint_flags = 0;
1337 int base_width, base_height;
1338 int min_rows = 0, min_cols = 0;
1339 int win_gravity = f->win_gravity;
1340 Lisp_Object fs_state, frame;
1342 /* Don't set size hints during initialization; that apparently leads
1343 to a race condition. See the thread at
1344 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1345 if (NILP (Vafter_init_time) || !FRAME_GTK_OUTER_WIDGET (f))
1346 return;
1348 XSETFRAME (frame, f);
1349 fs_state = Fframe_parameter (frame, Qfullscreen);
1350 if (EQ (fs_state, Qmaximized) || EQ (fs_state, Qfullboth))
1352 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1353 Gtk3 don't get along and the frame shrinks (!).
1355 return;
1358 if (flags)
1360 memset (&size_hints, 0, sizeof (size_hints));
1361 f->output_data.x->size_hints = size_hints;
1362 f->output_data.x->hint_flags = hint_flags;
1364 else
1365 flags = f->size_hint_flags;
1367 size_hints = f->output_data.x->size_hints;
1368 hint_flags = f->output_data.x->hint_flags;
1370 hint_flags |= GDK_HINT_RESIZE_INC | GDK_HINT_MIN_SIZE;
1371 size_hints.width_inc = FRAME_COLUMN_WIDTH (f);
1372 size_hints.height_inc = FRAME_LINE_HEIGHT (f);
1374 hint_flags |= GDK_HINT_BASE_SIZE;
1375 /* Use one row/col here so base_height/width does not become zero.
1376 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1377 base_width = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 1) + FRAME_TOOLBAR_WIDTH (f);
1378 base_height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 1)
1379 + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f);
1381 check_frame_size (f, &min_rows, &min_cols);
1382 if (min_cols > 0) --min_cols; /* We used one col in base_width = ... 1); */
1383 if (min_rows > 0) --min_rows; /* We used one row in base_height = ... 1); */
1385 size_hints.base_width = base_width;
1386 size_hints.base_height = base_height;
1387 size_hints.min_width = base_width + min_cols * size_hints.width_inc;
1388 size_hints.min_height = base_height + min_rows * size_hints.height_inc;
1390 /* These currently have a one to one mapping with the X values, but I
1391 don't think we should rely on that. */
1392 hint_flags |= GDK_HINT_WIN_GRAVITY;
1393 size_hints.win_gravity = 0;
1394 if (win_gravity == NorthWestGravity)
1395 size_hints.win_gravity = GDK_GRAVITY_NORTH_WEST;
1396 else if (win_gravity == NorthGravity)
1397 size_hints.win_gravity = GDK_GRAVITY_NORTH;
1398 else if (win_gravity == NorthEastGravity)
1399 size_hints.win_gravity = GDK_GRAVITY_NORTH_EAST;
1400 else if (win_gravity == WestGravity)
1401 size_hints.win_gravity = GDK_GRAVITY_WEST;
1402 else if (win_gravity == CenterGravity)
1403 size_hints.win_gravity = GDK_GRAVITY_CENTER;
1404 else if (win_gravity == EastGravity)
1405 size_hints.win_gravity = GDK_GRAVITY_EAST;
1406 else if (win_gravity == SouthWestGravity)
1407 size_hints.win_gravity = GDK_GRAVITY_SOUTH_WEST;
1408 else if (win_gravity == SouthGravity)
1409 size_hints.win_gravity = GDK_GRAVITY_SOUTH;
1410 else if (win_gravity == SouthEastGravity)
1411 size_hints.win_gravity = GDK_GRAVITY_SOUTH_EAST;
1412 else if (win_gravity == StaticGravity)
1413 size_hints.win_gravity = GDK_GRAVITY_STATIC;
1415 if (user_position)
1417 hint_flags &= ~GDK_HINT_POS;
1418 hint_flags |= GDK_HINT_USER_POS;
1421 if (hint_flags != f->output_data.x->hint_flags
1422 || memcmp (&size_hints,
1423 &f->output_data.x->size_hints,
1424 sizeof (size_hints)) != 0)
1426 block_input ();
1427 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
1428 NULL, &size_hints, hint_flags);
1429 f->output_data.x->size_hints = size_hints;
1430 f->output_data.x->hint_flags = hint_flags;
1431 unblock_input ();
1435 /* Change background color of a frame.
1436 Since GTK uses the background color to clear the window, we must
1437 keep the GTK and X colors in sync.
1438 F is the frame to change,
1439 BG is the pixel value to change to. */
1441 void
1442 xg_set_background_color (struct frame *f, long unsigned int bg)
1444 if (FRAME_GTK_WIDGET (f))
1446 block_input ();
1447 xg_set_widget_bg (f, FRAME_GTK_WIDGET (f), FRAME_BACKGROUND_PIXEL (f));
1448 unblock_input ();
1453 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1454 functions so GTK does not overwrite the icon. */
1456 void
1457 xg_set_frame_icon (struct frame *f, Pixmap icon_pixmap, Pixmap icon_mask)
1459 GdkPixbuf *gp = xg_get_pixbuf_from_pix_and_mask (f,
1460 icon_pixmap,
1461 icon_mask);
1462 if (gp)
1463 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)), gp);
1468 /***********************************************************************
1469 Dialog functions
1470 ***********************************************************************/
1471 /* Return the dialog title to use for a dialog of type KEY.
1472 This is the encoding used by lwlib. We use the same for GTK. */
1474 static const char *
1475 get_dialog_title (char key)
1477 const char *title = "";
1479 switch (key) {
1480 case 'E': case 'e':
1481 title = "Error";
1482 break;
1484 case 'I': case 'i':
1485 title = "Information";
1486 break;
1488 case 'L': case 'l':
1489 title = "Prompt";
1490 break;
1492 case 'P': case 'p':
1493 title = "Prompt";
1494 break;
1496 case 'Q': case 'q':
1497 title = "Question";
1498 break;
1501 return title;
1504 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1505 the dialog, but return TRUE so the event does not propagate further
1506 in GTK. This prevents GTK from destroying the dialog widget automatically
1507 and we can always destroy the widget manually, regardless of how
1508 it was popped down (button press or WM_DELETE_WINDOW).
1509 W is the dialog widget.
1510 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1511 user_data is NULL (not used).
1513 Returns TRUE to end propagation of event. */
1515 static gboolean
1516 dialog_delete_callback (GtkWidget *w, GdkEvent *event, gpointer user_data)
1518 gtk_widget_unmap (w);
1519 return TRUE;
1522 /* Create a popup dialog window. See also xg_create_widget below.
1523 WV is a widget_value describing the dialog.
1524 SELECT_CB is the callback to use when a button has been pressed.
1525 DEACTIVATE_CB is the callback to use when the dialog pops down.
1527 Returns the GTK dialog widget. */
1529 static GtkWidget *
1530 create_dialog (widget_value *wv,
1531 GCallback select_cb,
1532 GCallback deactivate_cb)
1534 const char *title = get_dialog_title (wv->name[0]);
1535 int total_buttons = wv->name[1] - '0';
1536 int right_buttons = wv->name[4] - '0';
1537 int left_buttons;
1538 int button_nr = 0;
1539 int button_spacing = 10;
1540 GtkWidget *wdialog = gtk_dialog_new ();
1541 GtkDialog *wd = GTK_DIALOG (wdialog);
1542 GtkBox *cur_box = GTK_BOX (gtk_dialog_get_action_area (wd));
1543 widget_value *item;
1544 GtkWidget *whbox_down;
1546 /* If the number of buttons is greater than 4, make two rows of buttons
1547 instead. This looks better. */
1548 bool make_two_rows = total_buttons > 4;
1550 if (right_buttons == 0) right_buttons = total_buttons/2;
1551 left_buttons = total_buttons - right_buttons;
1553 gtk_window_set_title (GTK_WINDOW (wdialog), title);
1554 gtk_widget_set_name (wdialog, "emacs-dialog");
1557 if (make_two_rows)
1559 GtkWidget *wvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, button_spacing);
1560 GtkWidget *whbox_up = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1561 gtk_box_set_homogeneous (GTK_BOX (wvbox), TRUE);
1562 gtk_box_set_homogeneous (GTK_BOX (whbox_up), FALSE);
1563 whbox_down = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1564 gtk_box_set_homogeneous (GTK_BOX (whbox_down), FALSE);
1566 gtk_box_pack_start (cur_box, wvbox, FALSE, FALSE, 0);
1567 gtk_box_pack_start (GTK_BOX (wvbox), whbox_up, FALSE, FALSE, 0);
1568 gtk_box_pack_start (GTK_BOX (wvbox), whbox_down, FALSE, FALSE, 0);
1570 cur_box = GTK_BOX (whbox_up);
1573 g_signal_connect (G_OBJECT (wdialog), "delete-event",
1574 G_CALLBACK (dialog_delete_callback), 0);
1576 if (deactivate_cb)
1578 g_signal_connect (G_OBJECT (wdialog), "close", deactivate_cb, 0);
1579 g_signal_connect (G_OBJECT (wdialog), "response", deactivate_cb, 0);
1582 for (item = wv->contents; item; item = item->next)
1584 char *utf8_label = get_utf8_string (item->value);
1585 GtkWidget *w;
1586 GtkRequisition req;
1588 if (item->name && strcmp (item->name, "message") == 0)
1590 GtkBox *wvbox = GTK_BOX (gtk_dialog_get_content_area (wd));
1591 /* This is the text part of the dialog. */
1592 w = gtk_label_new (utf8_label);
1593 gtk_box_pack_start (wvbox, gtk_label_new (""), FALSE, FALSE, 0);
1594 gtk_box_pack_start (wvbox, w, TRUE, TRUE, 0);
1595 gtk_misc_set_alignment (GTK_MISC (w), 0.1, 0.5);
1597 /* Try to make dialog look better. Must realize first so
1598 the widget can calculate the size it needs. */
1599 gtk_widget_realize (w);
1600 gtk_widget_get_preferred_size (w, NULL, &req);
1601 gtk_box_set_spacing (wvbox, req.height);
1602 if (item->value && strlen (item->value) > 0)
1603 button_spacing = 2*req.width/strlen (item->value);
1605 else
1607 /* This is one button to add to the dialog. */
1608 w = gtk_button_new_with_label (utf8_label);
1609 if (! item->enabled)
1610 gtk_widget_set_sensitive (w, FALSE);
1611 if (select_cb)
1612 g_signal_connect (G_OBJECT (w), "clicked",
1613 select_cb, item->call_data);
1615 gtk_box_pack_start (cur_box, w, TRUE, TRUE, button_spacing);
1616 if (++button_nr == left_buttons)
1618 if (make_two_rows)
1619 cur_box = GTK_BOX (whbox_down);
1620 else
1621 gtk_box_pack_start (cur_box,
1622 gtk_label_new (""),
1623 TRUE, TRUE,
1624 button_spacing);
1628 if (utf8_label)
1629 g_free (utf8_label);
1632 return wdialog;
1635 struct xg_dialog_data
1637 GMainLoop *loop;
1638 int response;
1639 GtkWidget *w;
1640 guint timerid;
1643 /* Function that is called when the file or font dialogs pop down.
1644 W is the dialog widget, RESPONSE is the response code.
1645 USER_DATA is what we passed in to g_signal_connect. */
1647 static void
1648 xg_dialog_response_cb (GtkDialog *w,
1649 gint response,
1650 gpointer user_data)
1652 struct xg_dialog_data *dd = user_data;
1653 dd->response = response;
1654 g_main_loop_quit (dd->loop);
1658 /* Destroy the dialog. This makes it pop down. */
1660 static void
1661 pop_down_dialog (void *arg)
1663 struct xg_dialog_data *dd = arg;
1665 block_input ();
1666 if (dd->w) gtk_widget_destroy (dd->w);
1667 if (dd->timerid != 0) g_source_remove (dd->timerid);
1669 g_main_loop_quit (dd->loop);
1670 g_main_loop_unref (dd->loop);
1672 unblock_input ();
1675 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1676 We pass in DATA as gpointer* so we can use this as a callback. */
1678 static gboolean
1679 xg_maybe_add_timer (gpointer data)
1681 struct xg_dialog_data *dd = data;
1682 struct timespec next_time = timer_check ();
1684 dd->timerid = 0;
1686 if (timespec_valid_p (next_time))
1688 time_t s = next_time.tv_sec;
1689 int per_ms = TIMESPEC_RESOLUTION / 1000;
1690 int ms = (next_time.tv_nsec + per_ms - 1) / per_ms;
1691 if (s <= ((guint) -1 - ms) / 1000)
1692 dd->timerid = g_timeout_add (s * 1000 + ms, xg_maybe_add_timer, dd);
1694 return FALSE;
1698 /* Pops up a modal dialog W and waits for response.
1699 We don't use gtk_dialog_run because we want to process emacs timers.
1700 The dialog W is not destroyed when this function returns. */
1702 static int
1703 xg_dialog_run (struct frame *f, GtkWidget *w)
1705 ptrdiff_t count = SPECPDL_INDEX ();
1706 struct xg_dialog_data dd;
1708 xg_set_screen (w, f);
1709 gtk_window_set_transient_for (GTK_WINDOW (w),
1710 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
1711 gtk_window_set_destroy_with_parent (GTK_WINDOW (w), TRUE);
1712 gtk_window_set_modal (GTK_WINDOW (w), TRUE);
1714 dd.loop = g_main_loop_new (NULL, FALSE);
1715 dd.response = GTK_RESPONSE_CANCEL;
1716 dd.w = w;
1717 dd.timerid = 0;
1719 g_signal_connect (G_OBJECT (w),
1720 "response",
1721 G_CALLBACK (xg_dialog_response_cb),
1722 &dd);
1723 /* Don't destroy the widget if closed by the window manager close button. */
1724 g_signal_connect (G_OBJECT (w), "delete-event", G_CALLBACK (gtk_true), NULL);
1725 gtk_widget_show (w);
1727 record_unwind_protect_ptr (pop_down_dialog, &dd);
1729 (void) xg_maybe_add_timer (&dd);
1730 g_main_loop_run (dd.loop);
1732 dd.w = 0;
1733 unbind_to (count, Qnil);
1735 return dd.response;
1739 /***********************************************************************
1740 File dialog functions
1741 ***********************************************************************/
1742 /* Return true if the old file selection dialog is being used. */
1744 bool
1745 xg_uses_old_file_dialog (void)
1747 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1748 return x_gtk_use_old_file_dialog;
1749 #else
1750 return 0;
1751 #endif
1755 typedef char * (*xg_get_file_func) (GtkWidget *);
1757 /* Return the selected file for file chooser dialog W.
1758 The returned string must be free:d. */
1760 static char *
1761 xg_get_file_name_from_chooser (GtkWidget *w)
1763 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w));
1766 /* Callback called when the "Show hidden files" toggle is pressed.
1767 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1769 static void
1770 xg_toggle_visibility_cb (GtkWidget *widget, gpointer data)
1772 GtkFileChooser *dialog = GTK_FILE_CHOOSER (data);
1773 gboolean visible;
1774 g_object_get (G_OBJECT (dialog), "show-hidden", &visible, NULL);
1775 g_object_set (G_OBJECT (dialog), "show-hidden", !visible, NULL);
1779 /* Callback called when a property changes in a file chooser.
1780 GOBJECT is the file chooser dialog, ARG1 describes the property.
1781 USER_DATA is the toggle widget in the file chooser dialog.
1782 We use this to update the "Show hidden files" toggle when the user
1783 changes that property by right clicking in the file list. */
1785 static void
1786 xg_toggle_notify_cb (GObject *gobject, GParamSpec *arg1, gpointer user_data)
1788 if (strcmp (arg1->name, "show-hidden") == 0)
1790 GtkWidget *wtoggle = GTK_WIDGET (user_data);
1791 gboolean visible, toggle_on;
1793 g_object_get (G_OBJECT (gobject), "show-hidden", &visible, NULL);
1794 toggle_on = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle));
1796 if (!!visible != !!toggle_on)
1798 g_signal_handlers_block_by_func (G_OBJECT (wtoggle),
1799 G_CALLBACK (xg_toggle_visibility_cb),
1800 gobject);
1801 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle), visible);
1802 g_signal_handlers_unblock_by_func
1803 (G_OBJECT (wtoggle),
1804 G_CALLBACK (xg_toggle_visibility_cb),
1805 gobject);
1807 x_gtk_show_hidden_files = visible;
1811 /* Read a file name from the user using a file chooser dialog.
1812 F is the current frame.
1813 PROMPT is a prompt to show to the user. May not be NULL.
1814 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1815 If MUSTMATCH_P, the returned file name must be an existing
1816 file. (Actually, this only has cosmetic effects, the user can
1817 still enter a non-existing file.) *FUNC is set to a function that
1818 can be used to retrieve the selected file name from the returned widget.
1820 Returns the created widget. */
1822 static GtkWidget *
1823 xg_get_file_with_chooser (struct frame *f,
1824 char *prompt,
1825 char *default_filename,
1826 bool mustmatch_p, bool only_dir_p,
1827 xg_get_file_func *func)
1829 char msgbuf[1024];
1831 GtkWidget *filewin, *wtoggle, *wbox, *wmessage IF_LINT (= NULL);
1832 GtkWindow *gwin = GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f));
1833 GtkFileChooserAction action = (mustmatch_p ?
1834 GTK_FILE_CHOOSER_ACTION_OPEN :
1835 GTK_FILE_CHOOSER_ACTION_SAVE);
1837 if (only_dir_p)
1838 action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
1840 filewin = gtk_file_chooser_dialog_new (prompt, gwin, action,
1841 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1842 (mustmatch_p || only_dir_p ?
1843 GTK_STOCK_OPEN : GTK_STOCK_OK),
1844 GTK_RESPONSE_OK,
1845 NULL);
1846 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin), TRUE);
1848 wbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1849 gtk_box_set_homogeneous (GTK_BOX (wbox), FALSE);
1850 gtk_widget_show (wbox);
1851 wtoggle = gtk_check_button_new_with_label ("Show hidden files.");
1853 if (x_gtk_show_hidden_files)
1855 g_object_set (G_OBJECT (filewin), "show-hidden", TRUE, NULL);
1856 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle), TRUE);
1858 gtk_widget_show (wtoggle);
1859 g_signal_connect (G_OBJECT (wtoggle), "clicked",
1860 G_CALLBACK (xg_toggle_visibility_cb), filewin);
1861 g_signal_connect (G_OBJECT (filewin), "notify",
1862 G_CALLBACK (xg_toggle_notify_cb), wtoggle);
1864 if (x_gtk_file_dialog_help_text)
1866 msgbuf[0] = '\0';
1867 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1868 Show the C-l help text only for versions < 2.10. */
1869 if (gtk_check_version (2, 10, 0) && action != GTK_FILE_CHOOSER_ACTION_SAVE)
1870 strcat (msgbuf, "\nType C-l to display a file name text entry box.\n");
1871 strcat (msgbuf, "\nIf you don't like this file selector, use the "
1872 "corresponding\nkey binding or customize "
1873 "use-file-dialog to turn it off.");
1875 wmessage = gtk_label_new (msgbuf);
1876 gtk_widget_show (wmessage);
1879 gtk_box_pack_start (GTK_BOX (wbox), wtoggle, FALSE, FALSE, 0);
1880 if (x_gtk_file_dialog_help_text)
1881 gtk_box_pack_start (GTK_BOX (wbox), wmessage, FALSE, FALSE, 0);
1882 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin), wbox);
1884 if (default_filename)
1886 Lisp_Object file;
1887 struct gcpro gcpro1;
1888 char *utf8_filename;
1889 GCPRO1 (file);
1891 file = build_string (default_filename);
1893 /* File chooser does not understand ~/... in the file name. It must be
1894 an absolute name starting with /. */
1895 if (default_filename[0] != '/')
1896 file = Fexpand_file_name (file, Qnil);
1898 utf8_filename = SSDATA (ENCODE_UTF_8 (file));
1899 if (! NILP (Ffile_directory_p (file)))
1900 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin),
1901 utf8_filename);
1902 else
1904 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin),
1905 utf8_filename);
1906 if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
1908 char *cp = strrchr (utf8_filename, '/');
1909 if (cp) ++cp;
1910 else cp = utf8_filename;
1911 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin), cp);
1915 UNGCPRO;
1918 *func = xg_get_file_name_from_chooser;
1919 return filewin;
1922 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1924 /* Return the selected file for file selector dialog W.
1925 The returned string must be free:d. */
1927 static char *
1928 xg_get_file_name_from_selector (GtkWidget *w)
1930 GtkFileSelection *filesel = GTK_FILE_SELECTION (w);
1931 return xstrdup (gtk_file_selection_get_filename (filesel));
1934 /* Create a file selection dialog.
1935 F is the current frame.
1936 PROMPT is a prompt to show to the user. May not be NULL.
1937 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1938 If MUSTMATCH_P, the returned file name must be an existing
1939 file. *FUNC is set to a function that can be used to retrieve the
1940 selected file name from the returned widget.
1942 Returns the created widget. */
1944 static GtkWidget *
1945 xg_get_file_with_selection (struct frame *f,
1946 char *prompt,
1947 char *default_filename,
1948 bool mustmatch_p, bool only_dir_p,
1949 xg_get_file_func *func)
1951 GtkWidget *filewin;
1952 GtkFileSelection *filesel;
1954 filewin = gtk_file_selection_new (prompt);
1955 filesel = GTK_FILE_SELECTION (filewin);
1957 if (default_filename)
1958 gtk_file_selection_set_filename (filesel, default_filename);
1960 if (mustmatch_p)
1962 /* The selection_entry part of filesel is not documented. */
1963 gtk_widget_set_sensitive (filesel->selection_entry, FALSE);
1964 gtk_file_selection_hide_fileop_buttons (filesel);
1967 *func = xg_get_file_name_from_selector;
1969 return filewin;
1971 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1973 /* Read a file name from the user using a file dialog, either the old
1974 file selection dialog, or the new file chooser dialog. Which to use
1975 depends on what the GTK version used has, and what the value of
1976 gtk-use-old-file-dialog.
1977 F is the current frame.
1978 PROMPT is a prompt to show to the user. May not be NULL.
1979 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1980 If MUSTMATCH_P, the returned file name must be an existing
1981 file.
1983 Returns a file name or NULL if no file was selected.
1984 The returned string must be freed by the caller. */
1986 char *
1987 xg_get_file_name (struct frame *f,
1988 char *prompt,
1989 char *default_filename,
1990 bool mustmatch_p,
1991 bool only_dir_p)
1993 GtkWidget *w = 0;
1994 char *fn = 0;
1995 int filesel_done = 0;
1996 xg_get_file_func func;
1998 #ifdef HAVE_GTK_FILE_SELECTION_NEW
2000 if (xg_uses_old_file_dialog ())
2001 w = xg_get_file_with_selection (f, prompt, default_filename,
2002 mustmatch_p, only_dir_p, &func);
2003 else
2004 w = xg_get_file_with_chooser (f, prompt, default_filename,
2005 mustmatch_p, only_dir_p, &func);
2007 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
2008 w = xg_get_file_with_chooser (f, prompt, default_filename,
2009 mustmatch_p, only_dir_p, &func);
2010 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
2012 gtk_widget_set_name (w, "emacs-filedialog");
2014 filesel_done = xg_dialog_run (f, w);
2015 if (filesel_done == GTK_RESPONSE_OK)
2016 fn = (*func) (w);
2018 gtk_widget_destroy (w);
2019 return fn;
2022 /***********************************************************************
2023 GTK font chooser
2024 ***********************************************************************/
2026 #ifdef HAVE_FREETYPE
2028 #if USE_NEW_GTK_FONT_CHOOSER
2030 #define XG_WEIGHT_TO_SYMBOL(w) \
2031 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
2032 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
2033 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
2034 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
2035 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
2036 : w <= PANGO_WEIGHT_BOLD ? Qbold \
2037 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
2038 : Qultra_bold)
2040 #define XG_STYLE_TO_SYMBOL(s) \
2041 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
2042 : s == PANGO_STYLE_ITALIC ? Qitalic \
2043 : Qnormal)
2045 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2048 static char *x_last_font_name;
2050 /* Pop up a GTK font selector and return the name of the font the user
2051 selects, as a C string. The returned font name follows GTK's own
2052 format:
2054 `FAMILY [VALUE1 VALUE2] SIZE'
2056 This can be parsed using font_parse_fcname in font.c.
2057 DEFAULT_NAME, if non-zero, is the default font name. */
2059 Lisp_Object
2060 xg_get_font (struct frame *f, const char *default_name)
2062 GtkWidget *w;
2063 int done = 0;
2064 Lisp_Object font = Qnil;
2066 w = gtk_font_chooser_dialog_new
2067 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
2069 if (default_name)
2071 /* Convert fontconfig names to Gtk names, i.e. remove - before
2072 number */
2073 char *p = strrchr (default_name, '-');
2074 if (p)
2076 char *ep = p+1;
2077 while (c_isdigit (*ep))
2078 ++ep;
2079 if (*ep == '\0') *p = ' ';
2082 else if (x_last_font_name)
2083 default_name = x_last_font_name;
2085 if (default_name)
2086 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w), default_name);
2088 gtk_widget_set_name (w, "emacs-fontdialog");
2089 done = xg_dialog_run (f, w);
2090 if (done == GTK_RESPONSE_OK)
2092 #if USE_NEW_GTK_FONT_CHOOSER
2093 /* Use the GTK3 font chooser. */
2094 PangoFontDescription *desc
2095 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w));
2097 if (desc)
2099 Lisp_Object args[10];
2100 const char *name = pango_font_description_get_family (desc);
2101 gint size = pango_font_description_get_size (desc);
2102 PangoWeight weight = pango_font_description_get_weight (desc);
2103 PangoStyle style = pango_font_description_get_style (desc);
2105 args[0] = QCname;
2106 args[1] = build_string (name);
2108 args[2] = QCsize;
2109 args[3] = make_float (pango_units_to_double (size));
2111 args[4] = QCweight;
2112 args[5] = XG_WEIGHT_TO_SYMBOL (weight);
2114 args[6] = QCslant;
2115 args[7] = XG_STYLE_TO_SYMBOL (style);
2117 args[8] = QCtype;
2118 args[9] = Qxft;
2120 font = Ffont_spec (8, args);
2122 pango_font_description_free (desc);
2123 xfree (x_last_font_name);
2124 x_last_font_name = xstrdup (name);
2127 #else /* Use old font selector, which just returns the font name. */
2129 char *font_name
2130 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w));
2132 if (font_name)
2134 font = build_string (font_name);
2135 g_free (x_last_font_name);
2136 x_last_font_name = font_name;
2138 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2141 gtk_widget_destroy (w);
2142 return font;
2144 #endif /* HAVE_FREETYPE */
2148 /***********************************************************************
2149 Menu functions.
2150 ***********************************************************************/
2152 /* The name of menu items that can be used for customization. Since GTK
2153 RC files are very crude and primitive, we have to set this on all
2154 menu item names so a user can easily customize menu items. */
2156 #define MENU_ITEM_NAME "emacs-menuitem"
2159 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2160 during GC. The next member points to the items. */
2161 static xg_list_node xg_menu_cb_list;
2163 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2164 during GC. The next member points to the items. */
2165 static xg_list_node xg_menu_item_cb_list;
2167 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2168 F is the frame CL_DATA will be initialized for.
2169 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2171 The menu bar and all sub menus under the menu bar in a frame
2172 share the same structure, hence the reference count.
2174 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2175 allocated xg_menu_cb_data if CL_DATA is NULL. */
2177 static xg_menu_cb_data *
2178 make_cl_data (xg_menu_cb_data *cl_data, struct frame *f, GCallback highlight_cb)
2180 if (! cl_data)
2182 cl_data = xmalloc (sizeof *cl_data);
2183 cl_data->f = f;
2184 cl_data->menu_bar_vector = f->menu_bar_vector;
2185 cl_data->menu_bar_items_used = f->menu_bar_items_used;
2186 cl_data->highlight_cb = highlight_cb;
2187 cl_data->ref_count = 0;
2189 xg_list_insert (&xg_menu_cb_list, &cl_data->ptrs);
2192 cl_data->ref_count++;
2194 return cl_data;
2197 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2198 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2200 When the menu bar is updated, menu items may have been added and/or
2201 removed, so menu_bar_vector and menu_bar_items_used change. We must
2202 then update CL_DATA since it is used to determine which menu
2203 item that is invoked in the menu.
2204 HIGHLIGHT_CB could change, there is no check that the same
2205 function is given when modifying a menu bar as was given when
2206 creating the menu bar. */
2208 static void
2209 update_cl_data (xg_menu_cb_data *cl_data,
2210 struct frame *f,
2211 GCallback highlight_cb)
2213 if (cl_data)
2215 cl_data->f = f;
2216 cl_data->menu_bar_vector = f->menu_bar_vector;
2217 cl_data->menu_bar_items_used = f->menu_bar_items_used;
2218 cl_data->highlight_cb = highlight_cb;
2222 /* Decrease reference count for CL_DATA.
2223 If reference count is zero, free CL_DATA. */
2225 static void
2226 unref_cl_data (xg_menu_cb_data *cl_data)
2228 if (cl_data && cl_data->ref_count > 0)
2230 cl_data->ref_count--;
2231 if (cl_data->ref_count == 0)
2233 xg_list_remove (&xg_menu_cb_list, &cl_data->ptrs);
2234 xfree (cl_data);
2239 /* Function that marks all lisp data during GC. */
2241 void
2242 xg_mark_data (void)
2244 xg_list_node *iter;
2245 Lisp_Object rest, frame;
2247 for (iter = xg_menu_cb_list.next; iter; iter = iter->next)
2248 mark_object (((xg_menu_cb_data *) iter)->menu_bar_vector);
2250 for (iter = xg_menu_item_cb_list.next; iter; iter = iter->next)
2252 xg_menu_item_cb_data *cb_data = (xg_menu_item_cb_data *) iter;
2254 if (! NILP (cb_data->help))
2255 mark_object (cb_data->help);
2258 FOR_EACH_FRAME (rest, frame)
2260 struct frame *f = XFRAME (frame);
2262 if (FRAME_X_P (f) && FRAME_GTK_OUTER_WIDGET (f))
2264 struct xg_frame_tb_info *tbinfo
2265 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
2266 TB_INFO_KEY);
2267 if (tbinfo)
2269 mark_object (tbinfo->last_tool_bar);
2270 mark_object (tbinfo->style);
2277 /* Callback called when a menu item is destroyed. Used to free data.
2278 W is the widget that is being destroyed (not used).
2279 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2281 static void
2282 menuitem_destroy_callback (GtkWidget *w, gpointer client_data)
2284 if (client_data)
2286 xg_menu_item_cb_data *data = client_data;
2287 xg_list_remove (&xg_menu_item_cb_list, &data->ptrs);
2288 xfree (data);
2292 /* Callback called when the pointer enters/leaves a menu item.
2293 W is the parent of the menu item.
2294 EVENT is either an enter event or leave event.
2295 CLIENT_DATA is not used.
2297 Returns FALSE to tell GTK to keep processing this event. */
2299 static gboolean
2300 menuitem_highlight_callback (GtkWidget *w,
2301 GdkEventCrossing *event,
2302 gpointer client_data)
2304 GdkEvent ev;
2305 GtkWidget *subwidget;
2306 xg_menu_item_cb_data *data;
2308 ev.crossing = *event;
2309 subwidget = gtk_get_event_widget (&ev);
2310 data = g_object_get_data (G_OBJECT (subwidget), XG_ITEM_DATA);
2311 if (data)
2313 if (! NILP (data->help) && data->cl_data->highlight_cb)
2315 gpointer call_data = event->type == GDK_LEAVE_NOTIFY ? 0 : data;
2316 GtkCallback func = (GtkCallback) data->cl_data->highlight_cb;
2317 (*func) (subwidget, call_data);
2321 return FALSE;
2324 /* Callback called when a menu is destroyed. Used to free data.
2325 W is the widget that is being destroyed (not used).
2326 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2328 static void
2329 menu_destroy_callback (GtkWidget *w, gpointer client_data)
2331 unref_cl_data (client_data);
2334 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2335 must be non-NULL) and can be inserted into a menu item.
2337 Returns the GtkHBox. */
2339 static GtkWidget *
2340 make_widget_for_menu_item (const char *utf8_label, const char *utf8_key)
2342 GtkWidget *wlbl;
2343 GtkWidget *wkey;
2344 GtkWidget *wbox;
2346 wbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2347 gtk_box_set_homogeneous (GTK_BOX (wbox), FALSE);
2348 wlbl = gtk_label_new (utf8_label);
2349 wkey = gtk_label_new (utf8_key);
2351 gtk_misc_set_alignment (GTK_MISC (wlbl), 0.0, 0.5);
2352 gtk_misc_set_alignment (GTK_MISC (wkey), 0.0, 0.5);
2354 gtk_box_pack_start (GTK_BOX (wbox), wlbl, TRUE, TRUE, 0);
2355 gtk_box_pack_start (GTK_BOX (wbox), wkey, FALSE, FALSE, 0);
2357 gtk_widget_set_name (wlbl, MENU_ITEM_NAME);
2358 gtk_widget_set_name (wkey, MENU_ITEM_NAME);
2359 gtk_widget_set_name (wbox, MENU_ITEM_NAME);
2361 return wbox;
2364 /* Make and return a menu item widget with the key to the right.
2365 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2366 UTF8_KEY is the text representing the key binding.
2367 ITEM is the widget_value describing the menu item.
2369 GROUP is an in/out parameter. If the menu item to be created is not
2370 part of any radio menu group, *GROUP contains NULL on entry and exit.
2371 If the menu item to be created is part of a radio menu group, on entry
2372 *GROUP contains the group to use, or NULL if this is the first item
2373 in the group. On exit, *GROUP contains the radio item group.
2375 Unfortunately, keys don't line up as nicely as in Motif,
2376 but the MacOS X version doesn't either, so I guess that is OK. */
2378 static GtkWidget *
2379 make_menu_item (const char *utf8_label,
2380 const char *utf8_key,
2381 widget_value *item,
2382 GSList **group)
2384 GtkWidget *w;
2385 GtkWidget *wtoadd = 0;
2387 /* It has been observed that some menu items have a NULL name field.
2388 This will lead to this function being called with a NULL utf8_label.
2389 GTK crashes on that so we set a blank label. Why there is a NULL
2390 name remains to be investigated. */
2391 if (! utf8_label) utf8_label = " ";
2393 if (utf8_key)
2394 wtoadd = make_widget_for_menu_item (utf8_label, utf8_key);
2396 if (item->button_type == BUTTON_TYPE_TOGGLE)
2398 *group = NULL;
2399 if (utf8_key) w = gtk_check_menu_item_new ();
2400 else w = gtk_check_menu_item_new_with_label (utf8_label);
2401 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), item->selected);
2403 else if (item->button_type == BUTTON_TYPE_RADIO)
2405 if (utf8_key) w = gtk_radio_menu_item_new (*group);
2406 else w = gtk_radio_menu_item_new_with_label (*group, utf8_label);
2407 *group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w));
2408 if (item->selected)
2409 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), TRUE);
2411 else
2413 *group = NULL;
2414 if (utf8_key) w = gtk_menu_item_new ();
2415 else w = gtk_menu_item_new_with_label (utf8_label);
2418 if (wtoadd) gtk_container_add (GTK_CONTAINER (w), wtoadd);
2419 if (! item->enabled) gtk_widget_set_sensitive (w, FALSE);
2421 return w;
2424 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2426 static int xg_detached_menus;
2428 /* Return true if there are detached menus. */
2430 bool
2431 xg_have_tear_offs (void)
2433 return xg_detached_menus > 0;
2436 /* Callback invoked when a detached menu window is removed. Here we
2437 decrease the xg_detached_menus count.
2438 WIDGET is the top level window that is removed (the parent of the menu).
2439 CLIENT_DATA is not used. */
2441 static void
2442 tearoff_remove (GtkWidget *widget, gpointer client_data)
2444 if (xg_detached_menus > 0) --xg_detached_menus;
2447 /* Callback invoked when a menu is detached. It increases the
2448 xg_detached_menus count.
2449 WIDGET is the GtkTearoffMenuItem.
2450 CLIENT_DATA is not used. */
2452 static void
2453 tearoff_activate (GtkWidget *widget, gpointer client_data)
2455 GtkWidget *menu = gtk_widget_get_parent (widget);
2456 if (gtk_menu_get_tearoff_state (GTK_MENU (menu)))
2458 ++xg_detached_menus;
2459 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget)),
2460 "destroy",
2461 G_CALLBACK (tearoff_remove), 0);
2464 #else /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2465 bool
2466 xg_have_tear_offs (void)
2468 return false;
2470 #endif /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2472 /* Create a menu item widget, and connect the callbacks.
2473 ITEM describes the menu item.
2474 F is the frame the created menu belongs to.
2475 SELECT_CB is the callback to use when a menu item is selected.
2476 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2477 CL_DATA points to the callback data to be used for this menu.
2478 GROUP is an in/out parameter. If the menu item to be created is not
2479 part of any radio menu group, *GROUP contains NULL on entry and exit.
2480 If the menu item to be created is part of a radio menu group, on entry
2481 *GROUP contains the group to use, or NULL if this is the first item
2482 in the group. On exit, *GROUP contains the radio item group.
2484 Returns the created GtkWidget. */
2486 static GtkWidget *
2487 xg_create_one_menuitem (widget_value *item,
2488 struct frame *f,
2489 GCallback select_cb,
2490 GCallback highlight_cb,
2491 xg_menu_cb_data *cl_data,
2492 GSList **group)
2494 char *utf8_label;
2495 char *utf8_key;
2496 GtkWidget *w;
2497 xg_menu_item_cb_data *cb_data;
2499 utf8_label = get_utf8_string (item->name);
2500 utf8_key = get_utf8_string (item->key);
2502 w = make_menu_item (utf8_label, utf8_key, item, group);
2504 if (utf8_label) g_free (utf8_label);
2505 if (utf8_key) g_free (utf8_key);
2507 cb_data = xmalloc (sizeof *cb_data);
2509 xg_list_insert (&xg_menu_item_cb_list, &cb_data->ptrs);
2511 cb_data->select_id = 0;
2512 cb_data->help = item->help;
2513 cb_data->cl_data = cl_data;
2514 cb_data->call_data = item->call_data;
2516 g_signal_connect (G_OBJECT (w),
2517 "destroy",
2518 G_CALLBACK (menuitem_destroy_callback),
2519 cb_data);
2521 /* Put cb_data in widget, so we can get at it when modifying menubar */
2522 g_object_set_data (G_OBJECT (w), XG_ITEM_DATA, cb_data);
2524 /* final item, not a submenu */
2525 if (item->call_data && ! item->contents)
2527 if (select_cb)
2528 cb_data->select_id
2529 = g_signal_connect (G_OBJECT (w), "activate", select_cb, cb_data);
2532 return w;
2535 /* Create a full menu tree specified by DATA.
2536 F is the frame the created menu belongs to.
2537 SELECT_CB is the callback to use when a menu item is selected.
2538 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2539 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2540 If POP_UP_P, create a popup menu.
2541 If MENU_BAR_P, create a menu bar.
2542 If ADD_TEAROFF_P, add a tearoff menu item. Ignored if MENU_BAR_P or
2543 the Gtk+ version used does not have tearoffs.
2544 TOPMENU is the topmost GtkWidget that others shall be placed under.
2545 It may be NULL, in that case we create the appropriate widget
2546 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2547 CL_DATA is the callback data we shall use for this menu, or NULL
2548 if we haven't set the first callback yet.
2549 NAME is the name to give to the top level menu if this function
2550 creates it. May be NULL to not set any name.
2552 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2553 not NULL.
2555 This function calls itself to create submenus. */
2557 static GtkWidget *
2558 create_menus (widget_value *data,
2559 struct frame *f,
2560 GCallback select_cb,
2561 GCallback deactivate_cb,
2562 GCallback highlight_cb,
2563 bool pop_up_p,
2564 bool menu_bar_p,
2565 bool add_tearoff_p,
2566 GtkWidget *topmenu,
2567 xg_menu_cb_data *cl_data,
2568 const char *name)
2570 widget_value *item;
2571 GtkWidget *wmenu = topmenu;
2572 GSList *group = NULL;
2574 if (! topmenu)
2576 if (! menu_bar_p)
2578 wmenu = gtk_menu_new ();
2579 xg_set_screen (wmenu, f);
2580 /* Connect this to the menu instead of items so we get enter/leave for
2581 disabled items also. TODO: Still does not get enter/leave for
2582 disabled items in detached menus. */
2583 g_signal_connect (G_OBJECT (wmenu),
2584 "enter-notify-event",
2585 G_CALLBACK (menuitem_highlight_callback),
2586 NULL);
2587 g_signal_connect (G_OBJECT (wmenu),
2588 "leave-notify-event",
2589 G_CALLBACK (menuitem_highlight_callback),
2590 NULL);
2592 else
2594 wmenu = gtk_menu_bar_new ();
2595 /* Set width of menu bar to a small value so it doesn't enlarge
2596 a small initial frame size. The width will be set to the
2597 width of the frame later on when it is added to a container.
2598 height -1: Natural height. */
2599 gtk_widget_set_size_request (wmenu, 1, -1);
2602 /* Put cl_data on the top menu for easier access. */
2603 cl_data = make_cl_data (cl_data, f, highlight_cb);
2604 g_object_set_data (G_OBJECT (wmenu), XG_FRAME_DATA, (gpointer)cl_data);
2605 g_signal_connect (G_OBJECT (wmenu), "destroy",
2606 G_CALLBACK (menu_destroy_callback), cl_data);
2608 if (name)
2609 gtk_widget_set_name (wmenu, name);
2611 if (deactivate_cb)
2612 g_signal_connect (G_OBJECT (wmenu),
2613 "selection-done", deactivate_cb, 0);
2616 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2617 if (! menu_bar_p && add_tearoff_p)
2619 GtkWidget *tearoff = gtk_tearoff_menu_item_new ();
2620 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu), tearoff);
2622 g_signal_connect (G_OBJECT (tearoff), "activate",
2623 G_CALLBACK (tearoff_activate), 0);
2625 #endif
2627 for (item = data; item; item = item->next)
2629 GtkWidget *w;
2631 if (pop_up_p && !item->contents && !item->call_data
2632 && !menu_separator_name_p (item->name))
2634 char *utf8_label;
2635 /* A title for a popup. We do the same as GTK does when
2636 creating titles, but it does not look good. */
2637 group = NULL;
2638 utf8_label = get_utf8_string (item->name);
2640 gtk_menu_set_title (GTK_MENU (wmenu), utf8_label);
2641 w = gtk_menu_item_new_with_label (utf8_label);
2642 gtk_widget_set_sensitive (w, FALSE);
2643 if (utf8_label) g_free (utf8_label);
2645 else if (menu_separator_name_p (item->name))
2647 group = NULL;
2648 /* GTK only have one separator type. */
2649 w = gtk_separator_menu_item_new ();
2651 else
2653 w = xg_create_one_menuitem (item,
2655 item->contents ? 0 : select_cb,
2656 highlight_cb,
2657 cl_data,
2658 &group);
2660 /* Create a possibly empty submenu for menu bar items, since some
2661 themes don't highlight items correctly without it. */
2662 if (item->contents || menu_bar_p)
2664 GtkWidget *submenu = create_menus (item->contents,
2666 select_cb,
2667 deactivate_cb,
2668 highlight_cb,
2671 add_tearoff_p,
2673 cl_data,
2675 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), submenu);
2679 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu), w);
2680 gtk_widget_set_name (w, MENU_ITEM_NAME);
2683 return wmenu;
2686 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2687 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2688 with some text and buttons.
2689 F is the frame the created item belongs to.
2690 NAME is the name to use for the top widget.
2691 VAL is a widget_value structure describing items to be created.
2692 SELECT_CB is the callback to use when a menu item is selected or
2693 a dialog button is pressed.
2694 DEACTIVATE_CB is the callback to use when an item is deactivated.
2695 For a menu, when a sub menu is not shown anymore, for a dialog it is
2696 called when the dialog is popped down.
2697 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2699 Returns the widget created. */
2701 GtkWidget *
2702 xg_create_widget (const char *type, const char *name, struct frame *f,
2703 widget_value *val, GCallback select_cb,
2704 GCallback deactivate_cb, GCallback highlight_cb)
2706 GtkWidget *w = 0;
2707 bool menu_bar_p = strcmp (type, "menubar") == 0;
2708 bool pop_up_p = strcmp (type, "popup") == 0;
2710 if (strcmp (type, "dialog") == 0)
2712 w = create_dialog (val, select_cb, deactivate_cb);
2713 xg_set_screen (w, f);
2714 gtk_window_set_transient_for (GTK_WINDOW (w),
2715 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
2716 gtk_window_set_destroy_with_parent (GTK_WINDOW (w), TRUE);
2717 gtk_widget_set_name (w, "emacs-dialog");
2718 gtk_window_set_modal (GTK_WINDOW (w), TRUE);
2720 else if (menu_bar_p || pop_up_p)
2722 w = create_menus (val->contents,
2724 select_cb,
2725 deactivate_cb,
2726 highlight_cb,
2727 pop_up_p,
2728 menu_bar_p,
2729 menu_bar_p,
2732 name);
2734 /* Set the cursor to an arrow for popup menus when they are mapped.
2735 This is done by default for menu bar menus. */
2736 if (pop_up_p)
2738 /* Must realize so the GdkWindow inside the widget is created. */
2739 gtk_widget_realize (w);
2740 xg_set_cursor (w, FRAME_DISPLAY_INFO (f)->xg_cursor);
2743 else
2745 fprintf (stderr, "bad type in xg_create_widget: %s, doing nothing\n",
2746 type);
2749 return w;
2752 /* Return the label for menu item WITEM. */
2754 static const char *
2755 xg_get_menu_item_label (GtkMenuItem *witem)
2757 GtkLabel *wlabel = GTK_LABEL (XG_BIN_CHILD (witem));
2758 return gtk_label_get_label (wlabel);
2761 /* Return true if the menu item WITEM has the text LABEL. */
2763 static bool
2764 xg_item_label_same_p (GtkMenuItem *witem, const char *label)
2766 bool is_same = 0;
2767 char *utf8_label = get_utf8_string (label);
2768 const char *old_label = witem ? xg_get_menu_item_label (witem) : 0;
2770 if (! old_label && ! utf8_label)
2771 is_same = 1;
2772 else if (old_label && utf8_label)
2773 is_same = strcmp (utf8_label, old_label) == 0;
2775 if (utf8_label) g_free (utf8_label);
2777 return is_same;
2780 /* Destroy widgets in LIST. */
2782 static void
2783 xg_destroy_widgets (GList *list)
2785 GList *iter;
2787 for (iter = list; iter; iter = g_list_next (iter))
2789 GtkWidget *w = GTK_WIDGET (iter->data);
2791 /* Destroying the widget will remove it from the container it is in. */
2792 gtk_widget_destroy (w);
2796 /* Update the top level names in MENUBAR (i.e. not submenus).
2797 F is the frame the menu bar belongs to.
2798 *LIST is a list with the current menu bar names (menu item widgets).
2799 ITER is the item within *LIST that shall be updated.
2800 POS is the numerical position, starting at 0, of ITER in *LIST.
2801 VAL describes what the menu bar shall look like after the update.
2802 SELECT_CB is the callback to use when a menu item is selected.
2803 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2804 CL_DATA points to the callback data to be used for this menu bar.
2806 This function calls itself to walk through the menu bar names. */
2808 static void
2809 xg_update_menubar (GtkWidget *menubar,
2810 struct frame *f,
2811 GList **list,
2812 GList *iter,
2813 int pos,
2814 widget_value *val,
2815 GCallback select_cb,
2816 GCallback deactivate_cb,
2817 GCallback highlight_cb,
2818 xg_menu_cb_data *cl_data)
2820 if (! iter && ! val)
2821 return;
2822 else if (iter && ! val)
2824 /* Item(s) have been removed. Remove all remaining items. */
2825 xg_destroy_widgets (iter);
2827 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2828 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar),
2829 gtk_menu_item_new_with_label (""),
2831 /* All updated. */
2832 val = 0;
2833 iter = 0;
2835 else if (! iter && val)
2837 /* Item(s) added. Add all new items in one call. */
2838 create_menus (val, f, select_cb, deactivate_cb, highlight_cb,
2839 0, 1, 0, menubar, cl_data, 0);
2841 /* All updated. */
2842 val = 0;
2843 iter = 0;
2845 /* Below this neither iter or val is NULL */
2846 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter->data), val->name))
2848 /* This item is still the same, check next item. */
2849 val = val->next;
2850 iter = g_list_next (iter);
2851 ++pos;
2853 else /* This item is changed. */
2855 GtkMenuItem *witem = GTK_MENU_ITEM (iter->data);
2856 GtkMenuItem *witem2 = 0;
2857 bool val_in_menubar = 0;
2858 bool iter_in_new_menubar = 0;
2859 GList *iter2;
2860 widget_value *cur;
2862 /* See if the changed entry (val) is present later in the menu bar */
2863 for (iter2 = iter;
2864 iter2 && ! val_in_menubar;
2865 iter2 = g_list_next (iter2))
2867 witem2 = GTK_MENU_ITEM (iter2->data);
2868 val_in_menubar = xg_item_label_same_p (witem2, val->name);
2871 /* See if the current entry (iter) is present later in the
2872 specification for the new menu bar. */
2873 for (cur = val; cur && ! iter_in_new_menubar; cur = cur->next)
2874 iter_in_new_menubar = xg_item_label_same_p (witem, cur->name);
2876 if (val_in_menubar && ! iter_in_new_menubar)
2878 int nr = pos;
2880 /* This corresponds to:
2881 Current: A B C
2882 New: A C
2883 Remove B. */
2885 g_object_ref (G_OBJECT (witem));
2886 gtk_container_remove (GTK_CONTAINER (menubar), GTK_WIDGET (witem));
2887 gtk_widget_destroy (GTK_WIDGET (witem));
2889 /* Must get new list since the old changed. */
2890 g_list_free (*list);
2891 *list = iter = gtk_container_get_children (GTK_CONTAINER (menubar));
2892 while (nr-- > 0) iter = g_list_next (iter);
2894 else if (! val_in_menubar && ! iter_in_new_menubar)
2896 /* This corresponds to:
2897 Current: A B C
2898 New: A X C
2899 Rename B to X. This might seem to be a strange thing to do,
2900 since if there is a menu under B it will be totally wrong for X.
2901 But consider editing a C file. Then there is a C-mode menu
2902 (corresponds to B above).
2903 If then doing C-x C-f the minibuf menu (X above) replaces the
2904 C-mode menu. When returning from the minibuffer, we get
2905 back the C-mode menu. Thus we do:
2906 Rename B to X (C-mode to minibuf menu)
2907 Rename X to B (minibuf to C-mode menu).
2908 If the X menu hasn't been invoked, the menu under B
2909 is up to date when leaving the minibuffer. */
2910 GtkLabel *wlabel = GTK_LABEL (XG_BIN_CHILD (witem));
2911 char *utf8_label = get_utf8_string (val->name);
2912 GtkWidget *submenu = gtk_menu_item_get_submenu (witem);
2914 gtk_label_set_text (wlabel, utf8_label);
2916 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2917 /* If this item has a submenu that has been detached, change
2918 the title in the WM decorations also. */
2919 if (submenu && gtk_menu_get_tearoff_state (GTK_MENU (submenu)))
2920 /* Set the title of the detached window. */
2921 gtk_menu_set_title (GTK_MENU (submenu), utf8_label);
2922 #endif
2924 if (utf8_label) g_free (utf8_label);
2925 iter = g_list_next (iter);
2926 val = val->next;
2927 ++pos;
2929 else if (! val_in_menubar && iter_in_new_menubar)
2931 /* This corresponds to:
2932 Current: A B C
2933 New: A X B C
2934 Insert X. */
2936 int nr = pos;
2937 GSList *group = 0;
2938 GtkWidget *w = xg_create_one_menuitem (val,
2940 select_cb,
2941 highlight_cb,
2942 cl_data,
2943 &group);
2945 /* Create a possibly empty submenu for menu bar items, since some
2946 themes don't highlight items correctly without it. */
2947 GtkWidget *submenu = create_menus (NULL, f,
2948 select_cb, deactivate_cb,
2949 highlight_cb,
2950 0, 0, 0, 0, cl_data, 0);
2951 gtk_widget_set_name (w, MENU_ITEM_NAME);
2952 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar), w, pos);
2953 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), submenu);
2955 g_list_free (*list);
2956 *list = iter = gtk_container_get_children (GTK_CONTAINER (menubar));
2957 while (nr-- > 0) iter = g_list_next (iter);
2958 iter = g_list_next (iter);
2959 val = val->next;
2960 ++pos;
2962 else /* if (val_in_menubar && iter_in_new_menubar) */
2964 int nr = pos;
2965 /* This corresponds to:
2966 Current: A B C
2967 New: A C B
2968 Move C before B */
2970 g_object_ref (G_OBJECT (witem2));
2971 gtk_container_remove (GTK_CONTAINER (menubar), GTK_WIDGET (witem2));
2972 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar),
2973 GTK_WIDGET (witem2), pos);
2974 g_object_unref (G_OBJECT (witem2));
2976 g_list_free (*list);
2977 *list = iter = gtk_container_get_children (GTK_CONTAINER (menubar));
2978 while (nr-- > 0) iter = g_list_next (iter);
2979 if (iter) iter = g_list_next (iter);
2980 val = val->next;
2981 ++pos;
2985 /* Update the rest of the menu bar. */
2986 xg_update_menubar (menubar, f, list, iter, pos, val,
2987 select_cb, deactivate_cb, highlight_cb, cl_data);
2990 /* Update the menu item W so it corresponds to VAL.
2991 SELECT_CB is the callback to use when a menu item is selected.
2992 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2993 CL_DATA is the data to set in the widget for menu invocation. */
2995 static void
2996 xg_update_menu_item (widget_value *val,
2997 GtkWidget *w,
2998 GCallback select_cb,
2999 GCallback highlight_cb,
3000 xg_menu_cb_data *cl_data)
3002 GtkWidget *wchild;
3003 GtkLabel *wlbl = 0;
3004 GtkLabel *wkey = 0;
3005 char *utf8_label;
3006 char *utf8_key;
3007 const char *old_label = 0;
3008 const char *old_key = 0;
3009 xg_menu_item_cb_data *cb_data;
3011 wchild = XG_BIN_CHILD (w);
3012 utf8_label = get_utf8_string (val->name);
3013 utf8_key = get_utf8_string (val->key);
3015 /* See if W is a menu item with a key. See make_menu_item above. */
3016 if (GTK_IS_BOX (wchild))
3018 GList *list = gtk_container_get_children (GTK_CONTAINER (wchild));
3020 wlbl = GTK_LABEL (list->data);
3021 wkey = GTK_LABEL (list->next->data);
3022 g_list_free (list);
3024 if (! utf8_key)
3026 /* Remove the key and keep just the label. */
3027 g_object_ref (G_OBJECT (wlbl));
3028 gtk_container_remove (GTK_CONTAINER (w), wchild);
3029 gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (wlbl));
3030 g_object_unref (G_OBJECT (wlbl));
3031 wkey = 0;
3035 else /* Just a label. */
3037 wlbl = GTK_LABEL (wchild);
3039 /* Check if there is now a key. */
3040 if (utf8_key)
3042 GtkWidget *wtoadd = make_widget_for_menu_item (utf8_label, utf8_key);
3043 GList *list = gtk_container_get_children (GTK_CONTAINER (wtoadd));
3045 wlbl = GTK_LABEL (list->data);
3046 wkey = GTK_LABEL (list->next->data);
3047 g_list_free (list);
3049 gtk_container_remove (GTK_CONTAINER (w), wchild);
3050 gtk_container_add (GTK_CONTAINER (w), wtoadd);
3055 if (wkey) old_key = gtk_label_get_label (wkey);
3056 if (wlbl) old_label = gtk_label_get_label (wlbl);
3058 if (wkey && utf8_key && (! old_key || strcmp (utf8_key, old_key) != 0))
3059 gtk_label_set_text (wkey, utf8_key);
3061 if (! old_label || strcmp (utf8_label, old_label) != 0)
3062 gtk_label_set_text (wlbl, utf8_label);
3064 if (utf8_key) g_free (utf8_key);
3065 if (utf8_label) g_free (utf8_label);
3067 if (! val->enabled && gtk_widget_get_sensitive (w))
3068 gtk_widget_set_sensitive (w, FALSE);
3069 else if (val->enabled && ! gtk_widget_get_sensitive (w))
3070 gtk_widget_set_sensitive (w, TRUE);
3072 cb_data = g_object_get_data (G_OBJECT (w), XG_ITEM_DATA);
3073 if (cb_data)
3075 cb_data->call_data = val->call_data;
3076 cb_data->help = val->help;
3077 cb_data->cl_data = cl_data;
3079 /* We assume the callback functions don't change. */
3080 if (val->call_data && ! val->contents)
3082 /* This item shall have a select callback. */
3083 if (! cb_data->select_id)
3084 cb_data->select_id
3085 = g_signal_connect (G_OBJECT (w), "activate",
3086 select_cb, cb_data);
3088 else if (cb_data->select_id)
3090 g_signal_handler_disconnect (w, cb_data->select_id);
3091 cb_data->select_id = 0;
3096 /* Update the toggle menu item W so it corresponds to VAL. */
3098 static void
3099 xg_update_toggle_item (widget_value *val, GtkWidget *w)
3101 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), val->selected);
3104 /* Update the radio menu item W so it corresponds to VAL. */
3106 static void
3107 xg_update_radio_item (widget_value *val, GtkWidget *w)
3109 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), val->selected);
3112 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3113 SUBMENU may be NULL, in that case a new menu is created.
3114 F is the frame the menu bar belongs to.
3115 VAL describes the contents of the menu bar.
3116 SELECT_CB is the callback to use when a menu item is selected.
3117 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3118 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3119 CL_DATA is the call back data to use for any newly created items.
3121 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3122 was NULL. */
3124 static GtkWidget *
3125 xg_update_submenu (GtkWidget *submenu,
3126 struct frame *f,
3127 widget_value *val,
3128 GCallback select_cb,
3129 GCallback deactivate_cb,
3130 GCallback highlight_cb,
3131 xg_menu_cb_data *cl_data)
3133 GtkWidget *newsub = submenu;
3134 GList *list = 0;
3135 GList *iter;
3136 widget_value *cur;
3137 bool has_tearoff_p = 0;
3138 GList *first_radio = 0;
3140 if (submenu)
3141 list = gtk_container_get_children (GTK_CONTAINER (submenu));
3143 for (cur = val, iter = list;
3144 cur && iter;
3145 iter = g_list_next (iter), cur = cur->next)
3147 GtkWidget *w = GTK_WIDGET (iter->data);
3149 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
3150 /* Skip tearoff items, they have no counterpart in val. */
3151 if (GTK_IS_TEAROFF_MENU_ITEM (w))
3153 has_tearoff_p = 1;
3154 iter = g_list_next (iter);
3155 if (iter) w = GTK_WIDGET (iter->data);
3156 else break;
3158 #endif
3160 /* Remember first radio button in a group. If we get a mismatch in
3161 a radio group we must rebuild the whole group so that the connections
3162 in GTK becomes correct. */
3163 if (cur->button_type == BUTTON_TYPE_RADIO && ! first_radio)
3164 first_radio = iter;
3165 else if (cur->button_type != BUTTON_TYPE_RADIO
3166 && ! GTK_IS_RADIO_MENU_ITEM (w))
3167 first_radio = 0;
3169 if (GTK_IS_SEPARATOR_MENU_ITEM (w))
3171 if (! menu_separator_name_p (cur->name))
3172 break;
3174 else if (GTK_IS_CHECK_MENU_ITEM (w))
3176 if (cur->button_type != BUTTON_TYPE_TOGGLE)
3177 break;
3178 xg_update_toggle_item (cur, w);
3179 xg_update_menu_item (cur, w, select_cb, highlight_cb, cl_data);
3181 else if (GTK_IS_RADIO_MENU_ITEM (w))
3183 if (cur->button_type != BUTTON_TYPE_RADIO)
3184 break;
3185 xg_update_radio_item (cur, w);
3186 xg_update_menu_item (cur, w, select_cb, highlight_cb, cl_data);
3188 else if (GTK_IS_MENU_ITEM (w))
3190 GtkMenuItem *witem = GTK_MENU_ITEM (w);
3191 GtkWidget *sub;
3193 if (cur->button_type != BUTTON_TYPE_NONE ||
3194 menu_separator_name_p (cur->name))
3195 break;
3197 xg_update_menu_item (cur, w, select_cb, highlight_cb, cl_data);
3199 sub = gtk_menu_item_get_submenu (witem);
3200 if (sub && ! cur->contents)
3202 /* Not a submenu anymore. */
3203 g_object_ref (G_OBJECT (sub));
3204 remove_submenu (witem);
3205 gtk_widget_destroy (sub);
3207 else if (cur->contents)
3209 GtkWidget *nsub;
3211 nsub = xg_update_submenu (sub, f, cur->contents,
3212 select_cb, deactivate_cb,
3213 highlight_cb, cl_data);
3215 /* If this item just became a submenu, we must set it. */
3216 if (nsub != sub)
3217 gtk_menu_item_set_submenu (witem, nsub);
3220 else
3222 /* Structural difference. Remove everything from here and down
3223 in SUBMENU. */
3224 break;
3228 /* Remove widgets from first structural change. */
3229 if (iter)
3231 /* If we are adding new menu items below, we must remove from
3232 first radio button so that radio groups become correct. */
3233 if (cur && first_radio) xg_destroy_widgets (first_radio);
3234 else xg_destroy_widgets (iter);
3237 if (cur)
3239 /* More items added. Create them. */
3240 newsub = create_menus (cur,
3242 select_cb,
3243 deactivate_cb,
3244 highlight_cb,
3247 ! has_tearoff_p,
3248 submenu,
3249 cl_data,
3253 if (list) g_list_free (list);
3255 return newsub;
3258 /* Update the MENUBAR.
3259 F is the frame the menu bar belongs to.
3260 VAL describes the contents of the menu bar.
3261 If DEEP_P, rebuild all but the top level menu names in
3262 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3263 SELECT_CB is the callback to use when a menu item is selected.
3264 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3265 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3267 void
3268 xg_modify_menubar_widgets (GtkWidget *menubar, struct frame *f,
3269 widget_value *val, bool deep_p,
3270 GCallback select_cb, GCallback deactivate_cb,
3271 GCallback highlight_cb)
3273 xg_menu_cb_data *cl_data;
3274 GList *list = gtk_container_get_children (GTK_CONTAINER (menubar));
3276 if (! list) return;
3278 cl_data = g_object_get_data (G_OBJECT (menubar), XG_FRAME_DATA);
3280 xg_update_menubar (menubar, f, &list, list, 0, val->contents,
3281 select_cb, deactivate_cb, highlight_cb, cl_data);
3283 if (deep_p)
3285 widget_value *cur;
3287 /* Update all sub menus.
3288 We must keep the submenus (GTK menu item widgets) since the
3289 X Window in the XEvent that activates the menu are those widgets. */
3291 /* Update cl_data, menu_item things in F may have changed. */
3292 update_cl_data (cl_data, f, highlight_cb);
3294 for (cur = val->contents; cur; cur = cur->next)
3296 GList *iter;
3297 GtkWidget *sub = 0;
3298 GtkWidget *newsub;
3299 GtkMenuItem *witem = 0;
3301 /* Find sub menu that corresponds to val and update it. */
3302 for (iter = list ; iter; iter = g_list_next (iter))
3304 witem = GTK_MENU_ITEM (iter->data);
3305 if (xg_item_label_same_p (witem, cur->name))
3307 sub = gtk_menu_item_get_submenu (witem);
3308 break;
3312 newsub = xg_update_submenu (sub,
3314 cur->contents,
3315 select_cb,
3316 deactivate_cb,
3317 highlight_cb,
3318 cl_data);
3319 /* sub may still be NULL. If we just updated non deep and added
3320 a new menu bar item, it has no sub menu yet. So we set the
3321 newly created sub menu under witem. */
3322 if (newsub != sub && witem != 0)
3324 xg_set_screen (newsub, f);
3325 gtk_menu_item_set_submenu (witem, newsub);
3330 g_list_free (list);
3331 gtk_widget_show_all (menubar);
3334 /* Callback called when the menu bar W is mapped.
3335 Used to find the height of the menu bar if we didn't get it
3336 after showing the widget. */
3338 static void
3339 menubar_map_cb (GtkWidget *w, gpointer user_data)
3341 GtkRequisition req;
3342 struct frame *f = user_data;
3343 gtk_widget_get_preferred_size (w, NULL, &req);
3344 if (FRAME_MENUBAR_HEIGHT (f) != req.height)
3346 FRAME_MENUBAR_HEIGHT (f) = req.height;
3347 xg_height_or_width_changed (f);
3351 /* Recompute all the widgets of frame F, when the menu bar has been
3352 changed. */
3354 void
3355 xg_update_frame_menubar (struct frame *f)
3357 struct x_output *x = f->output_data.x;
3358 GtkRequisition req;
3360 if (!x->menubar_widget || gtk_widget_get_mapped (x->menubar_widget))
3361 return;
3363 if (x->menubar_widget && gtk_widget_get_parent (x->menubar_widget))
3364 return; /* Already done this, happens for frames created invisible. */
3366 block_input ();
3368 gtk_box_pack_start (GTK_BOX (x->vbox_widget), x->menubar_widget,
3369 FALSE, FALSE, 0);
3370 gtk_box_reorder_child (GTK_BOX (x->vbox_widget), x->menubar_widget, 0);
3372 g_signal_connect (x->menubar_widget, "map", G_CALLBACK (menubar_map_cb), f);
3373 gtk_widget_show_all (x->menubar_widget);
3374 gtk_widget_get_preferred_size (x->menubar_widget, NULL, &req);
3376 /* If menu bar doesn't know its height yet, cheat a little so the frame
3377 doesn't jump so much when resized later in menubar_map_cb. */
3378 if (req.height == 0)
3379 req.height = 23;
3381 if (FRAME_MENUBAR_HEIGHT (f) != req.height)
3383 FRAME_MENUBAR_HEIGHT (f) = req.height;
3384 xg_height_or_width_changed (f);
3386 unblock_input ();
3389 /* Get rid of the menu bar of frame F, and free its storage.
3390 This is used when deleting a frame, and when turning off the menu bar. */
3392 void
3393 free_frame_menubar (struct frame *f)
3395 struct x_output *x = f->output_data.x;
3397 if (x->menubar_widget)
3399 block_input ();
3401 gtk_container_remove (GTK_CONTAINER (x->vbox_widget), x->menubar_widget);
3402 /* The menubar and its children shall be deleted when removed from
3403 the container. */
3404 x->menubar_widget = 0;
3405 FRAME_MENUBAR_HEIGHT (f) = 0;
3406 xg_height_or_width_changed (f);
3407 unblock_input ();
3411 bool
3412 xg_event_is_for_menubar (struct frame *f, const XEvent *event)
3414 struct x_output *x = f->output_data.x;
3415 GList *iter;
3416 GdkRectangle rec;
3417 GList *list;
3418 GdkDisplay *gdpy;
3419 GdkWindow *gw;
3420 GdkEvent gevent;
3421 GtkWidget *gwdesc;
3423 if (! x->menubar_widget) return 0;
3425 if (! (event->xbutton.x >= 0
3426 && event->xbutton.x < FRAME_PIXEL_WIDTH (f)
3427 && event->xbutton.y >= 0
3428 && event->xbutton.y < f->output_data.x->menubar_height
3429 && event->xbutton.same_screen))
3430 return 0;
3432 gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
3433 gw = gdk_x11_window_lookup_for_display (gdpy, event->xbutton.window);
3434 if (! gw) return 0;
3435 gevent.any.window = gw;
3436 gevent.any.type = GDK_NOTHING;
3437 gwdesc = gtk_get_event_widget (&gevent);
3438 if (! gwdesc) return 0;
3439 if (! GTK_IS_MENU_BAR (gwdesc)
3440 && ! GTK_IS_MENU_ITEM (gwdesc)
3441 && ! gtk_widget_is_ancestor (x->menubar_widget, gwdesc))
3442 return 0;
3444 list = gtk_container_get_children (GTK_CONTAINER (x->menubar_widget));
3445 if (! list) return 0;
3446 rec.x = event->xbutton.x;
3447 rec.y = event->xbutton.y;
3448 rec.width = 1;
3449 rec.height = 1;
3451 for (iter = list ; iter; iter = g_list_next (iter))
3453 GtkWidget *w = GTK_WIDGET (iter->data);
3454 if (gtk_widget_get_mapped (w) && gtk_widget_intersect (w, &rec, NULL))
3455 break;
3457 g_list_free (list);
3458 return iter != 0;
3463 /***********************************************************************
3464 Scroll bar functions
3465 ***********************************************************************/
3468 /* Setting scroll bar values invokes the callback. Use this variable
3469 to indicate that callback should do nothing. */
3471 bool xg_ignore_gtk_scrollbar;
3473 /* The width of the scroll bar for the current theme. */
3475 static int scroll_bar_width_for_theme;
3477 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3478 may be larger than 32 bits. Keep a mapping from integer index to widget
3479 pointers to get around the 32 bit limitation. */
3481 static struct
3483 GtkWidget **widgets;
3484 ptrdiff_t max_size;
3485 ptrdiff_t used;
3486 } id_to_widget;
3488 /* Grow this much every time we need to allocate more */
3490 #define ID_TO_WIDGET_INCR 32
3492 /* Store the widget pointer W in id_to_widget and return the integer index. */
3494 static ptrdiff_t
3495 xg_store_widget_in_map (GtkWidget *w)
3497 ptrdiff_t i;
3499 if (id_to_widget.max_size == id_to_widget.used)
3501 ptrdiff_t new_size;
3502 if (TYPE_MAXIMUM (Window) - ID_TO_WIDGET_INCR < id_to_widget.max_size)
3503 memory_full (SIZE_MAX);
3505 new_size = id_to_widget.max_size + ID_TO_WIDGET_INCR;
3506 id_to_widget.widgets = xnrealloc (id_to_widget.widgets,
3507 new_size, sizeof (GtkWidget *));
3509 for (i = id_to_widget.max_size; i < new_size; ++i)
3510 id_to_widget.widgets[i] = 0;
3511 id_to_widget.max_size = new_size;
3514 /* Just loop over the array and find a free place. After all,
3515 how many scroll bars are we creating? Should be a small number.
3516 The check above guarantees we will find a free place. */
3517 for (i = 0; i < id_to_widget.max_size; ++i)
3519 if (! id_to_widget.widgets[i])
3521 id_to_widget.widgets[i] = w;
3522 ++id_to_widget.used;
3524 return i;
3528 /* Should never end up here */
3529 emacs_abort ();
3532 /* Remove pointer at IDX from id_to_widget.
3533 Called when scroll bar is destroyed. */
3535 static void
3536 xg_remove_widget_from_map (ptrdiff_t idx)
3538 if (idx < id_to_widget.max_size && id_to_widget.widgets[idx] != 0)
3540 id_to_widget.widgets[idx] = 0;
3541 --id_to_widget.used;
3545 /* Get the widget pointer at IDX from id_to_widget. */
3547 static GtkWidget *
3548 xg_get_widget_from_map (ptrdiff_t idx)
3550 if (idx < id_to_widget.max_size && id_to_widget.widgets[idx] != 0)
3551 return id_to_widget.widgets[idx];
3553 return 0;
3556 static void
3557 update_theme_scrollbar_width (void)
3559 #ifdef HAVE_GTK3
3560 GtkAdjustment *vadj;
3561 #else
3562 GtkObject *vadj;
3563 #endif
3564 GtkWidget *wscroll;
3565 int w = 0, b = 0;
3567 vadj = gtk_adjustment_new (XG_SB_MIN, XG_SB_MIN, XG_SB_MAX, 0.1, 0.1, 0.1);
3568 wscroll = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (vadj));
3569 g_object_ref_sink (G_OBJECT (wscroll));
3570 gtk_widget_style_get (wscroll, "slider-width", &w, "trough-border", &b, NULL);
3571 gtk_widget_destroy (wscroll);
3572 g_object_unref (G_OBJECT (wscroll));
3573 w += 2*b;
3574 if (w < 16) w = 16;
3575 scroll_bar_width_for_theme = w;
3579 xg_get_default_scrollbar_width (void)
3581 return scroll_bar_width_for_theme;
3584 /* Return the scrollbar id for X Window WID on display DPY.
3585 Return -1 if WID not in id_to_widget. */
3587 ptrdiff_t
3588 xg_get_scroll_id_for_window (Display *dpy, Window wid)
3590 ptrdiff_t idx;
3591 GtkWidget *w;
3593 w = xg_win_to_widget (dpy, wid);
3595 if (w)
3597 for (idx = 0; idx < id_to_widget.max_size; ++idx)
3598 if (id_to_widget.widgets[idx] == w)
3599 return idx;
3602 return -1;
3605 /* Callback invoked when scroll bar WIDGET is destroyed.
3606 DATA is the index into id_to_widget for WIDGET.
3607 We free pointer to last scroll bar values here and remove the index. */
3609 static void
3610 xg_gtk_scroll_destroy (GtkWidget *widget, gpointer data)
3612 intptr_t id = (intptr_t) data;
3613 xg_remove_widget_from_map (id);
3616 /* Create a scroll bar widget for frame F. Store the scroll bar
3617 in BAR.
3618 SCROLL_CALLBACK is the callback to invoke when the value of the
3619 bar changes.
3620 END_CALLBACK is the callback to invoke when scrolling ends.
3621 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3622 to set resources for the widget. */
3624 void
3625 xg_create_scroll_bar (struct frame *f,
3626 struct scroll_bar *bar,
3627 GCallback scroll_callback,
3628 GCallback end_callback,
3629 const char *scroll_bar_name)
3631 GtkWidget *wscroll;
3632 GtkWidget *webox;
3633 intptr_t scroll_id;
3634 #ifdef HAVE_GTK3
3635 GtkAdjustment *vadj;
3636 #else
3637 GtkObject *vadj;
3638 #endif
3640 /* Page, step increment values are not so important here, they
3641 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3642 vadj = gtk_adjustment_new (XG_SB_MIN, XG_SB_MIN, XG_SB_MAX,
3643 0.1, 0.1, 0.1);
3645 wscroll = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (vadj));
3646 webox = gtk_event_box_new ();
3647 gtk_widget_set_name (wscroll, scroll_bar_name);
3648 #ifndef HAVE_GTK3
3649 gtk_range_set_update_policy (GTK_RANGE (wscroll), GTK_UPDATE_CONTINUOUS);
3650 #endif
3651 g_object_set_data (G_OBJECT (wscroll), XG_FRAME_DATA, (gpointer)f);
3653 scroll_id = xg_store_widget_in_map (wscroll);
3655 g_signal_connect (G_OBJECT (wscroll),
3656 "destroy",
3657 G_CALLBACK (xg_gtk_scroll_destroy),
3658 (gpointer) scroll_id);
3659 g_signal_connect (G_OBJECT (wscroll),
3660 "change-value",
3661 scroll_callback,
3662 (gpointer) bar);
3663 g_signal_connect (G_OBJECT (wscroll),
3664 "button-release-event",
3665 end_callback,
3666 (gpointer) bar);
3668 /* The scroll bar widget does not draw on a window of its own. Instead
3669 it draws on the parent window, in this case the edit widget. So
3670 whenever the edit widget is cleared, the scroll bar needs to redraw
3671 also, which causes flicker. Put an event box between the edit widget
3672 and the scroll bar, so the scroll bar instead draws itself on the
3673 event box window. */
3674 gtk_fixed_put (GTK_FIXED (f->output_data.x->edit_widget), webox, -1, -1);
3675 gtk_container_add (GTK_CONTAINER (webox), wscroll);
3678 /* Set the cursor to an arrow. */
3679 xg_set_cursor (webox, FRAME_DISPLAY_INFO (f)->xg_cursor);
3681 bar->x_window = scroll_id;
3684 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3686 void
3687 xg_remove_scroll_bar (struct frame *f, ptrdiff_t scrollbar_id)
3689 GtkWidget *w = xg_get_widget_from_map (scrollbar_id);
3690 if (w)
3692 GtkWidget *wparent = gtk_widget_get_parent (w);
3693 gtk_widget_destroy (w);
3694 gtk_widget_destroy (wparent);
3695 SET_FRAME_GARBAGED (f);
3699 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3700 in frame F.
3701 TOP/LEFT are the new pixel positions where the bar shall appear.
3702 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3704 void
3705 xg_update_scrollbar_pos (struct frame *f,
3706 ptrdiff_t scrollbar_id,
3707 int top,
3708 int left,
3709 int width,
3710 int height)
3713 GtkWidget *wscroll = xg_get_widget_from_map (scrollbar_id);
3715 if (wscroll)
3717 GtkWidget *wfixed = f->output_data.x->edit_widget;
3718 GtkWidget *wparent = gtk_widget_get_parent (wscroll);
3719 gint msl;
3721 /* Clear out old position. */
3722 int oldx = -1, oldy = -1, oldw, oldh;
3723 if (gtk_widget_get_parent (wparent) == wfixed)
3725 gtk_container_child_get (GTK_CONTAINER (wfixed), wparent,
3726 "x", &oldx, "y", &oldy, NULL);
3727 gtk_widget_get_size_request (wscroll, &oldw, &oldh);
3730 /* Move and resize to new values. */
3731 gtk_fixed_move (GTK_FIXED (wfixed), wparent, left, top);
3732 gtk_widget_style_get (wscroll, "min-slider-length", &msl, NULL);
3733 if (msl > height)
3735 /* No room. Hide scroll bar as some themes output a warning if
3736 the height is less than the min size. */
3737 gtk_widget_hide (wparent);
3738 gtk_widget_hide (wscroll);
3740 else
3742 gtk_widget_show_all (wparent);
3743 gtk_widget_set_size_request (wscroll, width, height);
3745 gtk_widget_queue_draw (wfixed);
3746 gdk_window_process_all_updates ();
3747 if (oldx != -1 && oldw > 0 && oldh > 0)
3748 /* Clear under old scroll bar position. This must be done after
3749 the gtk_widget_queue_draw and gdk_window_process_all_updates
3750 above. */
3751 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3752 oldx, oldy, oldw, oldh);
3754 /* GTK does not redraw until the main loop is entered again, but
3755 if there are no X events pending we will not enter it. So we sync
3756 here to get some events. */
3758 x_sync (f);
3759 SET_FRAME_GARBAGED (f);
3760 cancel_mouse_face (f);
3764 /* Get the current value of the range, truncated to an integer. */
3766 static int
3767 int_gtk_range_get_value (GtkRange *range)
3769 return gtk_range_get_value (range);
3773 /* Set the thumb size and position of scroll bar BAR. We are currently
3774 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3776 void
3777 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar,
3778 int portion,
3779 int position,
3780 int whole)
3782 GtkWidget *wscroll = xg_get_widget_from_map (bar->x_window);
3784 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3786 if (wscroll && bar->dragging == -1)
3788 GtkAdjustment *adj;
3789 gdouble shown;
3790 gdouble top;
3791 int size, value;
3792 int old_size;
3793 int new_step;
3794 bool changed = 0;
3796 adj = gtk_range_get_adjustment (GTK_RANGE (wscroll));
3798 if (scroll_bar_adjust_thumb_portion_p)
3800 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3801 line rather than the real portion value. This makes the
3802 thumb less likely to resize and that looks better. */
3803 portion = WINDOW_TOTAL_LINES (XWINDOW (bar->window)) * 30;
3805 /* When the thumb is at the bottom, position == whole.
3806 So we need to increase `whole' to make space for the thumb. */
3807 whole += portion;
3810 if (whole <= 0)
3811 top = 0, shown = 1;
3812 else
3814 top = (gdouble) position / whole;
3815 shown = (gdouble) portion / whole;
3818 size = clip_to_bounds (1, shown * XG_SB_RANGE, XG_SB_RANGE);
3819 value = clip_to_bounds (XG_SB_MIN, top * XG_SB_RANGE, XG_SB_MAX - size);
3821 /* Assume all lines are of equal size. */
3822 new_step = size / max (1, FRAME_LINES (f));
3824 old_size = gtk_adjustment_get_page_size (adj);
3825 if (old_size != size)
3827 int old_step = gtk_adjustment_get_step_increment (adj);
3828 if (old_step != new_step)
3830 gtk_adjustment_set_page_size (adj, size);
3831 gtk_adjustment_set_step_increment (adj, new_step);
3832 /* Assume a page increment is about 95% of the page size */
3833 gtk_adjustment_set_page_increment (adj, size - size / 20);
3834 changed = 1;
3838 if (changed || int_gtk_range_get_value (GTK_RANGE (wscroll)) != value)
3840 block_input ();
3842 /* gtk_range_set_value invokes the callback. Set
3843 ignore_gtk_scrollbar to make the callback do nothing */
3844 xg_ignore_gtk_scrollbar = 1;
3846 if (int_gtk_range_get_value (GTK_RANGE (wscroll)) != value)
3847 gtk_range_set_value (GTK_RANGE (wscroll), (gdouble)value);
3848 else if (changed)
3849 gtk_adjustment_changed (adj);
3851 xg_ignore_gtk_scrollbar = 0;
3853 unblock_input ();
3858 /* Return true if EVENT is for a scroll bar in frame F.
3859 When the same X window is used for several Gtk+ widgets, we cannot
3860 say for sure based on the X window alone if an event is for the
3861 frame. This function does additional checks. */
3863 bool
3864 xg_event_is_for_scrollbar (struct frame *f, const XEvent *event)
3866 bool retval = 0;
3868 if (f && event->type == ButtonPress && event->xbutton.button < 4)
3870 /* Check if press occurred outside the edit widget. */
3871 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
3872 GdkWindow *gwin;
3873 #ifdef HAVE_GTK3
3874 GdkDevice *gdev = gdk_device_manager_get_client_pointer
3875 (gdk_display_get_device_manager (gdpy));
3876 gwin = gdk_device_get_window_at_position (gdev, NULL, NULL);
3877 #else
3878 gwin = gdk_display_get_window_at_pointer (gdpy, NULL, NULL);
3879 #endif
3880 retval = gwin != gtk_widget_get_window (f->output_data.x->edit_widget);
3882 else if (f
3883 && ((event->type == ButtonRelease && event->xbutton.button < 4)
3884 || event->type == MotionNotify))
3886 /* If we are releasing or moving the scroll bar, it has the grab. */
3887 GtkWidget *w = gtk_grab_get_current ();
3888 retval = w != 0 && GTK_IS_SCROLLBAR (w);
3891 return retval;
3896 /***********************************************************************
3897 Tool bar functions
3898 ***********************************************************************/
3899 /* The key for the data we put in the GtkImage widgets. The data is
3900 the image used by Emacs. We use this to see if we need to update
3901 the GtkImage with a new image. */
3902 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3904 /* The key for storing the latest modifiers so the activate callback can
3905 get them. */
3906 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3908 /* The key for storing the button widget in its proxy menu item. */
3909 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3911 /* The key for the data we put in the GtkImage widgets. The data is
3912 the stock name used by Emacs. We use this to see if we need to update
3913 the GtkImage with a new image. */
3914 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3916 /* As above, but this is used for named theme widgets, as opposed to
3917 stock items. */
3918 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3920 /* Callback function invoked when a tool bar item is pressed.
3921 W is the button widget in the tool bar that got pressed,
3922 CLIENT_DATA is an integer that is the index of the button in the
3923 tool bar. 0 is the first button. */
3925 static gboolean
3926 xg_tool_bar_button_cb (GtkWidget *widget,
3927 GdkEventButton *event,
3928 gpointer user_data)
3930 intptr_t state = event->state;
3931 gpointer ptr = (gpointer) state;
3932 g_object_set_data (G_OBJECT (widget), XG_TOOL_BAR_LAST_MODIFIER, ptr);
3933 return FALSE;
3937 /* Callback function invoked when a tool bar item is pressed.
3938 W is the button widget in the tool bar that got pressed,
3939 CLIENT_DATA is an integer that is the index of the button in the
3940 tool bar. 0 is the first button. */
3942 static void
3943 xg_tool_bar_callback (GtkWidget *w, gpointer client_data)
3945 intptr_t idx = (intptr_t) client_data;
3946 gpointer gmod = g_object_get_data (G_OBJECT (w), XG_TOOL_BAR_LAST_MODIFIER);
3947 intptr_t mod = (intptr_t) gmod;
3949 struct frame *f = g_object_get_data (G_OBJECT (w), XG_FRAME_DATA);
3950 Lisp_Object key, frame;
3951 struct input_event event;
3952 EVENT_INIT (event);
3954 if (! f || ! f->n_tool_bar_items || NILP (f->tool_bar_items))
3955 return;
3957 idx *= TOOL_BAR_ITEM_NSLOTS;
3959 key = AREF (f->tool_bar_items, idx + TOOL_BAR_ITEM_KEY);
3960 XSETFRAME (frame, f);
3962 /* We generate two events here. The first one is to set the prefix
3963 to `(tool_bar)', see keyboard.c. */
3964 event.kind = TOOL_BAR_EVENT;
3965 event.frame_or_window = frame;
3966 event.arg = frame;
3967 kbd_buffer_store_event (&event);
3969 event.kind = TOOL_BAR_EVENT;
3970 event.frame_or_window = frame;
3971 event.arg = key;
3972 /* Convert between the modifier bits GDK uses and the modifier bits
3973 Emacs uses. This assumes GDK and X masks are the same, which they are when
3974 this is written. */
3975 event.modifiers = x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f), mod);
3976 kbd_buffer_store_event (&event);
3978 /* Return focus to the frame after we have clicked on a detached
3979 tool bar button. */
3980 x_focus_frame (f);
3983 /* Callback function invoked when a tool bar item is pressed in a detached
3984 tool bar or the overflow drop down menu.
3985 We just call xg_tool_bar_callback.
3986 W is the menu item widget that got pressed,
3987 CLIENT_DATA is an integer that is the index of the button in the
3988 tool bar. 0 is the first button. */
3990 static void
3991 xg_tool_bar_proxy_callback (GtkWidget *w, gpointer client_data)
3993 GtkWidget *wbutton = GTK_WIDGET (g_object_get_data (G_OBJECT (w),
3994 XG_TOOL_BAR_PROXY_BUTTON));
3995 xg_tool_bar_callback (wbutton, client_data);
3999 static gboolean
4000 xg_tool_bar_help_callback (GtkWidget *w,
4001 GdkEventCrossing *event,
4002 gpointer client_data);
4004 /* This callback is called when a help is to be shown for an item in
4005 the detached tool bar when the detached tool bar it is not expanded. */
4007 static gboolean
4008 xg_tool_bar_proxy_help_callback (GtkWidget *w,
4009 GdkEventCrossing *event,
4010 gpointer client_data)
4012 GtkWidget *wbutton = GTK_WIDGET (g_object_get_data (G_OBJECT (w),
4013 XG_TOOL_BAR_PROXY_BUTTON));
4015 return xg_tool_bar_help_callback (wbutton, event, client_data);
4018 static GtkWidget *
4019 xg_get_tool_bar_widgets (GtkWidget *vb, GtkWidget **wimage)
4021 GList *clist = gtk_container_get_children (GTK_CONTAINER (vb));
4022 GtkWidget *c1 = clist->data;
4023 GtkWidget *c2 = clist->next ? clist->next->data : NULL;
4025 *wimage = GTK_IS_IMAGE (c1) ? c1 : c2;
4026 g_list_free (clist);
4027 return GTK_IS_LABEL (c1) ? c1 : c2;
4031 /* This callback is called when a tool item should create a proxy item,
4032 such as for the overflow menu. Also called when the tool bar is detached.
4033 If we don't create a proxy menu item, the detached tool bar will be
4034 blank. */
4036 static gboolean
4037 xg_tool_bar_menu_proxy (GtkToolItem *toolitem, gpointer user_data)
4039 GtkButton *wbutton = GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem)));
4040 GtkWidget *vb = XG_BIN_CHILD (wbutton);
4041 GtkWidget *c1;
4042 GtkLabel *wlbl = GTK_LABEL (xg_get_tool_bar_widgets (vb, &c1));
4043 GtkImage *wimage = GTK_IMAGE (c1);
4044 GtkWidget *wmenuitem = gtk_image_menu_item_new_with_label
4045 (wlbl ? gtk_label_get_text (wlbl) : "");
4046 GtkWidget *wmenuimage;
4049 if (gtk_button_get_use_stock (wbutton))
4050 wmenuimage = gtk_image_new_from_stock (gtk_button_get_label (wbutton),
4051 GTK_ICON_SIZE_MENU);
4052 else
4054 GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (wbutton));
4055 GtkImageType store_type = gtk_image_get_storage_type (wimage);
4057 g_object_set (G_OBJECT (settings), "gtk-menu-images", TRUE, NULL);
4059 if (store_type == GTK_IMAGE_STOCK)
4061 gchar *stock_id;
4062 gtk_image_get_stock (wimage, &stock_id, NULL);
4063 wmenuimage = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);
4065 else if (store_type == GTK_IMAGE_ICON_SET)
4067 GtkIconSet *icon_set;
4068 gtk_image_get_icon_set (wimage, &icon_set, NULL);
4069 wmenuimage = gtk_image_new_from_icon_set (icon_set,
4070 GTK_ICON_SIZE_MENU);
4072 else if (store_type == GTK_IMAGE_PIXBUF)
4074 gint width, height;
4076 if (settings &&
4077 gtk_icon_size_lookup_for_settings (settings, GTK_ICON_SIZE_MENU,
4078 &width, &height))
4080 GdkPixbuf *src_pixbuf, *dest_pixbuf;
4082 src_pixbuf = gtk_image_get_pixbuf (wimage);
4083 dest_pixbuf = gdk_pixbuf_scale_simple (src_pixbuf, width, height,
4084 GDK_INTERP_BILINEAR);
4086 wmenuimage = gtk_image_new_from_pixbuf (dest_pixbuf);
4088 else
4090 fprintf (stderr, "internal error: GTK_IMAGE_PIXBUF failed\n");
4091 emacs_abort ();
4094 else if (store_type == GTK_IMAGE_ICON_NAME)
4096 const gchar *icon_name;
4097 GtkIconSize icon_size;
4099 gtk_image_get_icon_name (wimage, &icon_name, &icon_size);
4100 wmenuimage = gtk_image_new_from_icon_name (icon_name,
4101 GTK_ICON_SIZE_MENU);
4103 else
4105 fprintf (stderr, "internal error: store_type is %d\n", store_type);
4106 emacs_abort ();
4109 if (wmenuimage)
4110 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem), wmenuimage);
4112 g_signal_connect (G_OBJECT (wmenuitem),
4113 "activate",
4114 G_CALLBACK (xg_tool_bar_proxy_callback),
4115 user_data);
4118 g_object_set_data (G_OBJECT (wmenuitem), XG_TOOL_BAR_PROXY_BUTTON,
4119 (gpointer) wbutton);
4120 gtk_tool_item_set_proxy_menu_item (toolitem, "Emacs toolbar item", wmenuitem);
4121 gtk_widget_set_sensitive (wmenuitem,
4122 gtk_widget_get_sensitive (GTK_WIDGET (wbutton)));
4124 /* Use enter/leave notify to show help. We use the events
4125 rather than the GtkButton specific signals "enter" and
4126 "leave", so we can have only one callback. The event
4127 will tell us what kind of event it is. */
4128 g_signal_connect (G_OBJECT (wmenuitem),
4129 "enter-notify-event",
4130 G_CALLBACK (xg_tool_bar_proxy_help_callback),
4131 user_data);
4132 g_signal_connect (G_OBJECT (wmenuitem),
4133 "leave-notify-event",
4134 G_CALLBACK (xg_tool_bar_proxy_help_callback),
4135 user_data);
4137 return TRUE;
4140 /* This callback is called when a tool bar is detached. We must set
4141 the height of the tool bar to zero when this happens so frame sizes
4142 are correctly calculated.
4143 WBOX is the handle box widget that enables detach/attach of the tool bar.
4144 W is the tool bar widget.
4145 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4147 static void
4148 xg_tool_bar_detach_callback (GtkHandleBox *wbox,
4149 GtkWidget *w,
4150 gpointer client_data)
4152 struct frame *f = client_data;
4154 g_object_set (G_OBJECT (w), "show-arrow", !x_gtk_whole_detached_tool_bar,
4155 NULL);
4157 if (f)
4159 GtkRequisition req, req2;
4161 gtk_widget_get_preferred_size (GTK_WIDGET (wbox), NULL, &req);
4162 gtk_widget_get_preferred_size (w, NULL, &req2);
4163 req.width -= req2.width;
4164 req.height -= req2.height;
4165 if (FRAME_TOOLBAR_TOP_HEIGHT (f) != 0)
4166 FRAME_TOOLBAR_TOP_HEIGHT (f) = req.height;
4167 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f) != 0)
4168 FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = req.height;
4169 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f) != 0)
4170 FRAME_TOOLBAR_RIGHT_WIDTH (f) = req.width;
4171 else if (FRAME_TOOLBAR_LEFT_WIDTH (f) != 0)
4172 FRAME_TOOLBAR_LEFT_WIDTH (f) = req.width;
4173 xg_height_or_width_changed (f);
4177 /* This callback is called when a tool bar is reattached. We must set
4178 the height of the tool bar when this happens so frame sizes
4179 are correctly calculated.
4180 WBOX is the handle box widget that enables detach/attach of the tool bar.
4181 W is the tool bar widget.
4182 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4184 static void
4185 xg_tool_bar_attach_callback (GtkHandleBox *wbox,
4186 GtkWidget *w,
4187 gpointer client_data)
4189 struct frame *f = client_data;
4190 g_object_set (G_OBJECT (w), "show-arrow", TRUE, NULL);
4192 if (f)
4194 GtkRequisition req, req2;
4196 gtk_widget_get_preferred_size (GTK_WIDGET (wbox), NULL, &req);
4197 gtk_widget_get_preferred_size (w, NULL, &req2);
4198 req.width += req2.width;
4199 req.height += req2.height;
4200 if (FRAME_TOOLBAR_TOP_HEIGHT (f) != 0)
4201 FRAME_TOOLBAR_TOP_HEIGHT (f) = req.height;
4202 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f) != 0)
4203 FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = req.height;
4204 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f) != 0)
4205 FRAME_TOOLBAR_RIGHT_WIDTH (f) = req.width;
4206 else if (FRAME_TOOLBAR_LEFT_WIDTH (f) != 0)
4207 FRAME_TOOLBAR_LEFT_WIDTH (f) = req.width;
4208 xg_height_or_width_changed (f);
4212 /* This callback is called when the mouse enters or leaves a tool bar item.
4213 It is used for displaying and hiding the help text.
4214 W is the tool bar item, a button.
4215 EVENT is either an enter event or leave event.
4216 CLIENT_DATA is an integer that is the index of the button in the
4217 tool bar. 0 is the first button.
4219 Returns FALSE to tell GTK to keep processing this event. */
4221 static gboolean
4222 xg_tool_bar_help_callback (GtkWidget *w,
4223 GdkEventCrossing *event,
4224 gpointer client_data)
4226 intptr_t idx = (intptr_t) client_data;
4227 struct frame *f = g_object_get_data (G_OBJECT (w), XG_FRAME_DATA);
4228 Lisp_Object help, frame;
4230 if (! f || ! f->n_tool_bar_items || NILP (f->tool_bar_items))
4231 return FALSE;
4233 if (event->type == GDK_ENTER_NOTIFY)
4235 idx *= TOOL_BAR_ITEM_NSLOTS;
4236 help = AREF (f->tool_bar_items, idx + TOOL_BAR_ITEM_HELP);
4238 if (NILP (help))
4239 help = AREF (f->tool_bar_items, idx + TOOL_BAR_ITEM_CAPTION);
4241 else
4242 help = Qnil;
4244 XSETFRAME (frame, f);
4245 kbd_buffer_store_help_event (frame, help);
4247 return FALSE;
4251 /* This callback is called when a tool bar item shall be redrawn.
4252 It modifies the expose event so that the GtkImage widget redraws the
4253 whole image. This to overcome a bug that makes GtkImage draw the image
4254 in the wrong place when it tries to redraw just a part of the image.
4255 W is the GtkImage to be redrawn.
4256 EVENT is the expose event for W.
4257 CLIENT_DATA is unused.
4259 Returns FALSE to tell GTK to keep processing this event. */
4261 #ifndef HAVE_GTK3
4262 static gboolean
4263 xg_tool_bar_item_expose_callback (GtkWidget *w,
4264 GdkEventExpose *event,
4265 gpointer client_data)
4267 gint width, height;
4269 gdk_drawable_get_size (event->window, &width, &height);
4270 event->area.x -= width > event->area.width ? width-event->area.width : 0;
4271 event->area.y -= height > event->area.height ? height-event->area.height : 0;
4273 event->area.x = max (0, event->area.x);
4274 event->area.y = max (0, event->area.y);
4276 event->area.width = max (width, event->area.width);
4277 event->area.height = max (height, event->area.height);
4279 return FALSE;
4281 #endif
4283 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4284 #define toolbar_set_orientation(w, o) \
4285 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4286 #else
4287 #define toolbar_set_orientation(w, o) \
4288 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4289 #endif
4291 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4292 #define TOOLBAR_TOP_WIDGET(x) ((x)->handlebox_widget)
4293 #else
4294 #define TOOLBAR_TOP_WIDGET(x) ((x)->toolbar_widget)
4295 #endif
4297 /* Attach a tool bar to frame F. */
4299 static void
4300 xg_pack_tool_bar (struct frame *f, Lisp_Object pos)
4302 struct x_output *x = f->output_data.x;
4303 bool into_hbox = EQ (pos, Qleft) || EQ (pos, Qright);
4304 GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
4306 toolbar_set_orientation (x->toolbar_widget,
4307 into_hbox
4308 ? GTK_ORIENTATION_VERTICAL
4309 : GTK_ORIENTATION_HORIZONTAL);
4310 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4311 if (!x->handlebox_widget)
4313 top_widget = x->handlebox_widget = gtk_handle_box_new ();
4314 g_signal_connect (G_OBJECT (x->handlebox_widget), "child-detached",
4315 G_CALLBACK (xg_tool_bar_detach_callback), f);
4316 g_signal_connect (G_OBJECT (x->handlebox_widget), "child-attached",
4317 G_CALLBACK (xg_tool_bar_attach_callback), f);
4318 gtk_container_add (GTK_CONTAINER (x->handlebox_widget),
4319 x->toolbar_widget);
4321 #endif
4323 if (into_hbox)
4325 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4326 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x->handlebox_widget),
4327 GTK_POS_TOP);
4328 #endif
4329 gtk_box_pack_start (GTK_BOX (x->hbox_widget), top_widget,
4330 FALSE, FALSE, 0);
4332 if (EQ (pos, Qleft))
4333 gtk_box_reorder_child (GTK_BOX (x->hbox_widget),
4334 top_widget,
4336 x->toolbar_in_hbox = true;
4338 else
4340 bool vbox_pos = x->menubar_widget != 0;
4341 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4342 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x->handlebox_widget),
4343 GTK_POS_LEFT);
4344 #endif
4345 gtk_box_pack_start (GTK_BOX (x->vbox_widget), top_widget,
4346 FALSE, FALSE, 0);
4348 if (EQ (pos, Qtop))
4349 gtk_box_reorder_child (GTK_BOX (x->vbox_widget),
4350 top_widget,
4351 vbox_pos);
4352 x->toolbar_in_hbox = false;
4354 x->toolbar_is_packed = true;
4357 static bool xg_update_tool_bar_sizes (struct frame *f);
4359 static void
4360 tb_size_cb (GtkWidget *widget,
4361 GdkRectangle *allocation,
4362 gpointer user_data)
4364 /* When tool bar is created it has one preferred size. But when size is
4365 allocated between widgets, it may get another. So we must update
4366 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4367 struct frame *f = user_data;
4368 if (xg_update_tool_bar_sizes (f))
4369 x_wm_set_size_hint (f, 0, 0);
4372 /* Create a tool bar for frame F. */
4374 static void
4375 xg_create_tool_bar (struct frame *f)
4377 struct x_output *x = f->output_data.x;
4378 #if GTK_CHECK_VERSION (3, 3, 6)
4379 GtkStyleContext *gsty;
4380 #endif
4381 struct xg_frame_tb_info *tbinfo
4382 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
4383 TB_INFO_KEY);
4384 if (! tbinfo)
4386 tbinfo = xmalloc (sizeof (*tbinfo));
4387 tbinfo->last_tool_bar = Qnil;
4388 tbinfo->style = Qnil;
4389 tbinfo->hmargin = tbinfo->vmargin = 0;
4390 tbinfo->dir = GTK_TEXT_DIR_NONE;
4391 tbinfo->n_last_items = 0;
4392 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
4393 TB_INFO_KEY,
4394 tbinfo);
4397 x->toolbar_widget = gtk_toolbar_new ();
4399 gtk_widget_set_name (x->toolbar_widget, "emacs-toolbar");
4401 gtk_toolbar_set_style (GTK_TOOLBAR (x->toolbar_widget), GTK_TOOLBAR_ICONS);
4402 toolbar_set_orientation (x->toolbar_widget, GTK_ORIENTATION_HORIZONTAL);
4403 g_signal_connect (x->toolbar_widget, "size-allocate",
4404 G_CALLBACK (tb_size_cb), f);
4405 #if GTK_CHECK_VERSION (3, 3, 6)
4406 gsty = gtk_widget_get_style_context (x->toolbar_widget);
4407 gtk_style_context_add_class (gsty, "primary-toolbar");
4408 #endif
4412 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4414 /* Find the right-to-left image named by RTL in the tool bar images for F.
4415 Returns IMAGE if RTL is not found. */
4417 static Lisp_Object
4418 find_rtl_image (struct frame *f, Lisp_Object image, Lisp_Object rtl)
4420 int i;
4421 Lisp_Object file, rtl_name;
4422 struct gcpro gcpro1, gcpro2;
4423 GCPRO2 (file, rtl_name);
4425 rtl_name = Ffile_name_nondirectory (rtl);
4427 for (i = 0; i < f->n_tool_bar_items; ++i)
4429 Lisp_Object rtl_image = PROP (TOOL_BAR_ITEM_IMAGES);
4430 if (!NILP (file = file_for_image (rtl_image)))
4432 file = call1 (intern ("file-name-sans-extension"),
4433 Ffile_name_nondirectory (file));
4434 if (! NILP (Fequal (file, rtl_name)))
4436 image = rtl_image;
4437 break;
4442 return image;
4445 static GtkToolItem *
4446 xg_make_tool_item (struct frame *f,
4447 GtkWidget *wimage,
4448 GtkWidget **wbutton,
4449 const char *label,
4450 int i, bool horiz, bool text_image)
4452 GtkToolItem *ti = gtk_tool_item_new ();
4453 GtkWidget *vb = gtk_box_new (horiz
4454 ? GTK_ORIENTATION_HORIZONTAL
4455 : GTK_ORIENTATION_VERTICAL,
4457 GtkWidget *wb = gtk_button_new ();
4458 /* The eventbox is here so we can have tooltips on disabled items. */
4459 GtkWidget *weventbox = gtk_event_box_new ();
4460 #if GTK_CHECK_VERSION (3, 3, 6)
4461 GtkCssProvider *css_prov = gtk_css_provider_new ();
4462 GtkStyleContext *gsty;
4464 gtk_css_provider_load_from_data (css_prov,
4465 "GtkEventBox {"
4466 " background-color: transparent;"
4467 "}",
4468 -1, NULL);
4470 gsty = gtk_widget_get_style_context (weventbox);
4471 gtk_style_context_add_provider (gsty,
4472 GTK_STYLE_PROVIDER (css_prov),
4473 GTK_STYLE_PROVIDER_PRIORITY_USER);
4474 g_object_unref (css_prov);
4475 #endif
4477 gtk_box_set_homogeneous (GTK_BOX (vb), FALSE);
4479 if (wimage && !text_image)
4480 gtk_box_pack_start (GTK_BOX (vb), wimage, TRUE, TRUE, 0);
4481 if (label)
4482 gtk_box_pack_start (GTK_BOX (vb), gtk_label_new (label), TRUE, TRUE, 0);
4483 if (wimage && text_image)
4484 gtk_box_pack_start (GTK_BOX (vb), wimage, TRUE, TRUE, 0);
4486 gtk_button_set_focus_on_click (GTK_BUTTON (wb), FALSE);
4487 gtk_button_set_relief (GTK_BUTTON (wb), GTK_RELIEF_NONE);
4488 gtk_container_add (GTK_CONTAINER (wb), vb);
4489 gtk_container_add (GTK_CONTAINER (weventbox), wb);
4490 gtk_container_add (GTK_CONTAINER (ti), weventbox);
4492 if (wimage || label)
4494 intptr_t ii = i;
4495 gpointer gi = (gpointer) ii;
4497 g_signal_connect (G_OBJECT (ti), "create-menu-proxy",
4498 G_CALLBACK (xg_tool_bar_menu_proxy),
4499 gi);
4501 g_signal_connect (G_OBJECT (wb), "clicked",
4502 G_CALLBACK (xg_tool_bar_callback),
4503 gi);
4505 g_object_set_data (G_OBJECT (weventbox), XG_FRAME_DATA, (gpointer)f);
4507 #ifndef HAVE_GTK3
4508 /* Catch expose events to overcome an annoying redraw bug, see
4509 comment for xg_tool_bar_item_expose_callback. */
4510 g_signal_connect (G_OBJECT (ti),
4511 "expose-event",
4512 G_CALLBACK (xg_tool_bar_item_expose_callback),
4514 #endif
4515 gtk_tool_item_set_homogeneous (ti, FALSE);
4517 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4518 no distinction based on modifiers in the activate callback,
4519 so we have to do it ourselves. */
4520 g_signal_connect (wb, "button-release-event",
4521 G_CALLBACK (xg_tool_bar_button_cb),
4522 NULL);
4524 g_object_set_data (G_OBJECT (wb), XG_FRAME_DATA, (gpointer)f);
4526 /* Use enter/leave notify to show help. We use the events
4527 rather than the GtkButton specific signals "enter" and
4528 "leave", so we can have only one callback. The event
4529 will tell us what kind of event it is. */
4530 g_signal_connect (G_OBJECT (weventbox),
4531 "enter-notify-event",
4532 G_CALLBACK (xg_tool_bar_help_callback),
4533 gi);
4534 g_signal_connect (G_OBJECT (weventbox),
4535 "leave-notify-event",
4536 G_CALLBACK (xg_tool_bar_help_callback),
4537 gi);
4540 if (wbutton) *wbutton = wb;
4542 return ti;
4545 static bool
4546 is_box_type (GtkWidget *vb, bool is_horizontal)
4548 #ifdef HAVE_GTK3
4549 bool ret = 0;
4550 if (GTK_IS_BOX (vb))
4552 GtkOrientation ori = gtk_orientable_get_orientation (GTK_ORIENTABLE (vb));
4553 ret = (ori == GTK_ORIENTATION_HORIZONTAL && is_horizontal)
4554 || (ori == GTK_ORIENTATION_VERTICAL && ! is_horizontal);
4556 return ret;
4557 #else
4558 return is_horizontal ? GTK_IS_VBOX (vb) : GTK_IS_HBOX (vb);
4559 #endif
4563 static bool
4564 xg_tool_item_stale_p (GtkWidget *wbutton, const char *stock_name,
4565 const char *icon_name, const struct image *img,
4566 const char *label, bool horiz)
4568 gpointer old;
4569 GtkWidget *wimage;
4570 GtkWidget *vb = XG_BIN_CHILD (wbutton);
4571 GtkWidget *wlbl = xg_get_tool_bar_widgets (vb, &wimage);
4573 /* Check if the tool icon matches. */
4574 if (stock_name && wimage)
4576 old = g_object_get_data (G_OBJECT (wimage),
4577 XG_TOOL_BAR_STOCK_NAME);
4578 if (!old || strcmp (old, stock_name))
4579 return 1;
4581 else if (icon_name && wimage)
4583 old = g_object_get_data (G_OBJECT (wimage),
4584 XG_TOOL_BAR_ICON_NAME);
4585 if (!old || strcmp (old, icon_name))
4586 return 1;
4588 else if (wimage)
4590 gpointer gold_img = g_object_get_data (G_OBJECT (wimage),
4591 XG_TOOL_BAR_IMAGE_DATA);
4592 Pixmap old_img = (Pixmap) gold_img;
4593 if (old_img != img->pixmap)
4594 return 1;
4597 /* Check button configuration and label. */
4598 if (is_box_type (vb, horiz)
4599 || (label ? (wlbl == NULL) : (wlbl != NULL)))
4600 return 1;
4602 /* Ensure label is correct. */
4603 if (label && wlbl)
4604 gtk_label_set_text (GTK_LABEL (wlbl), label);
4605 return 0;
4608 static bool
4609 xg_update_tool_bar_sizes (struct frame *f)
4611 struct x_output *x = f->output_data.x;
4612 GtkRequisition req;
4613 int nl = 0, nr = 0, nt = 0, nb = 0;
4614 GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
4616 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget), NULL, &req);
4617 if (x->toolbar_in_hbox)
4619 int pos;
4620 gtk_container_child_get (GTK_CONTAINER (x->hbox_widget),
4621 top_widget,
4622 "position", &pos, NULL);
4623 if (pos == 0) nl = req.width;
4624 else nr = req.width;
4626 else
4628 int pos;
4629 gtk_container_child_get (GTK_CONTAINER (x->vbox_widget),
4630 top_widget,
4631 "position", &pos, NULL);
4632 if (pos == 0 || (pos == 1 && x->menubar_widget)) nt = req.height;
4633 else nb = req.height;
4636 if (nl != FRAME_TOOLBAR_LEFT_WIDTH (f)
4637 || nr != FRAME_TOOLBAR_RIGHT_WIDTH (f)
4638 || nt != FRAME_TOOLBAR_TOP_HEIGHT (f)
4639 || nb != FRAME_TOOLBAR_BOTTOM_HEIGHT (f))
4641 FRAME_TOOLBAR_RIGHT_WIDTH (f) = FRAME_TOOLBAR_LEFT_WIDTH (f)
4642 = FRAME_TOOLBAR_TOP_HEIGHT (f) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = 0;
4643 FRAME_TOOLBAR_LEFT_WIDTH (f) = nl;
4644 FRAME_TOOLBAR_RIGHT_WIDTH (f) = nr;
4645 FRAME_TOOLBAR_TOP_HEIGHT (f) = nt;
4646 FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = nb;
4647 return 1;
4650 return 0;
4654 /* Update the tool bar for frame F. Add new buttons and remove old. */
4656 void
4657 update_frame_tool_bar (struct frame *f)
4659 int i, j;
4660 struct x_output *x = f->output_data.x;
4661 int hmargin = 0, vmargin = 0;
4662 GtkToolbar *wtoolbar;
4663 GtkToolItem *ti;
4664 GtkTextDirection dir;
4665 Lisp_Object style;
4666 bool text_image, horiz;
4667 struct xg_frame_tb_info *tbinfo;
4669 if (! FRAME_GTK_WIDGET (f))
4670 return;
4672 block_input ();
4674 if (RANGED_INTEGERP (1, Vtool_bar_button_margin, INT_MAX))
4676 hmargin = XFASTINT (Vtool_bar_button_margin);
4677 vmargin = XFASTINT (Vtool_bar_button_margin);
4679 else if (CONSP (Vtool_bar_button_margin))
4681 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin), INT_MAX))
4682 hmargin = XFASTINT (XCAR (Vtool_bar_button_margin));
4684 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin), INT_MAX))
4685 vmargin = XFASTINT (XCDR (Vtool_bar_button_margin));
4688 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4689 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4690 i.e. zero. This means that margins less than
4691 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4692 hmargin = max (0, hmargin - DEFAULT_TOOL_BAR_BUTTON_MARGIN);
4693 vmargin = max (0, vmargin - DEFAULT_TOOL_BAR_BUTTON_MARGIN);
4695 if (! x->toolbar_widget)
4696 xg_create_tool_bar (f);
4698 wtoolbar = GTK_TOOLBAR (x->toolbar_widget);
4699 dir = gtk_widget_get_direction (GTK_WIDGET (wtoolbar));
4701 style = Ftool_bar_get_system_style ();
4703 /* Are we up to date? */
4704 tbinfo = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
4705 TB_INFO_KEY);
4707 if (! NILP (tbinfo->last_tool_bar) && ! NILP (f->tool_bar_items)
4708 && tbinfo->n_last_items == f->n_tool_bar_items
4709 && tbinfo->hmargin == hmargin && tbinfo->vmargin == vmargin
4710 && tbinfo->dir == dir
4711 && ! NILP (Fequal (tbinfo->style, style))
4712 && ! NILP (Fequal (tbinfo->last_tool_bar, f->tool_bar_items)))
4714 unblock_input ();
4715 return;
4718 tbinfo->last_tool_bar = f->tool_bar_items;
4719 tbinfo->n_last_items = f->n_tool_bar_items;
4720 tbinfo->style = style;
4721 tbinfo->hmargin = hmargin;
4722 tbinfo->vmargin = vmargin;
4723 tbinfo->dir = dir;
4725 text_image = EQ (style, Qtext_image_horiz);
4726 horiz = EQ (style, Qboth_horiz) || text_image;
4728 for (i = j = 0; i < f->n_tool_bar_items; ++i)
4730 bool enabled_p = !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P));
4731 bool selected_p = !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P));
4732 int idx;
4733 ptrdiff_t img_id;
4734 int icon_size = 0;
4735 struct image *img = NULL;
4736 Lisp_Object image;
4737 Lisp_Object stock = Qnil;
4738 GtkStockItem stock_item;
4739 char *stock_name = NULL;
4740 char *icon_name = NULL;
4741 Lisp_Object rtl;
4742 GtkWidget *wbutton = NULL;
4743 Lisp_Object specified_file;
4744 bool vert_only = ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY));
4745 const char *label
4746 = (EQ (style, Qimage) || (vert_only && horiz)) ? NULL
4747 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL))
4748 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL))
4749 : "";
4751 ti = gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar), j);
4753 /* If this is a separator, use a gtk separator item. */
4754 if (EQ (PROP (TOOL_BAR_ITEM_TYPE), Qt))
4756 if (ti == NULL || !GTK_IS_SEPARATOR_TOOL_ITEM (ti))
4758 if (ti)
4759 gtk_container_remove (GTK_CONTAINER (wtoolbar),
4760 GTK_WIDGET (ti));
4761 ti = gtk_separator_tool_item_new ();
4762 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar), ti, j);
4764 j++;
4765 continue;
4768 /* Otherwise, the tool-bar item is an ordinary button. */
4770 if (ti && GTK_IS_SEPARATOR_TOOL_ITEM (ti))
4772 gtk_container_remove (GTK_CONTAINER (wtoolbar), GTK_WIDGET (ti));
4773 ti = NULL;
4776 if (ti) wbutton = XG_BIN_CHILD (XG_BIN_CHILD (ti));
4778 /* Ignore invalid image specifications. */
4779 image = PROP (TOOL_BAR_ITEM_IMAGES);
4780 if (!valid_image_p (image))
4782 if (ti)
4783 gtk_container_remove (GTK_CONTAINER (wtoolbar),
4784 GTK_WIDGET (ti));
4785 continue;
4788 specified_file = file_for_image (image);
4789 if (!NILP (specified_file) && !NILP (Ffboundp (Qx_gtk_map_stock)))
4790 stock = call1 (Qx_gtk_map_stock, specified_file);
4792 if (STRINGP (stock))
4794 stock_name = SSDATA (stock);
4795 if (stock_name[0] == 'n' && stock_name[1] == ':')
4797 GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (wtoolbar));
4798 GtkIconTheme *icon_theme = gtk_icon_theme_get_for_screen (screen);
4800 icon_name = stock_name + 2;
4801 stock_name = NULL;
4802 stock = Qnil;
4804 if (! gtk_icon_theme_has_icon (icon_theme, icon_name))
4805 icon_name = NULL;
4806 else
4807 icon_size = gtk_toolbar_get_icon_size (wtoolbar);
4809 else if (gtk_stock_lookup (SSDATA (stock), &stock_item))
4810 icon_size = gtk_toolbar_get_icon_size (wtoolbar);
4811 else
4813 stock = Qnil;
4814 stock_name = NULL;
4818 if (stock_name == NULL && icon_name == NULL)
4820 /* No stock image, or stock item not known. Try regular
4821 image. If image is a vector, choose it according to the
4822 button state. */
4823 if (dir == GTK_TEXT_DIR_RTL
4824 && !NILP (rtl = PROP (TOOL_BAR_ITEM_RTL_IMAGE))
4825 && STRINGP (rtl))
4826 image = find_rtl_image (f, image, rtl);
4828 if (VECTORP (image))
4830 if (enabled_p)
4831 idx = (selected_p
4832 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4833 : TOOL_BAR_IMAGE_ENABLED_DESELECTED);
4834 else
4835 idx = (selected_p
4836 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4837 : TOOL_BAR_IMAGE_DISABLED_DESELECTED);
4839 eassert (ASIZE (image) >= idx);
4840 image = AREF (image, idx);
4842 else
4843 idx = -1;
4845 img_id = lookup_image (f, image);
4846 img = IMAGE_FROM_ID (f, img_id);
4847 prepare_image_for_display (f, img);
4849 if (img->load_failed_p || img->pixmap == None)
4851 if (ti)
4852 gtk_container_remove (GTK_CONTAINER (wtoolbar),
4853 GTK_WIDGET (ti));
4854 continue;
4858 /* If there is an existing widget, check if it's stale; if so,
4859 remove it and make a new tool item from scratch. */
4860 if (ti && xg_tool_item_stale_p (wbutton, stock_name, icon_name,
4861 img, label, horiz))
4863 gtk_container_remove (GTK_CONTAINER (wtoolbar),
4864 GTK_WIDGET (ti));
4865 ti = NULL;
4868 if (ti == NULL)
4870 GtkWidget *w;
4872 /* Save the image so we can see if an update is needed the
4873 next time we call xg_tool_item_match_p. */
4874 if (EQ (style, Qtext))
4875 w = NULL;
4876 else if (stock_name)
4878 w = gtk_image_new_from_stock (stock_name, icon_size);
4879 g_object_set_data_full (G_OBJECT (w), XG_TOOL_BAR_STOCK_NAME,
4880 (gpointer) xstrdup (stock_name),
4881 (GDestroyNotify) xfree);
4883 else if (icon_name)
4885 w = gtk_image_new_from_icon_name (icon_name, icon_size);
4886 g_object_set_data_full (G_OBJECT (w), XG_TOOL_BAR_ICON_NAME,
4887 (gpointer) xstrdup (icon_name),
4888 (GDestroyNotify) xfree);
4890 else
4892 w = xg_get_image_for_pixmap (f, img, x->widget, NULL);
4893 g_object_set_data (G_OBJECT (w), XG_TOOL_BAR_IMAGE_DATA,
4894 (gpointer)img->pixmap);
4897 if (w) gtk_misc_set_padding (GTK_MISC (w), hmargin, vmargin);
4898 ti = xg_make_tool_item (f, w, &wbutton, label, i, horiz, text_image);
4899 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar), ti, j);
4902 #undef PROP
4904 gtk_widget_set_sensitive (wbutton, enabled_p);
4905 j++;
4908 /* Remove buttons not longer needed. */
4911 ti = gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar), j);
4912 if (ti)
4913 gtk_container_remove (GTK_CONTAINER (wtoolbar), GTK_WIDGET (ti));
4914 } while (ti != NULL);
4916 if (f->n_tool_bar_items != 0)
4918 if (! x->toolbar_is_packed)
4919 xg_pack_tool_bar (f, f->tool_bar_position);
4920 gtk_widget_show_all (TOOLBAR_TOP_WIDGET (x));
4921 if (xg_update_tool_bar_sizes (f))
4922 xg_height_or_width_changed (f);
4925 unblock_input ();
4928 /* Deallocate all resources for the tool bar on frame F.
4929 Remove the tool bar. */
4931 void
4932 free_frame_tool_bar (struct frame *f)
4934 struct x_output *x = f->output_data.x;
4936 if (x->toolbar_widget)
4938 struct xg_frame_tb_info *tbinfo;
4939 GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
4941 block_input ();
4942 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4943 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4944 if (x->toolbar_is_packed)
4946 if (x->toolbar_in_hbox)
4947 gtk_container_remove (GTK_CONTAINER (x->hbox_widget),
4948 top_widget);
4949 else
4950 gtk_container_remove (GTK_CONTAINER (x->vbox_widget),
4951 top_widget);
4953 else
4954 gtk_widget_destroy (x->toolbar_widget);
4956 x->toolbar_widget = 0;
4957 TOOLBAR_TOP_WIDGET (x) = 0;
4958 x->toolbar_is_packed = false;
4959 FRAME_TOOLBAR_TOP_HEIGHT (f) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = 0;
4960 FRAME_TOOLBAR_LEFT_WIDTH (f) = FRAME_TOOLBAR_RIGHT_WIDTH (f) = 0;
4962 tbinfo = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
4963 TB_INFO_KEY);
4964 if (tbinfo)
4966 xfree (tbinfo);
4967 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
4968 TB_INFO_KEY,
4969 NULL);
4972 xg_height_or_width_changed (f);
4974 unblock_input ();
4978 void
4979 xg_change_toolbar_position (struct frame *f, Lisp_Object pos)
4981 struct x_output *x = f->output_data.x;
4982 GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
4984 if (! x->toolbar_widget || ! top_widget)
4985 return;
4987 block_input ();
4988 g_object_ref (top_widget);
4989 if (x->toolbar_is_packed)
4991 if (x->toolbar_in_hbox)
4992 gtk_container_remove (GTK_CONTAINER (x->hbox_widget),
4993 top_widget);
4994 else
4995 gtk_container_remove (GTK_CONTAINER (x->vbox_widget),
4996 top_widget);
4999 xg_pack_tool_bar (f, pos);
5000 g_object_unref (top_widget);
5001 if (xg_update_tool_bar_sizes (f))
5002 xg_height_or_width_changed (f);
5004 unblock_input ();
5009 /***********************************************************************
5010 Initializing
5011 ***********************************************************************/
5012 void
5013 xg_initialize (void)
5015 GtkBindingSet *binding_set;
5016 GtkSettings *settings;
5018 #if HAVE_XFT
5019 /* Work around a bug with corrupted data if libXft gets unloaded. This way
5020 we keep it permanently linked in. */
5021 XftInit (0);
5022 #endif
5024 gdpy_def = NULL;
5025 xg_ignore_gtk_scrollbar = 0;
5026 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
5027 xg_detached_menus = 0;
5028 #endif
5029 xg_menu_cb_list.prev = xg_menu_cb_list.next =
5030 xg_menu_item_cb_list.prev = xg_menu_item_cb_list.next = 0;
5032 id_to_widget.max_size = id_to_widget.used = 0;
5033 id_to_widget.widgets = 0;
5035 settings = gtk_settings_get_for_screen (gdk_display_get_default_screen
5036 (gdk_display_get_default ()));
5037 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5038 bindings. It doesn't seem to be any way to remove properties,
5039 so we set it to "" which in means "no key". */
5040 gtk_settings_set_string_property (settings,
5041 "gtk-menu-bar-accel",
5043 EMACS_CLASS);
5045 /* Make GTK text input widgets use Emacs style keybindings. This is
5046 Emacs after all. */
5047 gtk_settings_set_string_property (settings,
5048 "gtk-key-theme-name",
5049 "Emacs",
5050 EMACS_CLASS);
5052 /* Make dialogs close on C-g. Since file dialog inherits from
5053 dialog, this works for them also. */
5054 binding_set = gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG));
5055 gtk_binding_entry_add_signal (binding_set, GDK_KEY_g, GDK_CONTROL_MASK,
5056 "close", 0);
5058 /* Make menus close on C-g. */
5059 binding_set = gtk_binding_set_by_class (g_type_class_ref
5060 (GTK_TYPE_MENU_SHELL));
5061 gtk_binding_entry_add_signal (binding_set, GDK_KEY_g, GDK_CONTROL_MASK,
5062 "cancel", 0);
5063 update_theme_scrollbar_width ();
5065 #ifdef HAVE_FREETYPE
5066 x_last_font_name = NULL;
5067 #endif
5070 #endif /* USE_GTK */