]> code.delx.au - gnu-emacs/blob - src/gtkutil.c
445e59c335def0d3f3b98873cbd8c21c8fbbf17d
[gnu-emacs] / src / gtkutil.c
1 /* Functions for creating and updating GTK widgets.
2
3 Copyright (C) 2003-2014 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
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.
11
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.
16
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/>. */
19
20 #include <config.h>
21
22 #ifdef USE_GTK
23 #include <float.h>
24 #include <stdio.h>
25
26 #include <c-ctype.h>
27
28 #include "lisp.h"
29 #include "xterm.h"
30 #include "blockinput.h"
31 #include "syssignal.h"
32 #include "window.h"
33 #include "buffer.h"
34 #include "gtkutil.h"
35 #include "termhooks.h"
36 #include "keyboard.h"
37 #include "charset.h"
38 #include "coding.h"
39 #include "font.h"
40
41 #include <gdk/gdkkeysyms.h>
42 #include "xsettings.h"
43
44 #ifdef HAVE_XFT
45 #include <X11/Xft/Xft.h>
46 #endif
47
48 #ifdef HAVE_GTK3
49 #include <gtk/gtkx.h>
50 #include "emacsgtkfixed.h"
51 #endif
52
53 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
54 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
55
56 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
57 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
58
59 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
60 #define gtk_widget_set_has_window(w, b) \
61 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
62 #endif
63 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
64 #define gtk_dialog_get_action_area(w) ((w)->action_area)
65 #define gtk_dialog_get_content_area(w) ((w)->vbox)
66 #endif
67 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
68 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
69 #endif
70 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
71 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
72 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
73 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
74 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
75 #endif
76 #if GTK_CHECK_VERSION (2, 12, 0)
77 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
78 #else
79 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
80 #endif
81
82 #ifdef HAVE_FREETYPE
83 #if GTK_CHECK_VERSION (3, 2, 0)
84 #define USE_NEW_GTK_FONT_CHOOSER 1
85 #else
86 #define USE_NEW_GTK_FONT_CHOOSER 0
87 #define gtk_font_chooser_dialog_new(x, y) \
88 gtk_font_selection_dialog_new (x)
89 #undef GTK_FONT_CHOOSER
90 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
91 #define gtk_font_chooser_set_font(x, y) \
92 gtk_font_selection_dialog_set_font_name (x, y)
93 #endif
94 #endif /* HAVE_FREETYPE */
95
96 #ifndef HAVE_GTK3
97 #ifdef USE_GTK_TOOLTIP
98 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
99 #endif
100 #define gdk_window_get_geometry(w, a, b, c, d) \
101 gdk_window_get_geometry (w, a, b, c, d, 0)
102 #define gdk_x11_window_lookup_for_display(d, w) \
103 gdk_xid_table_lookup_for_display (d, w)
104 #define gtk_box_new(ori, spacing) \
105 ((ori) == GTK_ORIENTATION_HORIZONTAL \
106 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
107 #define gtk_scrollbar_new(ori, spacing) \
108 ((ori) == GTK_ORIENTATION_HORIZONTAL \
109 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
110 #ifndef GDK_KEY_g
111 #define GDK_KEY_g GDK_g
112 #endif
113 #endif /* HAVE_GTK3 */
114
115 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
116
117 static void update_theme_scrollbar_width (void);
118 static void update_theme_scrollbar_height (void);
119
120 #define TB_INFO_KEY "xg_frame_tb_info"
121 struct xg_frame_tb_info
122 {
123 Lisp_Object last_tool_bar;
124 Lisp_Object style;
125 int n_last_items;
126 int hmargin, vmargin;
127 GtkTextDirection dir;
128 };
129
130 \f
131 /***********************************************************************
132 Display handling functions
133 ***********************************************************************/
134
135 /* Keep track of the default display, or NULL if there is none. Emacs
136 may close all its displays. */
137
138 static GdkDisplay *gdpy_def;
139
140 /* When the GTK widget W is to be created on a display for F that
141 is not the default display, set the display for W.
142 W can be a GtkMenu or a GtkWindow widget. */
143
144 static void
145 xg_set_screen (GtkWidget *w, struct frame *f)
146 {
147 if (FRAME_X_DISPLAY (f) != DEFAULT_GDK_DISPLAY ())
148 {
149 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
150 GdkScreen *gscreen = gdk_display_get_default_screen (gdpy);
151
152 if (GTK_IS_MENU (w))
153 gtk_menu_set_screen (GTK_MENU (w), gscreen);
154 else
155 gtk_window_set_screen (GTK_WINDOW (w), gscreen);
156 }
157 }
158
159
160 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
161 *DPY is set to NULL if the display can't be opened.
162
163 Returns non-zero if display could be opened, zero if display could not
164 be opened, and less than zero if the GTK version doesn't support
165 multiple displays. */
166
167 void
168 xg_display_open (char *display_name, Display **dpy)
169 {
170 GdkDisplay *gdpy;
171
172 gdpy = gdk_display_open (display_name);
173 if (!gdpy_def && gdpy)
174 {
175 gdpy_def = gdpy;
176 gdk_display_manager_set_default_display (gdk_display_manager_get (),
177 gdpy);
178 }
179
180 *dpy = gdpy ? GDK_DISPLAY_XDISPLAY (gdpy) : NULL;
181 }
182
183
184 /* Close display DPY. */
185
186 void
187 xg_display_close (Display *dpy)
188 {
189 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (dpy);
190
191 /* If this is the default display, try to change it before closing.
192 If there is no other display to use, gdpy_def is set to NULL, and
193 the next call to xg_display_open resets the default display. */
194 if (gdk_display_get_default () == gdpy)
195 {
196 struct x_display_info *dpyinfo;
197 GdkDisplay *gdpy_new = NULL;
198
199 /* Find another display. */
200 for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
201 if (dpyinfo->display != dpy)
202 {
203 gdpy_new = gdk_x11_lookup_xdisplay (dpyinfo->display);
204 gdk_display_manager_set_default_display (gdk_display_manager_get (),
205 gdpy_new);
206 break;
207 }
208 gdpy_def = gdpy_new;
209 }
210
211 #if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
212 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
213 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
214 can continue running, but there will be memory leaks. */
215 g_object_run_dispose (G_OBJECT (gdpy));
216 #else
217 /* This seems to be fixed in GTK 2.10. */
218 gdk_display_close (gdpy);
219 #endif
220 }
221
222 \f
223 /***********************************************************************
224 Utility functions
225 ***********************************************************************/
226
227 /* Create and return the cursor to be used for popup menus and
228 scroll bars on display DPY. */
229
230 GdkCursor *
231 xg_create_default_cursor (Display *dpy)
232 {
233 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (dpy);
234 return gdk_cursor_new_for_display (gdpy, GDK_LEFT_PTR);
235 }
236
237 static GdkPixbuf *
238 xg_get_pixbuf_from_pixmap (struct frame *f, Pixmap pix)
239 {
240 int iunused;
241 GdkPixbuf *tmp_buf;
242 Window wunused;
243 unsigned int width, height, uunused;
244 XImage *xim;
245
246 XGetGeometry (FRAME_X_DISPLAY (f), pix, &wunused, &iunused, &iunused,
247 &width, &height, &uunused, &uunused);
248
249 xim = XGetImage (FRAME_X_DISPLAY (f), pix, 0, 0, width, height,
250 ~0, XYPixmap);
251 if (!xim) return 0;
252
253 tmp_buf = gdk_pixbuf_new_from_data ((guchar *) xim->data,
254 GDK_COLORSPACE_RGB,
255 FALSE,
256 xim->bitmap_unit,
257 width,
258 height,
259 xim->bytes_per_line,
260 NULL,
261 NULL);
262 XDestroyImage (xim);
263 return tmp_buf;
264 }
265
266 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
267
268 static GdkPixbuf *
269 xg_get_pixbuf_from_pix_and_mask (struct frame *f,
270 Pixmap pix,
271 Pixmap mask)
272 {
273 int width, height;
274 GdkPixbuf *icon_buf, *tmp_buf;
275
276 tmp_buf = xg_get_pixbuf_from_pixmap (f, pix);
277 icon_buf = gdk_pixbuf_add_alpha (tmp_buf, FALSE, 0, 0, 0);
278 g_object_unref (G_OBJECT (tmp_buf));
279
280 width = gdk_pixbuf_get_width (icon_buf);
281 height = gdk_pixbuf_get_height (icon_buf);
282
283 if (mask)
284 {
285 GdkPixbuf *mask_buf = xg_get_pixbuf_from_pixmap (f, mask);
286 guchar *pixels = gdk_pixbuf_get_pixels (icon_buf);
287 guchar *mask_pixels = gdk_pixbuf_get_pixels (mask_buf);
288 int rowstride = gdk_pixbuf_get_rowstride (icon_buf);
289 int mask_rowstride = gdk_pixbuf_get_rowstride (mask_buf);
290 int y;
291
292 for (y = 0; y < height; ++y)
293 {
294 guchar *iconptr, *maskptr;
295 int x;
296
297 iconptr = pixels + y * rowstride;
298 maskptr = mask_pixels + y * mask_rowstride;
299
300 for (x = 0; x < width; ++x)
301 {
302 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
303 just R is sufficient. */
304 if (maskptr[0] == 0)
305 iconptr[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
306
307 iconptr += rowstride/width;
308 maskptr += mask_rowstride/width;
309 }
310 }
311
312 g_object_unref (G_OBJECT (mask_buf));
313 }
314
315 return icon_buf;
316 }
317
318 static Lisp_Object
319 file_for_image (Lisp_Object image)
320 {
321 Lisp_Object specified_file = Qnil;
322 Lisp_Object tail;
323
324 for (tail = XCDR (image);
325 NILP (specified_file) && CONSP (tail) && CONSP (XCDR (tail));
326 tail = XCDR (XCDR (tail)))
327 if (EQ (XCAR (tail), QCfile))
328 specified_file = XCAR (XCDR (tail));
329
330 return specified_file;
331 }
332
333 /* For the image defined in IMG, make and return a GtkImage. For displays with
334 8 planes or less we must make a GdkPixbuf and apply the mask manually.
335 Otherwise the highlighting and dimming the tool bar code in GTK does
336 will look bad. For display with more than 8 planes we just use the
337 pixmap and mask directly. For monochrome displays, GTK doesn't seem
338 able to use external pixmaps, it looks bad whatever we do.
339 The image is defined on the display where frame F is.
340 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
341 If OLD_WIDGET is NULL, a new widget is constructed and returned.
342 If OLD_WIDGET is not NULL, that widget is modified. */
343
344 static GtkWidget *
345 xg_get_image_for_pixmap (struct frame *f,
346 struct image *img,
347 GtkWidget *widget,
348 GtkImage *old_widget)
349 {
350 GdkPixbuf *icon_buf;
351
352 /* If we have a file, let GTK do all the image handling.
353 This seems to be the only way to make insensitive and activated icons
354 look good in all cases. */
355 Lisp_Object specified_file = file_for_image (img->spec);
356 Lisp_Object file;
357
358 /* We already loaded the image once before calling this
359 function, so this only fails if the image file has been removed.
360 In that case, use the pixmap already loaded. */
361
362 if (STRINGP (specified_file)
363 && STRINGP (file = x_find_image_file (specified_file)))
364 {
365 if (! old_widget)
366 old_widget = GTK_IMAGE (gtk_image_new_from_file (SSDATA (file)));
367 else
368 gtk_image_set_from_file (old_widget, SSDATA (file));
369
370 return GTK_WIDGET (old_widget);
371 }
372
373 /* No file, do the image handling ourselves. This will look very bad
374 on a monochrome display, and sometimes bad on all displays with
375 certain themes. */
376
377 /* This is a workaround to make icons look good on pseudo color
378 displays. Apparently GTK expects the images to have an alpha
379 channel. If they don't, insensitive and activated icons will
380 look bad. This workaround does not work on monochrome displays,
381 and is strictly not needed on true color/static color displays (i.e.
382 16 bits and higher). But we do it anyway so we get a pixbuf that is
383 not associated with the img->pixmap. The img->pixmap may be removed
384 by clearing the image cache and then the tool bar redraw fails, since
385 Gtk+ assumes the pixmap is always there. */
386 icon_buf = xg_get_pixbuf_from_pix_and_mask (f, img->pixmap, img->mask);
387
388 if (icon_buf)
389 {
390 if (! old_widget)
391 old_widget = GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf));
392 else
393 gtk_image_set_from_pixbuf (old_widget, icon_buf);
394
395 g_object_unref (G_OBJECT (icon_buf));
396 }
397
398 return GTK_WIDGET (old_widget);
399 }
400
401
402 /* Set CURSOR on W and all widgets W contain. We must do like this
403 for scroll bars and menu because they create widgets internally,
404 and it is those widgets that are visible. */
405
406 static void
407 xg_set_cursor (GtkWidget *w, GdkCursor *cursor)
408 {
409 GdkWindow *window = gtk_widget_get_window (w);
410 GList *children = gdk_window_peek_children (window);
411
412 gdk_window_set_cursor (window, cursor);
413
414 /* The scroll bar widget has more than one GDK window (had to look at
415 the source to figure this out), and there is no way to set cursor
416 on widgets in GTK. So we must set the cursor for all GDK windows.
417 Ditto for menus. */
418
419 for ( ; children; children = g_list_next (children))
420 gdk_window_set_cursor (GDK_WINDOW (children->data), cursor);
421 }
422
423 /* Insert NODE into linked LIST. */
424
425 static void
426 xg_list_insert (xg_list_node *list, xg_list_node *node)
427 {
428 xg_list_node *list_start = list->next;
429
430 if (list_start) list_start->prev = node;
431 node->next = list_start;
432 node->prev = 0;
433 list->next = node;
434 }
435
436 /* Remove NODE from linked LIST. */
437
438 static void
439 xg_list_remove (xg_list_node *list, xg_list_node *node)
440 {
441 xg_list_node *list_start = list->next;
442 if (node == list_start)
443 {
444 list->next = node->next;
445 if (list->next) list->next->prev = 0;
446 }
447 else
448 {
449 node->prev->next = node->next;
450 if (node->next) node->next->prev = node->prev;
451 }
452 }
453
454 /* Allocate and return a utf8 version of STR. If STR is already
455 utf8 or NULL, just return a copy of STR.
456 A new string is allocated and the caller must free the result
457 with g_free. */
458
459 static char *
460 get_utf8_string (const char *str)
461 {
462 char *utf8_str;
463
464 if (!str) return NULL;
465
466 /* If not UTF-8, try current locale. */
467 if (!g_utf8_validate (str, -1, NULL))
468 utf8_str = g_locale_to_utf8 (str, -1, 0, 0, 0);
469 else
470 return g_strdup (str);
471
472 if (!utf8_str)
473 {
474 /* Probably some control characters in str. Escape them. */
475 ptrdiff_t len;
476 ptrdiff_t nr_bad = 0;
477 gsize bytes_read;
478 gsize bytes_written;
479 unsigned char *p = (unsigned char *)str;
480 char *cp, *up;
481 GError *err = NULL;
482
483 while (! (cp = g_locale_to_utf8 ((char *)p, -1, &bytes_read,
484 &bytes_written, &err))
485 && err->code == G_CONVERT_ERROR_ILLEGAL_SEQUENCE)
486 {
487 ++nr_bad;
488 p += bytes_written+1;
489 g_error_free (err);
490 err = NULL;
491 }
492
493 if (err)
494 {
495 g_error_free (err);
496 err = NULL;
497 }
498 if (cp) g_free (cp);
499
500 len = strlen (str);
501 if ((min (PTRDIFF_MAX, SIZE_MAX) - len - 1) / 4 < nr_bad)
502 memory_full (SIZE_MAX);
503 up = utf8_str = xmalloc (len + nr_bad * 4 + 1);
504 p = (unsigned char *)str;
505
506 while (! (cp = g_locale_to_utf8 ((char *)p, -1, &bytes_read,
507 &bytes_written, &err))
508 && err->code == G_CONVERT_ERROR_ILLEGAL_SEQUENCE)
509 {
510 memcpy (up, p, bytes_written);
511 up += bytes_written;
512 up += sprintf (up, "\\%03o", p[bytes_written]);
513 p += bytes_written + 1;
514 g_error_free (err);
515 err = NULL;
516 }
517
518 if (cp)
519 {
520 strcpy (up, cp);
521 g_free (cp);
522 }
523 if (err)
524 {
525 g_error_free (err);
526 err = NULL;
527 }
528 }
529 return utf8_str;
530 }
531
532 /* Check for special colors used in face spec for region face.
533 The colors are fetched from the Gtk+ theme.
534 Return true if color was found, false if not. */
535
536 bool
537 xg_check_special_colors (struct frame *f,
538 const char *color_name,
539 XColor *color)
540 {
541 bool success_p = 0;
542 bool get_bg = strcmp ("gtk_selection_bg_color", color_name) == 0;
543 bool get_fg = !get_bg && strcmp ("gtk_selection_fg_color", color_name) == 0;
544
545 if (! FRAME_GTK_WIDGET (f) || ! (get_bg || get_fg))
546 return success_p;
547
548 block_input ();
549 {
550 #ifdef HAVE_GTK3
551 GtkStyleContext *gsty
552 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f));
553 GdkRGBA col;
554 char buf[sizeof "rgb://rrrr/gggg/bbbb"];
555 int state = GTK_STATE_FLAG_SELECTED|GTK_STATE_FLAG_FOCUSED;
556 if (get_fg)
557 gtk_style_context_get_color (gsty, state, &col);
558 else
559 gtk_style_context_get_background_color (gsty, state, &col);
560
561 sprintf (buf, "rgb:%04x/%04x/%04x",
562 (int)(col.red * 65535),
563 (int)(col.green * 65535),
564 (int)(col.blue * 65535));
565 success_p = (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
566 buf, color)
567 != 0);
568 #else
569 GtkStyle *gsty = gtk_widget_get_style (FRAME_GTK_WIDGET (f));
570 GdkColor *grgb = get_bg
571 ? &gsty->bg[GTK_STATE_SELECTED]
572 : &gsty->fg[GTK_STATE_SELECTED];
573
574 color->red = grgb->red;
575 color->green = grgb->green;
576 color->blue = grgb->blue;
577 color->pixel = grgb->pixel;
578 success_p = 1;
579 #endif
580
581 }
582 unblock_input ();
583 return success_p;
584 }
585
586
587 \f
588 /***********************************************************************
589 Tooltips
590 ***********************************************************************/
591 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
592 We use that to pop down the tooltip. This happens if Gtk+ for some
593 reason wants to change or hide the tooltip. */
594
595 #ifdef USE_GTK_TOOLTIP
596
597 static void
598 hierarchy_ch_cb (GtkWidget *widget,
599 GtkWidget *previous_toplevel,
600 gpointer user_data)
601 {
602 struct frame *f = user_data;
603 struct x_output *x = f->output_data.x;
604 GtkWidget *top = gtk_widget_get_toplevel (x->ttip_lbl);
605
606 if (! top || ! GTK_IS_WINDOW (top))
607 gtk_widget_hide (previous_toplevel);
608 }
609
610 /* Callback called when Gtk+ thinks a tooltip should be displayed.
611 We use it to get the tooltip window and the tooltip widget so
612 we can manipulate the ourselves.
613
614 Return FALSE ensures that the tooltip is not shown. */
615
616 static gboolean
617 qttip_cb (GtkWidget *widget,
618 gint xpos,
619 gint ypos,
620 gboolean keyboard_mode,
621 GtkTooltip *tooltip,
622 gpointer user_data)
623 {
624 struct frame *f = user_data;
625 struct x_output *x = f->output_data.x;
626 if (x->ttip_widget == NULL)
627 {
628 GtkWidget *p;
629 GList *list, *iter;
630
631 g_object_set (G_OBJECT (widget), "has-tooltip", FALSE, NULL);
632 x->ttip_widget = tooltip;
633 g_object_ref (G_OBJECT (tooltip));
634 x->ttip_lbl = gtk_label_new ("");
635 g_object_ref (G_OBJECT (x->ttip_lbl));
636 gtk_tooltip_set_custom (tooltip, x->ttip_lbl);
637 x->ttip_window = GTK_WINDOW (gtk_widget_get_toplevel (x->ttip_lbl));
638
639 /* Change stupid Gtk+ default line wrapping. */
640 p = gtk_widget_get_parent (x->ttip_lbl);
641 list = gtk_container_get_children (GTK_CONTAINER (p));
642 for (iter = list; iter; iter = g_list_next (iter))
643 {
644 GtkWidget *w = GTK_WIDGET (iter->data);
645 if (GTK_IS_LABEL (w))
646 gtk_label_set_line_wrap (GTK_LABEL (w), FALSE);
647 }
648 g_list_free (list);
649
650 /* ATK needs an empty title for some reason. */
651 gtk_window_set_title (x->ttip_window, "");
652 /* Realize so we can safely get screen later on. */
653 gtk_widget_realize (GTK_WIDGET (x->ttip_window));
654 gtk_widget_realize (x->ttip_lbl);
655
656 g_signal_connect (x->ttip_lbl, "hierarchy-changed",
657 G_CALLBACK (hierarchy_ch_cb), f);
658 }
659 return FALSE;
660 }
661
662 #endif /* USE_GTK_TOOLTIP */
663
664 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
665 Return true if a system tooltip is available. */
666
667 bool
668 xg_prepare_tooltip (struct frame *f,
669 Lisp_Object string,
670 int *width,
671 int *height)
672 {
673 #ifndef USE_GTK_TOOLTIP
674 return 0;
675 #else
676 struct x_output *x = f->output_data.x;
677 GtkWidget *widget;
678 GdkWindow *gwin;
679 GdkScreen *screen;
680 GtkSettings *settings;
681 gboolean tt_enabled = TRUE;
682 GtkRequisition req;
683 Lisp_Object encoded_string;
684
685 if (!x->ttip_lbl) return 0;
686
687 block_input ();
688 encoded_string = ENCODE_UTF_8 (string);
689 widget = GTK_WIDGET (x->ttip_lbl);
690 gwin = gtk_widget_get_window (GTK_WIDGET (x->ttip_window));
691 screen = gdk_window_get_screen (gwin);
692 settings = gtk_settings_get_for_screen (screen);
693 g_object_get (settings, "gtk-enable-tooltips", &tt_enabled, NULL);
694 if (tt_enabled)
695 {
696 g_object_set (settings, "gtk-enable-tooltips", FALSE, NULL);
697 /* Record that we disabled it so it can be enabled again. */
698 g_object_set_data (G_OBJECT (x->ttip_window), "restore-tt",
699 (gpointer)f);
700 }
701
702 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
703 g_object_set_data (G_OBJECT
704 (gtk_widget_get_display (GTK_WIDGET (x->ttip_window))),
705 "gdk-display-current-tooltip", NULL);
706
707 /* Put our dummy widget in so we can get callbacks for unrealize and
708 hierarchy-changed. */
709 gtk_tooltip_set_custom (x->ttip_widget, widget);
710 gtk_tooltip_set_text (x->ttip_widget, SSDATA (encoded_string));
711 gtk_widget_get_preferred_size (GTK_WIDGET (x->ttip_window), NULL, &req);
712 if (width) *width = req.width;
713 if (height) *height = req.height;
714
715 unblock_input ();
716
717 return 1;
718 #endif /* USE_GTK_TOOLTIP */
719 }
720
721 /* Show the tooltip at ROOT_X and ROOT_Y.
722 xg_prepare_tooltip must have been called before this function. */
723
724 void
725 xg_show_tooltip (struct frame *f, int root_x, int root_y)
726 {
727 #ifdef USE_GTK_TOOLTIP
728 struct x_output *x = f->output_data.x;
729 if (x->ttip_window)
730 {
731 block_input ();
732 gtk_window_move (x->ttip_window, root_x, root_y);
733 gtk_widget_show_all (GTK_WIDGET (x->ttip_window));
734 unblock_input ();
735 }
736 #endif
737 }
738
739 /* Hide tooltip if shown. Do nothing if not shown.
740 Return true if tip was hidden, false if not (i.e. not using
741 system tooltips). */
742
743 bool
744 xg_hide_tooltip (struct frame *f)
745 {
746 bool ret = 0;
747 #ifdef USE_GTK_TOOLTIP
748 if (f->output_data.x->ttip_window)
749 {
750 GtkWindow *win = f->output_data.x->ttip_window;
751 block_input ();
752 gtk_widget_hide (GTK_WIDGET (win));
753
754 if (g_object_get_data (G_OBJECT (win), "restore-tt"))
755 {
756 GdkWindow *gwin = gtk_widget_get_window (GTK_WIDGET (win));
757 GdkScreen *screen = gdk_window_get_screen (gwin);
758 GtkSettings *settings = gtk_settings_get_for_screen (screen);
759 g_object_set (settings, "gtk-enable-tooltips", TRUE, NULL);
760 }
761 unblock_input ();
762
763 ret = 1;
764 }
765 #endif
766 return ret;
767 }
768
769 \f
770 /***********************************************************************
771 General functions for creating widgets, resizing, events, e.t.c.
772 ***********************************************************************/
773
774 static void
775 my_log_handler (const gchar *log_domain, GLogLevelFlags log_level,
776 const gchar *msg, gpointer user_data)
777 {
778 if (!strstr (msg, "visible children"))
779 fprintf (stderr, "XX %s-WARNING **: %s\n", log_domain, msg);
780 }
781
782 /* Make a geometry string and pass that to GTK. It seems this is the
783 only way to get geometry position right if the user explicitly
784 asked for a position when starting Emacs.
785 F is the frame we shall set geometry for. */
786
787 static void
788 xg_set_geometry (struct frame *f)
789 {
790 if (f->size_hint_flags & (USPosition | PPosition))
791 {
792 int left = f->left_pos;
793 int xneg = f->size_hint_flags & XNegative;
794 int top = f->top_pos;
795 int yneg = f->size_hint_flags & YNegative;
796 char geom_str[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
797 guint id;
798
799 if (xneg)
800 left = -left;
801 if (yneg)
802 top = -top;
803
804 sprintf (geom_str, "=%dx%d%c%d%c%d",
805 FRAME_PIXEL_WIDTH (f),
806 FRAME_PIXEL_HEIGHT (f),
807 (xneg ? '-' : '+'), left,
808 (yneg ? '-' : '+'), top);
809
810 /* Silence warning about visible children. */
811 id = g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL
812 | G_LOG_FLAG_RECURSION, my_log_handler, NULL);
813
814 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
815 geom_str))
816 fprintf (stderr, "Failed to parse: '%s'\n", geom_str);
817
818 g_log_remove_handler ("Gtk", id);
819 }
820 }
821
822 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
823 and use a GtkFixed widget, this doesn't happen automatically. */
824
825 void
826 xg_clear_under_internal_border (struct frame *f)
827 {
828 if (FRAME_INTERNAL_BORDER_WIDTH (f) > 0)
829 {
830 GtkWidget *wfixed = f->output_data.x->edit_widget;
831
832 gtk_widget_queue_draw (wfixed);
833 gdk_window_process_all_updates ();
834
835 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), 0, 0,
836 FRAME_PIXEL_WIDTH (f), FRAME_INTERNAL_BORDER_WIDTH (f));
837
838 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), 0, 0,
839 FRAME_INTERNAL_BORDER_WIDTH (f), FRAME_PIXEL_HEIGHT (f));
840
841 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), 0,
842 FRAME_PIXEL_HEIGHT (f) - FRAME_INTERNAL_BORDER_WIDTH (f),
843 FRAME_PIXEL_WIDTH (f), FRAME_INTERNAL_BORDER_WIDTH (f));
844
845 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
846 FRAME_PIXEL_WIDTH (f) - FRAME_INTERNAL_BORDER_WIDTH (f),
847 0, FRAME_INTERNAL_BORDER_WIDTH (f), FRAME_PIXEL_HEIGHT (f));
848 }
849 }
850
851 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
852 and a Gtk+ menu bar, we get resize events for the edit part of the
853 frame only. We let Gtk+ deal with the Gtk+ parts.
854 F is the frame to resize.
855 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
856
857 void
858 xg_frame_resized (struct frame *f, int pixelwidth, int pixelheight)
859 {
860 int width, height;
861
862 if (pixelwidth == -1 && pixelheight == -1)
863 {
864 if (FRAME_GTK_WIDGET (f) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f)))
865 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f)),
866 0, 0,
867 &pixelwidth, &pixelheight);
868 else return;
869 }
870
871
872 width = FRAME_PIXEL_TO_TEXT_WIDTH (f, pixelwidth);
873 height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, pixelheight);
874
875 if (width != FRAME_TEXT_WIDTH (f)
876 || height != FRAME_TEXT_HEIGHT (f)
877 || pixelwidth != FRAME_PIXEL_WIDTH (f)
878 || pixelheight != FRAME_PIXEL_HEIGHT (f))
879 {
880 FRAME_PIXEL_WIDTH (f) = pixelwidth;
881 FRAME_PIXEL_HEIGHT (f) = pixelheight;
882
883 xg_clear_under_internal_border (f);
884 change_frame_size (f, width, height, 0, 1, 0, 1);
885 SET_FRAME_GARBAGED (f);
886 cancel_mouse_face (f);
887
888 do_pending_window_change (0);
889 }
890 }
891
892 /* Resize the outer window of frame F after changing the height.
893 COLUMNS/ROWS is the size the edit area shall have after the resize. */
894
895 void
896 xg_frame_set_char_size (struct frame *f, int width, int height)
897 {
898 int pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width);
899 int pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height);
900
901 if (FRAME_PIXEL_HEIGHT (f) == 0)
902 return;
903
904 /* Do this before resize, as we don't know yet if we will be resized. */
905 xg_clear_under_internal_border (f);
906
907 /* Must resize our top level widget. Font size may have changed,
908 but not rows/cols. */
909 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
910 pixelwidth + FRAME_TOOLBAR_WIDTH (f),
911 pixelheight + FRAME_TOOLBAR_HEIGHT (f)
912 + FRAME_MENUBAR_HEIGHT (f));
913 x_wm_set_size_hint (f, 0, 0);
914
915 SET_FRAME_GARBAGED (f);
916 cancel_mouse_face (f);
917
918 /* We can not call change_frame_size for a mapped frame,
919 we can not set pixel width/height either. The window manager may
920 override our resize request, XMonad does this all the time.
921 The best we can do is try to sync, so lisp code sees the updated
922 size as fast as possible.
923 For unmapped windows, we can set rows/cols. When
924 the frame is mapped again we will (hopefully) get the correct size. */
925 if (FRAME_VISIBLE_P (f))
926 {
927 /* Must call this to flush out events */
928 (void)gtk_events_pending ();
929 gdk_flush ();
930 x_wait_for_event (f, ConfigureNotify);
931 }
932 else
933 adjust_frame_size (f, -1, -1, 5, 0);
934 }
935
936 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
937 The policy is to keep the number of editable lines. */
938
939 static void
940 xg_height_or_width_changed (struct frame *f)
941 {
942 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
943 FRAME_TOTAL_PIXEL_WIDTH (f),
944 FRAME_TOTAL_PIXEL_HEIGHT (f));
945 f->output_data.x->hint_flags = 0;
946 x_wm_set_size_hint (f, 0, 0);
947 }
948
949 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
950 Must be done like this, because GtkWidget:s can have "hidden"
951 X Window that aren't accessible.
952
953 Return 0 if no widget match WDESC. */
954
955 GtkWidget *
956 xg_win_to_widget (Display *dpy, Window wdesc)
957 {
958 gpointer gdkwin;
959 GtkWidget *gwdesc = 0;
960
961 block_input ();
962
963 gdkwin = gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy),
964 wdesc);
965 if (gdkwin)
966 {
967 GdkEvent event;
968 event.any.window = gdkwin;
969 event.any.type = GDK_NOTHING;
970 gwdesc = gtk_get_event_widget (&event);
971 }
972
973 unblock_input ();
974 return gwdesc;
975 }
976
977 /* Set the background of widget W to PIXEL. */
978
979 static void
980 xg_set_widget_bg (struct frame *f, GtkWidget *w, unsigned long pixel)
981 {
982 #ifdef HAVE_GTK3
983 GdkRGBA bg;
984 XColor xbg;
985 xbg.pixel = pixel;
986 if (XQueryColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), &xbg))
987 {
988 bg.red = (double)xbg.red/65535.0;
989 bg.green = (double)xbg.green/65535.0;
990 bg.blue = (double)xbg.blue/65535.0;
991 bg.alpha = 1.0;
992 gtk_widget_override_background_color (w, GTK_STATE_FLAG_NORMAL, &bg);
993 }
994 #else
995 GdkColor bg;
996 GdkColormap *map = gtk_widget_get_colormap (w);
997 gdk_colormap_query_color (map, pixel, &bg);
998 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f), GTK_STATE_NORMAL, &bg);
999 #endif
1000 }
1001
1002 /* Callback called when the gtk theme changes.
1003 We notify lisp code so it can fix faces used for region for example. */
1004
1005 static void
1006 style_changed_cb (GObject *go,
1007 GParamSpec *spec,
1008 gpointer user_data)
1009 {
1010 struct input_event event;
1011 GdkDisplay *gdpy = user_data;
1012 const char *display_name = gdk_display_get_name (gdpy);
1013 Display *dpy = GDK_DISPLAY_XDISPLAY (gdpy);
1014
1015 EVENT_INIT (event);
1016 event.kind = CONFIG_CHANGED_EVENT;
1017 event.frame_or_window = build_string (display_name);
1018 /* Theme doesn't change often, so intern is called seldom. */
1019 event.arg = intern ("theme-name");
1020 kbd_buffer_store_event (&event);
1021
1022 update_theme_scrollbar_width ();
1023 update_theme_scrollbar_height ();
1024
1025 /* If scroll bar width changed, we need set the new size on all frames
1026 on this display. */
1027 if (dpy)
1028 {
1029 Lisp_Object rest, frame;
1030 FOR_EACH_FRAME (rest, frame)
1031 {
1032 struct frame *f = XFRAME (frame);
1033 if (FRAME_LIVE_P (f)
1034 && FRAME_X_P (f)
1035 && FRAME_X_DISPLAY (f) == dpy)
1036 {
1037 x_set_scroll_bar_default_width (f);
1038 x_set_scroll_bar_default_height (f);
1039 xg_frame_set_char_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f));
1040 }
1041 }
1042 }
1043 }
1044
1045 /* Called when a delete-event occurs on WIDGET. */
1046
1047 static gboolean
1048 delete_cb (GtkWidget *widget,
1049 GdkEvent *event,
1050 gpointer user_data)
1051 {
1052 #ifdef HAVE_GTK3
1053 /* The event doesn't arrive in the normal event loop. Send event
1054 here. */
1055 struct frame *f = user_data;
1056 struct input_event ie;
1057
1058 EVENT_INIT (ie);
1059 ie.kind = DELETE_WINDOW_EVENT;
1060 XSETFRAME (ie.frame_or_window, f);
1061 kbd_buffer_store_event (&ie);
1062 #endif
1063
1064 return TRUE;
1065 }
1066
1067 /* Create and set up the GTK widgets for frame F.
1068 Return true if creation succeeded. */
1069
1070 bool
1071 xg_create_frame_widgets (struct frame *f)
1072 {
1073 GtkWidget *wtop;
1074 GtkWidget *wvbox, *whbox;
1075 GtkWidget *wfixed;
1076 #ifndef HAVE_GTK3
1077 GtkRcStyle *style;
1078 #endif
1079 char *title = 0;
1080
1081 block_input ();
1082
1083 if (FRAME_X_EMBEDDED_P (f))
1084 {
1085 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
1086 wtop = gtk_plug_new_for_display (gdpy, f->output_data.x->parent_desc);
1087 }
1088 else
1089 wtop = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1090
1091 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1092 has backported it to Gtk+ 2.0 and they add the resize grip for
1093 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1094 forever, so disable the grip. */
1095 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1096 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1097 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop), FALSE);
1098 #endif
1099
1100 xg_set_screen (wtop, f);
1101
1102 wvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1103 whbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1104 gtk_box_set_homogeneous (GTK_BOX (wvbox), FALSE);
1105 gtk_box_set_homogeneous (GTK_BOX (whbox), FALSE);
1106
1107 #ifdef HAVE_GTK3
1108 wfixed = emacs_fixed_new (f);
1109 #else
1110 wfixed = gtk_fixed_new ();
1111 #endif
1112
1113 if (! wtop || ! wvbox || ! whbox || ! wfixed)
1114 {
1115 if (wtop) gtk_widget_destroy (wtop);
1116 if (wvbox) gtk_widget_destroy (wvbox);
1117 if (whbox) gtk_widget_destroy (whbox);
1118 if (wfixed) gtk_widget_destroy (wfixed);
1119
1120 unblock_input ();
1121 return 0;
1122 }
1123
1124 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1125 gtk_widget_set_name (wtop, EMACS_CLASS);
1126 gtk_widget_set_name (wvbox, "pane");
1127 gtk_widget_set_name (wfixed, SSDATA (Vx_resource_name));
1128
1129 /* If this frame has a title or name, set it in the title bar. */
1130 if (! NILP (f->title))
1131 title = SSDATA (ENCODE_UTF_8 (f->title));
1132 else if (! NILP (f->name))
1133 title = SSDATA (ENCODE_UTF_8 (f->name));
1134
1135 if (title) gtk_window_set_title (GTK_WINDOW (wtop), title);
1136
1137 FRAME_GTK_OUTER_WIDGET (f) = wtop;
1138 FRAME_GTK_WIDGET (f) = wfixed;
1139 f->output_data.x->vbox_widget = wvbox;
1140 f->output_data.x->hbox_widget = whbox;
1141
1142 gtk_widget_set_has_window (wfixed, TRUE);
1143
1144 gtk_container_add (GTK_CONTAINER (wtop), wvbox);
1145 gtk_box_pack_start (GTK_BOX (wvbox), whbox, TRUE, TRUE, 0);
1146 gtk_box_pack_start (GTK_BOX (whbox), wfixed, TRUE, TRUE, 0);
1147
1148 if (FRAME_EXTERNAL_TOOL_BAR (f))
1149 update_frame_tool_bar (f);
1150
1151 /* We don't want this widget double buffered, because we draw on it
1152 with regular X drawing primitives, so from a GTK/GDK point of
1153 view, the widget is totally blank. When an expose comes, this
1154 will make the widget blank, and then Emacs redraws it. This flickers
1155 a lot, so we turn off double buffering. */
1156 gtk_widget_set_double_buffered (wfixed, FALSE);
1157
1158 gtk_window_set_wmclass (GTK_WINDOW (wtop),
1159 SSDATA (Vx_resource_name),
1160 SSDATA (Vx_resource_class));
1161
1162 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1163 GTK is to destroy the widget. We want Emacs to do that instead. */
1164 g_signal_connect (G_OBJECT (wtop), "delete-event",
1165 G_CALLBACK (delete_cb), f);
1166
1167 /* Convert our geometry parameters into a geometry string
1168 and specify it.
1169 GTK will itself handle calculating the real position this way. */
1170 xg_set_geometry (f);
1171 f->win_gravity
1172 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
1173
1174 gtk_widget_add_events (wfixed,
1175 GDK_POINTER_MOTION_MASK
1176 | GDK_EXPOSURE_MASK
1177 | GDK_BUTTON_PRESS_MASK
1178 | GDK_BUTTON_RELEASE_MASK
1179 | GDK_KEY_PRESS_MASK
1180 | GDK_ENTER_NOTIFY_MASK
1181 | GDK_LEAVE_NOTIFY_MASK
1182 | GDK_FOCUS_CHANGE_MASK
1183 | GDK_STRUCTURE_MASK
1184 | GDK_VISIBILITY_NOTIFY_MASK);
1185
1186 /* Must realize the windows so the X window gets created. It is used
1187 by callers of this function. */
1188 gtk_widget_realize (wfixed);
1189 FRAME_X_WINDOW (f) = GTK_WIDGET_TO_X_WIN (wfixed);
1190
1191 /* Since GTK clears its window by filling with the background color,
1192 we must keep X and GTK background in sync. */
1193 xg_set_widget_bg (f, wfixed, FRAME_BACKGROUND_PIXEL (f));
1194
1195 #ifndef HAVE_GTK3
1196 /* Also, do not let any background pixmap to be set, this looks very
1197 bad as Emacs overwrites the background pixmap with its own idea
1198 of background color. */
1199 style = gtk_widget_get_modifier_style (wfixed);
1200
1201 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1202 style->bg_pixmap_name[GTK_STATE_NORMAL] = g_strdup ("<none>");
1203 gtk_widget_modify_style (wfixed, style);
1204 #else
1205 gtk_widget_set_can_focus (wfixed, TRUE);
1206 gtk_window_set_resizable (GTK_WINDOW (wtop), TRUE);
1207 #endif
1208
1209 #ifdef USE_GTK_TOOLTIP
1210 /* Steal a tool tip window we can move ourselves. */
1211 f->output_data.x->ttip_widget = 0;
1212 f->output_data.x->ttip_lbl = 0;
1213 f->output_data.x->ttip_window = 0;
1214 gtk_widget_set_tooltip_text (wtop, "Dummy text");
1215 g_signal_connect (wtop, "query-tooltip", G_CALLBACK (qttip_cb), f);
1216 #endif
1217
1218 {
1219 GdkScreen *screen = gtk_widget_get_screen (wtop);
1220 GtkSettings *gs = gtk_settings_get_for_screen (screen);
1221 /* Only connect this signal once per screen. */
1222 if (! g_signal_handler_find (G_OBJECT (gs),
1223 G_SIGNAL_MATCH_FUNC,
1224 0, 0, 0,
1225 G_CALLBACK (style_changed_cb),
1226 0))
1227 {
1228 g_signal_connect (G_OBJECT (gs), "notify::gtk-theme-name",
1229 G_CALLBACK (style_changed_cb),
1230 gdk_screen_get_display (screen));
1231 }
1232 }
1233
1234 unblock_input ();
1235
1236 return 1;
1237 }
1238
1239 void
1240 xg_free_frame_widgets (struct frame *f)
1241 {
1242 if (FRAME_GTK_OUTER_WIDGET (f))
1243 {
1244 #ifdef USE_GTK_TOOLTIP
1245 struct x_output *x = f->output_data.x;
1246 #endif
1247 struct xg_frame_tb_info *tbinfo
1248 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
1249 TB_INFO_KEY);
1250 if (tbinfo)
1251 xfree (tbinfo);
1252
1253 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f));
1254 FRAME_X_WINDOW (f) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1255 FRAME_GTK_OUTER_WIDGET (f) = 0;
1256 #ifdef USE_GTK_TOOLTIP
1257 if (x->ttip_lbl)
1258 gtk_widget_destroy (x->ttip_lbl);
1259 if (x->ttip_widget)
1260 g_object_unref (G_OBJECT (x->ttip_widget));
1261 #endif
1262 }
1263 }
1264
1265 /* Set the normal size hints for the window manager, for frame F.
1266 FLAGS is the flags word to use--or 0 meaning preserve the flags
1267 that the window now has.
1268 If USER_POSITION, set the User Position
1269 flag (this is useful when FLAGS is 0). */
1270
1271 void
1272 x_wm_set_size_hint (struct frame *f, long int flags, bool user_position)
1273 {
1274 /* Must use GTK routines here, otherwise GTK resets the size hints
1275 to its own defaults. */
1276 GdkGeometry size_hints;
1277 gint hint_flags = 0;
1278 int base_width, base_height;
1279 int min_rows = 0, min_cols = 0;
1280 int win_gravity = f->win_gravity;
1281 Lisp_Object fs_state, frame;
1282
1283 /* Don't set size hints during initialization; that apparently leads
1284 to a race condition. See the thread at
1285 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1286 if (NILP (Vafter_init_time) || !FRAME_GTK_OUTER_WIDGET (f))
1287 return;
1288
1289 XSETFRAME (frame, f);
1290 fs_state = Fframe_parameter (frame, Qfullscreen);
1291 if (EQ (fs_state, Qmaximized) || EQ (fs_state, Qfullboth))
1292 {
1293 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1294 Gtk3 don't get along and the frame shrinks (!).
1295 */
1296 return;
1297 }
1298
1299 if (flags)
1300 {
1301 memset (&size_hints, 0, sizeof (size_hints));
1302 f->output_data.x->size_hints = size_hints;
1303 f->output_data.x->hint_flags = hint_flags;
1304 }
1305 else
1306 flags = f->size_hint_flags;
1307
1308 size_hints = f->output_data.x->size_hints;
1309 hint_flags = f->output_data.x->hint_flags;
1310
1311 hint_flags |= GDK_HINT_RESIZE_INC | GDK_HINT_MIN_SIZE;
1312 size_hints.width_inc = frame_resize_pixelwise ? 1 : FRAME_COLUMN_WIDTH (f);
1313 size_hints.height_inc = frame_resize_pixelwise ? 1 : FRAME_LINE_HEIGHT (f);
1314
1315 hint_flags |= GDK_HINT_BASE_SIZE;
1316 /* Use one row/col here so base_height/width does not become zero.
1317 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1318 base_width = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 1) + FRAME_TOOLBAR_WIDTH (f);
1319 base_height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 1)
1320 + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f);
1321
1322 if (min_cols > 0) --min_cols; /* We used one col in base_width = ... 1); */
1323 if (min_rows > 0) --min_rows; /* We used one row in base_height = ... 1); */
1324
1325 size_hints.base_width = base_width;
1326 size_hints.base_height = base_height;
1327 size_hints.min_width = base_width + min_cols * FRAME_COLUMN_WIDTH (f);
1328 size_hints.min_height = base_height + min_rows * FRAME_LINE_HEIGHT (f);
1329
1330 /* These currently have a one to one mapping with the X values, but I
1331 don't think we should rely on that. */
1332 hint_flags |= GDK_HINT_WIN_GRAVITY;
1333 size_hints.win_gravity = 0;
1334 if (win_gravity == NorthWestGravity)
1335 size_hints.win_gravity = GDK_GRAVITY_NORTH_WEST;
1336 else if (win_gravity == NorthGravity)
1337 size_hints.win_gravity = GDK_GRAVITY_NORTH;
1338 else if (win_gravity == NorthEastGravity)
1339 size_hints.win_gravity = GDK_GRAVITY_NORTH_EAST;
1340 else if (win_gravity == WestGravity)
1341 size_hints.win_gravity = GDK_GRAVITY_WEST;
1342 else if (win_gravity == CenterGravity)
1343 size_hints.win_gravity = GDK_GRAVITY_CENTER;
1344 else if (win_gravity == EastGravity)
1345 size_hints.win_gravity = GDK_GRAVITY_EAST;
1346 else if (win_gravity == SouthWestGravity)
1347 size_hints.win_gravity = GDK_GRAVITY_SOUTH_WEST;
1348 else if (win_gravity == SouthGravity)
1349 size_hints.win_gravity = GDK_GRAVITY_SOUTH;
1350 else if (win_gravity == SouthEastGravity)
1351 size_hints.win_gravity = GDK_GRAVITY_SOUTH_EAST;
1352 else if (win_gravity == StaticGravity)
1353 size_hints.win_gravity = GDK_GRAVITY_STATIC;
1354
1355 if (user_position)
1356 {
1357 hint_flags &= ~GDK_HINT_POS;
1358 hint_flags |= GDK_HINT_USER_POS;
1359 }
1360
1361 if (hint_flags != f->output_data.x->hint_flags
1362 || memcmp (&size_hints,
1363 &f->output_data.x->size_hints,
1364 sizeof (size_hints)) != 0)
1365 {
1366 block_input ();
1367 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
1368 NULL, &size_hints, hint_flags);
1369 f->output_data.x->size_hints = size_hints;
1370 f->output_data.x->hint_flags = hint_flags;
1371 unblock_input ();
1372 }
1373 }
1374
1375 /* Change background color of a frame.
1376 Since GTK uses the background color to clear the window, we must
1377 keep the GTK and X colors in sync.
1378 F is the frame to change,
1379 BG is the pixel value to change to. */
1380
1381 void
1382 xg_set_background_color (struct frame *f, unsigned long bg)
1383 {
1384 if (FRAME_GTK_WIDGET (f))
1385 {
1386 block_input ();
1387 xg_set_widget_bg (f, FRAME_GTK_WIDGET (f), FRAME_BACKGROUND_PIXEL (f));
1388 unblock_input ();
1389 }
1390 }
1391
1392
1393 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1394 functions so GTK does not overwrite the icon. */
1395
1396 void
1397 xg_set_frame_icon (struct frame *f, Pixmap icon_pixmap, Pixmap icon_mask)
1398 {
1399 GdkPixbuf *gp = xg_get_pixbuf_from_pix_and_mask (f,
1400 icon_pixmap,
1401 icon_mask);
1402 if (gp)
1403 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)), gp);
1404 }
1405
1406
1407 \f
1408 /***********************************************************************
1409 Dialog functions
1410 ***********************************************************************/
1411 /* Return the dialog title to use for a dialog of type KEY.
1412 This is the encoding used by lwlib. We use the same for GTK. */
1413
1414 static const char *
1415 get_dialog_title (char key)
1416 {
1417 const char *title = "";
1418
1419 switch (key) {
1420 case 'E': case 'e':
1421 title = "Error";
1422 break;
1423
1424 case 'I': case 'i':
1425 title = "Information";
1426 break;
1427
1428 case 'L': case 'l':
1429 title = "Prompt";
1430 break;
1431
1432 case 'P': case 'p':
1433 title = "Prompt";
1434 break;
1435
1436 case 'Q': case 'q':
1437 title = "Question";
1438 break;
1439 }
1440
1441 return title;
1442 }
1443
1444 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1445 the dialog, but return TRUE so the event does not propagate further
1446 in GTK. This prevents GTK from destroying the dialog widget automatically
1447 and we can always destroy the widget manually, regardless of how
1448 it was popped down (button press or WM_DELETE_WINDOW).
1449 W is the dialog widget.
1450 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1451 user_data is NULL (not used).
1452
1453 Returns TRUE to end propagation of event. */
1454
1455 static gboolean
1456 dialog_delete_callback (GtkWidget *w, GdkEvent *event, gpointer user_data)
1457 {
1458 gtk_widget_unmap (w);
1459 return TRUE;
1460 }
1461
1462 /* Create a popup dialog window. See also xg_create_widget below.
1463 WV is a widget_value describing the dialog.
1464 SELECT_CB is the callback to use when a button has been pressed.
1465 DEACTIVATE_CB is the callback to use when the dialog pops down.
1466
1467 Returns the GTK dialog widget. */
1468
1469 static GtkWidget *
1470 create_dialog (widget_value *wv,
1471 GCallback select_cb,
1472 GCallback deactivate_cb)
1473 {
1474 const char *title = get_dialog_title (wv->name[0]);
1475 int total_buttons = wv->name[1] - '0';
1476 int right_buttons = wv->name[4] - '0';
1477 int left_buttons;
1478 int button_nr = 0;
1479 int button_spacing = 10;
1480 GtkWidget *wdialog = gtk_dialog_new ();
1481 GtkDialog *wd = GTK_DIALOG (wdialog);
1482 GtkBox *cur_box = GTK_BOX (gtk_dialog_get_action_area (wd));
1483 widget_value *item;
1484 GtkWidget *whbox_down;
1485
1486 /* If the number of buttons is greater than 4, make two rows of buttons
1487 instead. This looks better. */
1488 bool make_two_rows = total_buttons > 4;
1489
1490 if (right_buttons == 0) right_buttons = total_buttons/2;
1491 left_buttons = total_buttons - right_buttons;
1492
1493 gtk_window_set_title (GTK_WINDOW (wdialog), title);
1494 gtk_widget_set_name (wdialog, "emacs-dialog");
1495
1496
1497 if (make_two_rows)
1498 {
1499 GtkWidget *wvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, button_spacing);
1500 GtkWidget *whbox_up = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1501 gtk_box_set_homogeneous (GTK_BOX (wvbox), TRUE);
1502 gtk_box_set_homogeneous (GTK_BOX (whbox_up), FALSE);
1503 whbox_down = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1504 gtk_box_set_homogeneous (GTK_BOX (whbox_down), FALSE);
1505
1506 gtk_box_pack_start (cur_box, wvbox, FALSE, FALSE, 0);
1507 gtk_box_pack_start (GTK_BOX (wvbox), whbox_up, FALSE, FALSE, 0);
1508 gtk_box_pack_start (GTK_BOX (wvbox), whbox_down, FALSE, FALSE, 0);
1509
1510 cur_box = GTK_BOX (whbox_up);
1511 }
1512
1513 g_signal_connect (G_OBJECT (wdialog), "delete-event",
1514 G_CALLBACK (dialog_delete_callback), 0);
1515
1516 if (deactivate_cb)
1517 {
1518 g_signal_connect (G_OBJECT (wdialog), "close", deactivate_cb, 0);
1519 g_signal_connect (G_OBJECT (wdialog), "response", deactivate_cb, 0);
1520 }
1521
1522 for (item = wv->contents; item; item = item->next)
1523 {
1524 char *utf8_label = get_utf8_string (item->value);
1525 GtkWidget *w;
1526 GtkRequisition req;
1527
1528 if (item->name && strcmp (item->name, "message") == 0)
1529 {
1530 GtkBox *wvbox = GTK_BOX (gtk_dialog_get_content_area (wd));
1531 /* This is the text part of the dialog. */
1532 w = gtk_label_new (utf8_label);
1533 gtk_box_pack_start (wvbox, gtk_label_new (""), FALSE, FALSE, 0);
1534 gtk_box_pack_start (wvbox, w, TRUE, TRUE, 0);
1535 gtk_misc_set_alignment (GTK_MISC (w), 0.1, 0.5);
1536
1537 /* Try to make dialog look better. Must realize first so
1538 the widget can calculate the size it needs. */
1539 gtk_widget_realize (w);
1540 gtk_widget_get_preferred_size (w, NULL, &req);
1541 gtk_box_set_spacing (wvbox, req.height);
1542 if (item->value && strlen (item->value) > 0)
1543 button_spacing = 2*req.width/strlen (item->value);
1544 if (button_spacing < 10) button_spacing = 10;
1545 }
1546 else
1547 {
1548 /* This is one button to add to the dialog. */
1549 w = gtk_button_new_with_label (utf8_label);
1550 if (! item->enabled)
1551 gtk_widget_set_sensitive (w, FALSE);
1552 if (select_cb)
1553 g_signal_connect (G_OBJECT (w), "clicked",
1554 select_cb, item->call_data);
1555
1556 gtk_box_pack_start (cur_box, w, TRUE, TRUE, button_spacing);
1557 if (++button_nr == left_buttons)
1558 {
1559 if (make_two_rows)
1560 cur_box = GTK_BOX (whbox_down);
1561 }
1562 }
1563
1564 if (utf8_label)
1565 g_free (utf8_label);
1566 }
1567
1568 return wdialog;
1569 }
1570
1571 struct xg_dialog_data
1572 {
1573 GMainLoop *loop;
1574 int response;
1575 GtkWidget *w;
1576 guint timerid;
1577 };
1578
1579 /* Function that is called when the file or font dialogs pop down.
1580 W is the dialog widget, RESPONSE is the response code.
1581 USER_DATA is what we passed in to g_signal_connect. */
1582
1583 static void
1584 xg_dialog_response_cb (GtkDialog *w,
1585 gint response,
1586 gpointer user_data)
1587 {
1588 struct xg_dialog_data *dd = user_data;
1589 dd->response = response;
1590 g_main_loop_quit (dd->loop);
1591 }
1592
1593
1594 /* Destroy the dialog. This makes it pop down. */
1595
1596 static void
1597 pop_down_dialog (void *arg)
1598 {
1599 struct xg_dialog_data *dd = arg;
1600
1601 block_input ();
1602 if (dd->w) gtk_widget_destroy (dd->w);
1603 if (dd->timerid != 0) g_source_remove (dd->timerid);
1604
1605 g_main_loop_quit (dd->loop);
1606 g_main_loop_unref (dd->loop);
1607
1608 unblock_input ();
1609 }
1610
1611 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1612 We pass in DATA as gpointer* so we can use this as a callback. */
1613
1614 static gboolean
1615 xg_maybe_add_timer (gpointer data)
1616 {
1617 struct xg_dialog_data *dd = data;
1618 struct timespec next_time = timer_check ();
1619
1620 dd->timerid = 0;
1621
1622 if (timespec_valid_p (next_time))
1623 {
1624 time_t s = next_time.tv_sec;
1625 int per_ms = TIMESPEC_RESOLUTION / 1000;
1626 int ms = (next_time.tv_nsec + per_ms - 1) / per_ms;
1627 if (s <= ((guint) -1 - ms) / 1000)
1628 dd->timerid = g_timeout_add (s * 1000 + ms, xg_maybe_add_timer, dd);
1629 }
1630 return FALSE;
1631 }
1632
1633
1634 /* Pops up a modal dialog W and waits for response.
1635 We don't use gtk_dialog_run because we want to process emacs timers.
1636 The dialog W is not destroyed when this function returns. */
1637
1638 static int
1639 xg_dialog_run (struct frame *f, GtkWidget *w)
1640 {
1641 ptrdiff_t count = SPECPDL_INDEX ();
1642 struct xg_dialog_data dd;
1643
1644 xg_set_screen (w, f);
1645 gtk_window_set_transient_for (GTK_WINDOW (w),
1646 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
1647 gtk_window_set_destroy_with_parent (GTK_WINDOW (w), TRUE);
1648 gtk_window_set_modal (GTK_WINDOW (w), TRUE);
1649
1650 dd.loop = g_main_loop_new (NULL, FALSE);
1651 dd.response = GTK_RESPONSE_CANCEL;
1652 dd.w = w;
1653 dd.timerid = 0;
1654
1655 g_signal_connect (G_OBJECT (w),
1656 "response",
1657 G_CALLBACK (xg_dialog_response_cb),
1658 &dd);
1659 /* Don't destroy the widget if closed by the window manager close button. */
1660 g_signal_connect (G_OBJECT (w), "delete-event", G_CALLBACK (gtk_true), NULL);
1661 gtk_widget_show (w);
1662
1663 record_unwind_protect_ptr (pop_down_dialog, &dd);
1664
1665 (void) xg_maybe_add_timer (&dd);
1666 g_main_loop_run (dd.loop);
1667
1668 dd.w = 0;
1669 unbind_to (count, Qnil);
1670
1671 return dd.response;
1672 }
1673
1674 \f
1675 /***********************************************************************
1676 File dialog functions
1677 ***********************************************************************/
1678 /* Return true if the old file selection dialog is being used. */
1679
1680 bool
1681 xg_uses_old_file_dialog (void)
1682 {
1683 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1684 return x_gtk_use_old_file_dialog;
1685 #else
1686 return 0;
1687 #endif
1688 }
1689
1690
1691 typedef char * (*xg_get_file_func) (GtkWidget *);
1692
1693 /* Return the selected file for file chooser dialog W.
1694 The returned string must be free:d. */
1695
1696 static char *
1697 xg_get_file_name_from_chooser (GtkWidget *w)
1698 {
1699 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w));
1700 }
1701
1702 /* Callback called when the "Show hidden files" toggle is pressed.
1703 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1704
1705 static void
1706 xg_toggle_visibility_cb (GtkWidget *widget, gpointer data)
1707 {
1708 GtkFileChooser *dialog = GTK_FILE_CHOOSER (data);
1709 gboolean visible;
1710 g_object_get (G_OBJECT (dialog), "show-hidden", &visible, NULL);
1711 g_object_set (G_OBJECT (dialog), "show-hidden", !visible, NULL);
1712 }
1713
1714
1715 /* Callback called when a property changes in a file chooser.
1716 GOBJECT is the file chooser dialog, ARG1 describes the property.
1717 USER_DATA is the toggle widget in the file chooser dialog.
1718 We use this to update the "Show hidden files" toggle when the user
1719 changes that property by right clicking in the file list. */
1720
1721 static void
1722 xg_toggle_notify_cb (GObject *gobject, GParamSpec *arg1, gpointer user_data)
1723 {
1724 if (strcmp (arg1->name, "show-hidden") == 0)
1725 {
1726 GtkWidget *wtoggle = GTK_WIDGET (user_data);
1727 gboolean visible, toggle_on;
1728
1729 g_object_get (G_OBJECT (gobject), "show-hidden", &visible, NULL);
1730 toggle_on = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle));
1731
1732 if (!!visible != !!toggle_on)
1733 {
1734 g_signal_handlers_block_by_func (G_OBJECT (wtoggle),
1735 G_CALLBACK (xg_toggle_visibility_cb),
1736 gobject);
1737 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle), visible);
1738 g_signal_handlers_unblock_by_func
1739 (G_OBJECT (wtoggle),
1740 G_CALLBACK (xg_toggle_visibility_cb),
1741 gobject);
1742 }
1743 x_gtk_show_hidden_files = visible;
1744 }
1745 }
1746
1747 /* Read a file name from the user using a file chooser dialog.
1748 F is the current frame.
1749 PROMPT is a prompt to show to the user. May not be NULL.
1750 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1751 If MUSTMATCH_P, the returned file name must be an existing
1752 file. (Actually, this only has cosmetic effects, the user can
1753 still enter a non-existing file.) *FUNC is set to a function that
1754 can be used to retrieve the selected file name from the returned widget.
1755
1756 Returns the created widget. */
1757
1758 static GtkWidget *
1759 xg_get_file_with_chooser (struct frame *f,
1760 char *prompt,
1761 char *default_filename,
1762 bool mustmatch_p, bool only_dir_p,
1763 xg_get_file_func *func)
1764 {
1765 char msgbuf[1024];
1766
1767 GtkWidget *filewin, *wtoggle, *wbox, *wmessage IF_LINT (= NULL);
1768 GtkWindow *gwin = GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f));
1769 GtkFileChooserAction action = (mustmatch_p ?
1770 GTK_FILE_CHOOSER_ACTION_OPEN :
1771 GTK_FILE_CHOOSER_ACTION_SAVE);
1772
1773 if (only_dir_p)
1774 action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
1775
1776 filewin = gtk_file_chooser_dialog_new (prompt, gwin, action,
1777 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1778 (mustmatch_p || only_dir_p ?
1779 GTK_STOCK_OPEN : GTK_STOCK_OK),
1780 GTK_RESPONSE_OK,
1781 NULL);
1782 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin), TRUE);
1783
1784 wbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1785 gtk_box_set_homogeneous (GTK_BOX (wbox), FALSE);
1786 gtk_widget_show (wbox);
1787 wtoggle = gtk_check_button_new_with_label ("Show hidden files.");
1788
1789 if (x_gtk_show_hidden_files)
1790 {
1791 g_object_set (G_OBJECT (filewin), "show-hidden", TRUE, NULL);
1792 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle), TRUE);
1793 }
1794 gtk_widget_show (wtoggle);
1795 g_signal_connect (G_OBJECT (wtoggle), "clicked",
1796 G_CALLBACK (xg_toggle_visibility_cb), filewin);
1797 g_signal_connect (G_OBJECT (filewin), "notify",
1798 G_CALLBACK (xg_toggle_notify_cb), wtoggle);
1799
1800 if (x_gtk_file_dialog_help_text)
1801 {
1802 msgbuf[0] = '\0';
1803 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1804 Show the C-l help text only for versions < 2.10. */
1805 if (gtk_check_version (2, 10, 0) && action != GTK_FILE_CHOOSER_ACTION_SAVE)
1806 strcat (msgbuf, "\nType C-l to display a file name text entry box.\n");
1807 strcat (msgbuf, "\nIf you don't like this file selector, use the "
1808 "corresponding\nkey binding or customize "
1809 "use-file-dialog to turn it off.");
1810
1811 wmessage = gtk_label_new (msgbuf);
1812 gtk_widget_show (wmessage);
1813 }
1814
1815 gtk_box_pack_start (GTK_BOX (wbox), wtoggle, FALSE, FALSE, 0);
1816 if (x_gtk_file_dialog_help_text)
1817 gtk_box_pack_start (GTK_BOX (wbox), wmessage, FALSE, FALSE, 0);
1818 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin), wbox);
1819
1820 if (default_filename)
1821 {
1822 Lisp_Object file;
1823 struct gcpro gcpro1;
1824 char *utf8_filename;
1825 GCPRO1 (file);
1826
1827 file = build_string (default_filename);
1828
1829 /* File chooser does not understand ~/... in the file name. It must be
1830 an absolute name starting with /. */
1831 if (default_filename[0] != '/')
1832 file = Fexpand_file_name (file, Qnil);
1833
1834 utf8_filename = SSDATA (ENCODE_UTF_8 (file));
1835 if (! NILP (Ffile_directory_p (file)))
1836 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin),
1837 utf8_filename);
1838 else
1839 {
1840 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin),
1841 utf8_filename);
1842 if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
1843 {
1844 char *cp = strrchr (utf8_filename, '/');
1845 if (cp) ++cp;
1846 else cp = utf8_filename;
1847 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin), cp);
1848 }
1849 }
1850
1851 UNGCPRO;
1852 }
1853
1854 *func = xg_get_file_name_from_chooser;
1855 return filewin;
1856 }
1857
1858 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1859
1860 /* Return the selected file for file selector dialog W.
1861 The returned string must be free:d. */
1862
1863 static char *
1864 xg_get_file_name_from_selector (GtkWidget *w)
1865 {
1866 GtkFileSelection *filesel = GTK_FILE_SELECTION (w);
1867 return xstrdup (gtk_file_selection_get_filename (filesel));
1868 }
1869
1870 /* Create a file selection dialog.
1871 F is the current frame.
1872 PROMPT is a prompt to show to the user. May not be NULL.
1873 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1874 If MUSTMATCH_P, the returned file name must be an existing
1875 file. *FUNC is set to a function that can be used to retrieve the
1876 selected file name from the returned widget.
1877
1878 Returns the created widget. */
1879
1880 static GtkWidget *
1881 xg_get_file_with_selection (struct frame *f,
1882 char *prompt,
1883 char *default_filename,
1884 bool mustmatch_p, bool only_dir_p,
1885 xg_get_file_func *func)
1886 {
1887 GtkWidget *filewin;
1888 GtkFileSelection *filesel;
1889
1890 filewin = gtk_file_selection_new (prompt);
1891 filesel = GTK_FILE_SELECTION (filewin);
1892
1893 if (default_filename)
1894 gtk_file_selection_set_filename (filesel, default_filename);
1895
1896 if (mustmatch_p)
1897 {
1898 /* The selection_entry part of filesel is not documented. */
1899 gtk_widget_set_sensitive (filesel->selection_entry, FALSE);
1900 gtk_file_selection_hide_fileop_buttons (filesel);
1901 }
1902
1903 *func = xg_get_file_name_from_selector;
1904
1905 return filewin;
1906 }
1907 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1908
1909 /* Read a file name from the user using a file dialog, either the old
1910 file selection dialog, or the new file chooser dialog. Which to use
1911 depends on what the GTK version used has, and what the value of
1912 gtk-use-old-file-dialog.
1913 F is the current frame.
1914 PROMPT is a prompt to show to the user. May not be NULL.
1915 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1916 If MUSTMATCH_P, the returned file name must be an existing
1917 file.
1918
1919 Returns a file name or NULL if no file was selected.
1920 The returned string must be freed by the caller. */
1921
1922 char *
1923 xg_get_file_name (struct frame *f,
1924 char *prompt,
1925 char *default_filename,
1926 bool mustmatch_p,
1927 bool only_dir_p)
1928 {
1929 GtkWidget *w = 0;
1930 char *fn = 0;
1931 int filesel_done = 0;
1932 xg_get_file_func func;
1933
1934 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1935
1936 if (xg_uses_old_file_dialog ())
1937 w = xg_get_file_with_selection (f, prompt, default_filename,
1938 mustmatch_p, only_dir_p, &func);
1939 else
1940 w = xg_get_file_with_chooser (f, prompt, default_filename,
1941 mustmatch_p, only_dir_p, &func);
1942
1943 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1944 w = xg_get_file_with_chooser (f, prompt, default_filename,
1945 mustmatch_p, only_dir_p, &func);
1946 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1947
1948 gtk_widget_set_name (w, "emacs-filedialog");
1949
1950 filesel_done = xg_dialog_run (f, w);
1951 if (filesel_done == GTK_RESPONSE_OK)
1952 fn = (*func) (w);
1953
1954 gtk_widget_destroy (w);
1955 return fn;
1956 }
1957
1958 /***********************************************************************
1959 GTK font chooser
1960 ***********************************************************************/
1961
1962 #ifdef HAVE_FREETYPE
1963
1964 #if USE_NEW_GTK_FONT_CHOOSER
1965
1966 #define XG_WEIGHT_TO_SYMBOL(w) \
1967 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
1968 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
1969 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
1970 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
1971 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
1972 : w <= PANGO_WEIGHT_BOLD ? Qbold \
1973 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
1974 : Qultra_bold)
1975
1976 #define XG_STYLE_TO_SYMBOL(s) \
1977 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
1978 : s == PANGO_STYLE_ITALIC ? Qitalic \
1979 : Qnormal)
1980
1981 #endif /* USE_NEW_GTK_FONT_CHOOSER */
1982
1983
1984 static char *x_last_font_name;
1985
1986 /* Pop up a GTK font selector and return the name of the font the user
1987 selects, as a C string. The returned font name follows GTK's own
1988 format:
1989
1990 `FAMILY [VALUE1 VALUE2] SIZE'
1991
1992 This can be parsed using font_parse_fcname in font.c.
1993 DEFAULT_NAME, if non-zero, is the default font name. */
1994
1995 Lisp_Object
1996 xg_get_font (struct frame *f, const char *default_name)
1997 {
1998 GtkWidget *w;
1999 int done = 0;
2000 Lisp_Object font = Qnil;
2001
2002 w = gtk_font_chooser_dialog_new
2003 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
2004
2005 if (default_name)
2006 {
2007 /* Convert fontconfig names to Gtk names, i.e. remove - before
2008 number */
2009 char *p = strrchr (default_name, '-');
2010 if (p)
2011 {
2012 char *ep = p+1;
2013 while (c_isdigit (*ep))
2014 ++ep;
2015 if (*ep == '\0') *p = ' ';
2016 }
2017 }
2018 else if (x_last_font_name)
2019 default_name = x_last_font_name;
2020
2021 if (default_name)
2022 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w), default_name);
2023
2024 gtk_widget_set_name (w, "emacs-fontdialog");
2025 done = xg_dialog_run (f, w);
2026 if (done == GTK_RESPONSE_OK)
2027 {
2028 #if USE_NEW_GTK_FONT_CHOOSER
2029 /* Use the GTK3 font chooser. */
2030 PangoFontDescription *desc
2031 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w));
2032
2033 if (desc)
2034 {
2035 Lisp_Object args[10];
2036 const char *name = pango_font_description_get_family (desc);
2037 gint size = pango_font_description_get_size (desc);
2038 PangoWeight weight = pango_font_description_get_weight (desc);
2039 PangoStyle style = pango_font_description_get_style (desc);
2040
2041 args[0] = QCname;
2042 args[1] = build_string (name);
2043
2044 args[2] = QCsize;
2045 args[3] = make_float (pango_units_to_double (size));
2046
2047 args[4] = QCweight;
2048 args[5] = XG_WEIGHT_TO_SYMBOL (weight);
2049
2050 args[6] = QCslant;
2051 args[7] = XG_STYLE_TO_SYMBOL (style);
2052
2053 args[8] = QCtype;
2054 args[9] = Qxft;
2055
2056 font = Ffont_spec (8, args);
2057
2058 pango_font_description_free (desc);
2059 dupstring (&x_last_font_name, name);
2060 }
2061
2062 #else /* Use old font selector, which just returns the font name. */
2063
2064 char *font_name
2065 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w));
2066
2067 if (font_name)
2068 {
2069 font = build_string (font_name);
2070 g_free (x_last_font_name);
2071 x_last_font_name = font_name;
2072 }
2073 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2074 }
2075
2076 gtk_widget_destroy (w);
2077 return font;
2078 }
2079 #endif /* HAVE_FREETYPE */
2080
2081
2082 \f
2083 /***********************************************************************
2084 Menu functions.
2085 ***********************************************************************/
2086
2087 /* The name of menu items that can be used for customization. Since GTK
2088 RC files are very crude and primitive, we have to set this on all
2089 menu item names so a user can easily customize menu items. */
2090
2091 #define MENU_ITEM_NAME "emacs-menuitem"
2092
2093
2094 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2095 during GC. The next member points to the items. */
2096 static xg_list_node xg_menu_cb_list;
2097
2098 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2099 during GC. The next member points to the items. */
2100 static xg_list_node xg_menu_item_cb_list;
2101
2102 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2103 F is the frame CL_DATA will be initialized for.
2104 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2105
2106 The menu bar and all sub menus under the menu bar in a frame
2107 share the same structure, hence the reference count.
2108
2109 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2110 allocated xg_menu_cb_data if CL_DATA is NULL. */
2111
2112 static xg_menu_cb_data *
2113 make_cl_data (xg_menu_cb_data *cl_data, struct frame *f, GCallback highlight_cb)
2114 {
2115 if (! cl_data)
2116 {
2117 cl_data = xmalloc (sizeof *cl_data);
2118 cl_data->f = f;
2119 cl_data->menu_bar_vector = f->menu_bar_vector;
2120 cl_data->menu_bar_items_used = f->menu_bar_items_used;
2121 cl_data->highlight_cb = highlight_cb;
2122 cl_data->ref_count = 0;
2123
2124 xg_list_insert (&xg_menu_cb_list, &cl_data->ptrs);
2125 }
2126
2127 cl_data->ref_count++;
2128
2129 return cl_data;
2130 }
2131
2132 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2133 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2134
2135 When the menu bar is updated, menu items may have been added and/or
2136 removed, so menu_bar_vector and menu_bar_items_used change. We must
2137 then update CL_DATA since it is used to determine which menu
2138 item that is invoked in the menu.
2139 HIGHLIGHT_CB could change, there is no check that the same
2140 function is given when modifying a menu bar as was given when
2141 creating the menu bar. */
2142
2143 static void
2144 update_cl_data (xg_menu_cb_data *cl_data,
2145 struct frame *f,
2146 GCallback highlight_cb)
2147 {
2148 if (cl_data)
2149 {
2150 cl_data->f = f;
2151 cl_data->menu_bar_vector = f->menu_bar_vector;
2152 cl_data->menu_bar_items_used = f->menu_bar_items_used;
2153 cl_data->highlight_cb = highlight_cb;
2154 }
2155 }
2156
2157 /* Decrease reference count for CL_DATA.
2158 If reference count is zero, free CL_DATA. */
2159
2160 static void
2161 unref_cl_data (xg_menu_cb_data *cl_data)
2162 {
2163 if (cl_data && cl_data->ref_count > 0)
2164 {
2165 cl_data->ref_count--;
2166 if (cl_data->ref_count == 0)
2167 {
2168 xg_list_remove (&xg_menu_cb_list, &cl_data->ptrs);
2169 xfree (cl_data);
2170 }
2171 }
2172 }
2173
2174 /* Function that marks all lisp data during GC. */
2175
2176 void
2177 xg_mark_data (void)
2178 {
2179 xg_list_node *iter;
2180 Lisp_Object rest, frame;
2181
2182 for (iter = xg_menu_cb_list.next; iter; iter = iter->next)
2183 mark_object (((xg_menu_cb_data *) iter)->menu_bar_vector);
2184
2185 for (iter = xg_menu_item_cb_list.next; iter; iter = iter->next)
2186 {
2187 xg_menu_item_cb_data *cb_data = (xg_menu_item_cb_data *) iter;
2188
2189 if (! NILP (cb_data->help))
2190 mark_object (cb_data->help);
2191 }
2192
2193 FOR_EACH_FRAME (rest, frame)
2194 {
2195 struct frame *f = XFRAME (frame);
2196
2197 if (FRAME_X_P (f) && FRAME_GTK_OUTER_WIDGET (f))
2198 {
2199 struct xg_frame_tb_info *tbinfo
2200 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
2201 TB_INFO_KEY);
2202 if (tbinfo)
2203 {
2204 mark_object (tbinfo->last_tool_bar);
2205 mark_object (tbinfo->style);
2206 }
2207 }
2208 }
2209 }
2210
2211
2212 /* Callback called when a menu item is destroyed. Used to free data.
2213 W is the widget that is being destroyed (not used).
2214 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2215
2216 static void
2217 menuitem_destroy_callback (GtkWidget *w, gpointer client_data)
2218 {
2219 if (client_data)
2220 {
2221 xg_menu_item_cb_data *data = client_data;
2222 xg_list_remove (&xg_menu_item_cb_list, &data->ptrs);
2223 xfree (data);
2224 }
2225 }
2226
2227 /* Callback called when the pointer enters/leaves a menu item.
2228 W is the parent of the menu item.
2229 EVENT is either an enter event or leave event.
2230 CLIENT_DATA is not used.
2231
2232 Returns FALSE to tell GTK to keep processing this event. */
2233
2234 static gboolean
2235 menuitem_highlight_callback (GtkWidget *w,
2236 GdkEventCrossing *event,
2237 gpointer client_data)
2238 {
2239 GdkEvent ev;
2240 GtkWidget *subwidget;
2241 xg_menu_item_cb_data *data;
2242
2243 ev.crossing = *event;
2244 subwidget = gtk_get_event_widget (&ev);
2245 data = g_object_get_data (G_OBJECT (subwidget), XG_ITEM_DATA);
2246 if (data)
2247 {
2248 if (! NILP (data->help) && data->cl_data->highlight_cb)
2249 {
2250 gpointer call_data = event->type == GDK_LEAVE_NOTIFY ? 0 : data;
2251 GtkCallback func = (GtkCallback) data->cl_data->highlight_cb;
2252 (*func) (subwidget, call_data);
2253 }
2254 }
2255
2256 return FALSE;
2257 }
2258
2259 /* Callback called when a menu is destroyed. Used to free data.
2260 W is the widget that is being destroyed (not used).
2261 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2262
2263 static void
2264 menu_destroy_callback (GtkWidget *w, gpointer client_data)
2265 {
2266 unref_cl_data (client_data);
2267 }
2268
2269 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2270 must be non-NULL) and can be inserted into a menu item.
2271
2272 Returns the GtkHBox. */
2273
2274 static GtkWidget *
2275 make_widget_for_menu_item (const char *utf8_label, const char *utf8_key)
2276 {
2277 GtkWidget *wlbl;
2278 GtkWidget *wkey;
2279 GtkWidget *wbox;
2280
2281 wbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2282 gtk_box_set_homogeneous (GTK_BOX (wbox), FALSE);
2283 wlbl = gtk_label_new (utf8_label);
2284 wkey = gtk_label_new (utf8_key);
2285
2286 gtk_misc_set_alignment (GTK_MISC (wlbl), 0.0, 0.5);
2287 gtk_misc_set_alignment (GTK_MISC (wkey), 0.0, 0.5);
2288
2289 gtk_box_pack_start (GTK_BOX (wbox), wlbl, TRUE, TRUE, 0);
2290 gtk_box_pack_start (GTK_BOX (wbox), wkey, FALSE, FALSE, 0);
2291
2292 gtk_widget_set_name (wlbl, MENU_ITEM_NAME);
2293 gtk_widget_set_name (wkey, MENU_ITEM_NAME);
2294 gtk_widget_set_name (wbox, MENU_ITEM_NAME);
2295
2296 return wbox;
2297 }
2298
2299 /* Make and return a menu item widget with the key to the right.
2300 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2301 UTF8_KEY is the text representing the key binding.
2302 ITEM is the widget_value describing the menu item.
2303
2304 GROUP is an in/out parameter. If the menu item to be created is not
2305 part of any radio menu group, *GROUP contains NULL on entry and exit.
2306 If the menu item to be created is part of a radio menu group, on entry
2307 *GROUP contains the group to use, or NULL if this is the first item
2308 in the group. On exit, *GROUP contains the radio item group.
2309
2310 Unfortunately, keys don't line up as nicely as in Motif,
2311 but the MacOS X version doesn't either, so I guess that is OK. */
2312
2313 static GtkWidget *
2314 make_menu_item (const char *utf8_label,
2315 const char *utf8_key,
2316 widget_value *item,
2317 GSList **group)
2318 {
2319 GtkWidget *w;
2320 GtkWidget *wtoadd = 0;
2321
2322 /* It has been observed that some menu items have a NULL name field.
2323 This will lead to this function being called with a NULL utf8_label.
2324 GTK crashes on that so we set a blank label. Why there is a NULL
2325 name remains to be investigated. */
2326 if (! utf8_label) utf8_label = " ";
2327
2328 if (utf8_key)
2329 wtoadd = make_widget_for_menu_item (utf8_label, utf8_key);
2330
2331 if (item->button_type == BUTTON_TYPE_TOGGLE)
2332 {
2333 *group = NULL;
2334 if (utf8_key) w = gtk_check_menu_item_new ();
2335 else w = gtk_check_menu_item_new_with_label (utf8_label);
2336 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), item->selected);
2337 }
2338 else if (item->button_type == BUTTON_TYPE_RADIO)
2339 {
2340 if (utf8_key) w = gtk_radio_menu_item_new (*group);
2341 else w = gtk_radio_menu_item_new_with_label (*group, utf8_label);
2342 *group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w));
2343 if (item->selected)
2344 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), TRUE);
2345 }
2346 else
2347 {
2348 *group = NULL;
2349 if (utf8_key) w = gtk_menu_item_new ();
2350 else w = gtk_menu_item_new_with_label (utf8_label);
2351 }
2352
2353 if (wtoadd) gtk_container_add (GTK_CONTAINER (w), wtoadd);
2354 if (! item->enabled) gtk_widget_set_sensitive (w, FALSE);
2355
2356 return w;
2357 }
2358
2359 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2360
2361 static int xg_detached_menus;
2362
2363 /* Return true if there are detached menus. */
2364
2365 bool
2366 xg_have_tear_offs (struct frame *f)
2367 {
2368 /* If the frame's menubar height is zero, the menu bar is probably
2369 being redirected outside the window to some kind of global menu;
2370 this situation is the moral equivalent of a tear-off. */
2371 return FRAME_MENUBAR_HEIGHT (f) == 0 || xg_detached_menus > 0;
2372 }
2373
2374 /* Callback invoked when a detached menu window is removed. Here we
2375 decrease the xg_detached_menus count.
2376 WIDGET is the top level window that is removed (the parent of the menu).
2377 CLIENT_DATA is not used. */
2378
2379 static void
2380 tearoff_remove (GtkWidget *widget, gpointer client_data)
2381 {
2382 if (xg_detached_menus > 0) --xg_detached_menus;
2383 }
2384
2385 /* Callback invoked when a menu is detached. It increases the
2386 xg_detached_menus count.
2387 WIDGET is the GtkTearoffMenuItem.
2388 CLIENT_DATA is not used. */
2389
2390 static void
2391 tearoff_activate (GtkWidget *widget, gpointer client_data)
2392 {
2393 GtkWidget *menu = gtk_widget_get_parent (widget);
2394 if (gtk_menu_get_tearoff_state (GTK_MENU (menu)))
2395 {
2396 ++xg_detached_menus;
2397 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget)),
2398 "destroy",
2399 G_CALLBACK (tearoff_remove), 0);
2400 }
2401 }
2402 #else /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2403 bool
2404 xg_have_tear_offs (struct frame *f)
2405 {
2406 return FRAME_MENUBAR_HEIGHT (f) == 0;
2407 }
2408 #endif /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2409
2410 /* Create a menu item widget, and connect the callbacks.
2411 ITEM describes the menu item.
2412 F is the frame the created menu belongs to.
2413 SELECT_CB is the callback to use when a menu item is selected.
2414 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2415 CL_DATA points to the callback data to be used for this menu.
2416 GROUP is an in/out parameter. If the menu item to be created is not
2417 part of any radio menu group, *GROUP contains NULL on entry and exit.
2418 If the menu item to be created is part of a radio menu group, on entry
2419 *GROUP contains the group to use, or NULL if this is the first item
2420 in the group. On exit, *GROUP contains the radio item group.
2421
2422 Returns the created GtkWidget. */
2423
2424 static GtkWidget *
2425 xg_create_one_menuitem (widget_value *item,
2426 struct frame *f,
2427 GCallback select_cb,
2428 GCallback highlight_cb,
2429 xg_menu_cb_data *cl_data,
2430 GSList **group)
2431 {
2432 char *utf8_label;
2433 char *utf8_key;
2434 GtkWidget *w;
2435 xg_menu_item_cb_data *cb_data;
2436
2437 utf8_label = get_utf8_string (item->name);
2438 utf8_key = get_utf8_string (item->key);
2439
2440 w = make_menu_item (utf8_label, utf8_key, item, group);
2441
2442 if (utf8_label) g_free (utf8_label);
2443 if (utf8_key) g_free (utf8_key);
2444
2445 cb_data = xmalloc (sizeof *cb_data);
2446
2447 xg_list_insert (&xg_menu_item_cb_list, &cb_data->ptrs);
2448
2449 cb_data->select_id = 0;
2450 cb_data->help = item->help;
2451 cb_data->cl_data = cl_data;
2452 cb_data->call_data = item->call_data;
2453
2454 g_signal_connect (G_OBJECT (w),
2455 "destroy",
2456 G_CALLBACK (menuitem_destroy_callback),
2457 cb_data);
2458
2459 /* Put cb_data in widget, so we can get at it when modifying menubar */
2460 g_object_set_data (G_OBJECT (w), XG_ITEM_DATA, cb_data);
2461
2462 /* final item, not a submenu */
2463 if (item->call_data && ! item->contents)
2464 {
2465 if (select_cb)
2466 cb_data->select_id
2467 = g_signal_connect (G_OBJECT (w), "activate", select_cb, cb_data);
2468 }
2469
2470 return w;
2471 }
2472
2473 /* Create a full menu tree specified by DATA.
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 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2477 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2478 If POP_UP_P, create a popup menu.
2479 If MENU_BAR_P, create a menu bar.
2480 If ADD_TEAROFF_P, add a tearoff menu item. Ignored if MENU_BAR_P or
2481 the Gtk+ version used does not have tearoffs.
2482 TOPMENU is the topmost GtkWidget that others shall be placed under.
2483 It may be NULL, in that case we create the appropriate widget
2484 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2485 CL_DATA is the callback data we shall use for this menu, or NULL
2486 if we haven't set the first callback yet.
2487 NAME is the name to give to the top level menu if this function
2488 creates it. May be NULL to not set any name.
2489
2490 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2491 not NULL.
2492
2493 This function calls itself to create submenus. */
2494
2495 static GtkWidget *
2496 create_menus (widget_value *data,
2497 struct frame *f,
2498 GCallback select_cb,
2499 GCallback deactivate_cb,
2500 GCallback highlight_cb,
2501 bool pop_up_p,
2502 bool menu_bar_p,
2503 bool add_tearoff_p,
2504 GtkWidget *topmenu,
2505 xg_menu_cb_data *cl_data,
2506 const char *name)
2507 {
2508 widget_value *item;
2509 GtkWidget *wmenu = topmenu;
2510 GSList *group = NULL;
2511
2512 if (! topmenu)
2513 {
2514 if (! menu_bar_p)
2515 {
2516 wmenu = gtk_menu_new ();
2517 xg_set_screen (wmenu, f);
2518 /* Connect this to the menu instead of items so we get enter/leave for
2519 disabled items also. TODO: Still does not get enter/leave for
2520 disabled items in detached menus. */
2521 g_signal_connect (G_OBJECT (wmenu),
2522 "enter-notify-event",
2523 G_CALLBACK (menuitem_highlight_callback),
2524 NULL);
2525 g_signal_connect (G_OBJECT (wmenu),
2526 "leave-notify-event",
2527 G_CALLBACK (menuitem_highlight_callback),
2528 NULL);
2529 }
2530 else
2531 {
2532 wmenu = gtk_menu_bar_new ();
2533 /* Set width of menu bar to a small value so it doesn't enlarge
2534 a small initial frame size. The width will be set to the
2535 width of the frame later on when it is added to a container.
2536 height -1: Natural height. */
2537 gtk_widget_set_size_request (wmenu, 1, -1);
2538 }
2539
2540 /* Put cl_data on the top menu for easier access. */
2541 cl_data = make_cl_data (cl_data, f, highlight_cb);
2542 g_object_set_data (G_OBJECT (wmenu), XG_FRAME_DATA, (gpointer)cl_data);
2543 g_signal_connect (G_OBJECT (wmenu), "destroy",
2544 G_CALLBACK (menu_destroy_callback), cl_data);
2545
2546 if (name)
2547 gtk_widget_set_name (wmenu, name);
2548
2549 if (deactivate_cb)
2550 g_signal_connect (G_OBJECT (wmenu),
2551 "selection-done", deactivate_cb, 0);
2552 }
2553
2554 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2555 if (! menu_bar_p && add_tearoff_p)
2556 {
2557 // Only add tearoff if menu is empty.
2558 GList *list = gtk_container_get_children (GTK_CONTAINER (wmenu));
2559 if (! list)
2560 {
2561 GtkWidget *tearoff = gtk_tearoff_menu_item_new ();
2562 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu), tearoff);
2563
2564 g_signal_connect (G_OBJECT (tearoff), "activate",
2565 G_CALLBACK (tearoff_activate), 0);
2566 }
2567 else
2568 g_list_free (list);
2569 }
2570 #endif
2571
2572 for (item = data; item; item = item->next)
2573 {
2574 GtkWidget *w;
2575
2576 if (pop_up_p && !item->contents && !item->call_data
2577 && !menu_separator_name_p (item->name))
2578 {
2579 char *utf8_label;
2580 /* A title for a popup. We do the same as GTK does when
2581 creating titles, but it does not look good. */
2582 group = NULL;
2583 utf8_label = get_utf8_string (item->name);
2584
2585 gtk_menu_set_title (GTK_MENU (wmenu), utf8_label);
2586 w = gtk_menu_item_new_with_label (utf8_label);
2587 gtk_widget_set_sensitive (w, FALSE);
2588 if (utf8_label) g_free (utf8_label);
2589 }
2590 else if (menu_separator_name_p (item->name))
2591 {
2592 group = NULL;
2593 /* GTK only have one separator type. */
2594 w = gtk_separator_menu_item_new ();
2595 }
2596 else
2597 {
2598 w = xg_create_one_menuitem (item,
2599 f,
2600 item->contents ? 0 : select_cb,
2601 highlight_cb,
2602 cl_data,
2603 &group);
2604
2605 /* Create a possibly empty submenu for menu bar items, since some
2606 themes don't highlight items correctly without it. */
2607 if (item->contents || menu_bar_p)
2608 {
2609 GtkWidget *submenu = create_menus (item->contents,
2610 f,
2611 select_cb,
2612 deactivate_cb,
2613 highlight_cb,
2614 0,
2615 0,
2616 add_tearoff_p,
2617 0,
2618 cl_data,
2619 0);
2620 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), submenu);
2621 }
2622 }
2623
2624 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu), w);
2625 gtk_widget_set_name (w, MENU_ITEM_NAME);
2626 }
2627
2628 return wmenu;
2629 }
2630
2631 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2632 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2633 with some text and buttons.
2634 F is the frame the created item belongs to.
2635 NAME is the name to use for the top widget.
2636 VAL is a widget_value structure describing items to be created.
2637 SELECT_CB is the callback to use when a menu item is selected or
2638 a dialog button is pressed.
2639 DEACTIVATE_CB is the callback to use when an item is deactivated.
2640 For a menu, when a sub menu is not shown anymore, for a dialog it is
2641 called when the dialog is popped down.
2642 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2643
2644 Returns the widget created. */
2645
2646 GtkWidget *
2647 xg_create_widget (const char *type, const char *name, struct frame *f,
2648 widget_value *val, GCallback select_cb,
2649 GCallback deactivate_cb, GCallback highlight_cb)
2650 {
2651 GtkWidget *w = 0;
2652 bool menu_bar_p = strcmp (type, "menubar") == 0;
2653 bool pop_up_p = strcmp (type, "popup") == 0;
2654
2655 if (strcmp (type, "dialog") == 0)
2656 {
2657 w = create_dialog (val, select_cb, deactivate_cb);
2658 xg_set_screen (w, f);
2659 gtk_window_set_transient_for (GTK_WINDOW (w),
2660 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
2661 gtk_window_set_destroy_with_parent (GTK_WINDOW (w), TRUE);
2662 gtk_widget_set_name (w, "emacs-dialog");
2663 gtk_window_set_modal (GTK_WINDOW (w), TRUE);
2664 }
2665 else if (menu_bar_p || pop_up_p)
2666 {
2667 w = create_menus (val->contents,
2668 f,
2669 select_cb,
2670 deactivate_cb,
2671 highlight_cb,
2672 pop_up_p,
2673 menu_bar_p,
2674 menu_bar_p,
2675 0,
2676 0,
2677 name);
2678
2679 /* Set the cursor to an arrow for popup menus when they are mapped.
2680 This is done by default for menu bar menus. */
2681 if (pop_up_p)
2682 {
2683 /* Must realize so the GdkWindow inside the widget is created. */
2684 gtk_widget_realize (w);
2685 xg_set_cursor (w, FRAME_DISPLAY_INFO (f)->xg_cursor);
2686 }
2687 }
2688 else
2689 {
2690 fprintf (stderr, "bad type in xg_create_widget: %s, doing nothing\n",
2691 type);
2692 }
2693
2694 return w;
2695 }
2696
2697 /* Return the label for menu item WITEM. */
2698
2699 static const char *
2700 xg_get_menu_item_label (GtkMenuItem *witem)
2701 {
2702 GtkLabel *wlabel = GTK_LABEL (XG_BIN_CHILD (witem));
2703 return gtk_label_get_label (wlabel);
2704 }
2705
2706 /* Return true if the menu item WITEM has the text LABEL. */
2707
2708 static bool
2709 xg_item_label_same_p (GtkMenuItem *witem, const char *label)
2710 {
2711 bool is_same = 0;
2712 char *utf8_label = get_utf8_string (label);
2713 const char *old_label = witem ? xg_get_menu_item_label (witem) : 0;
2714
2715 if (! old_label && ! utf8_label)
2716 is_same = 1;
2717 else if (old_label && utf8_label)
2718 is_same = strcmp (utf8_label, old_label) == 0;
2719
2720 if (utf8_label) g_free (utf8_label);
2721
2722 return is_same;
2723 }
2724
2725 /* Destroy widgets in LIST. */
2726
2727 static void
2728 xg_destroy_widgets (GList *list)
2729 {
2730 GList *iter;
2731
2732 for (iter = list; iter; iter = g_list_next (iter))
2733 {
2734 GtkWidget *w = GTK_WIDGET (iter->data);
2735
2736 /* Destroying the widget will remove it from the container it is in. */
2737 gtk_widget_destroy (w);
2738 }
2739 }
2740
2741 /* Update the top level names in MENUBAR (i.e. not submenus).
2742 F is the frame the menu bar belongs to.
2743 *LIST is a list with the current menu bar names (menu item widgets).
2744 ITER is the item within *LIST that shall be updated.
2745 POS is the numerical position, starting at 0, of ITER in *LIST.
2746 VAL describes what the menu bar shall look like after the update.
2747 SELECT_CB is the callback to use when a menu item is selected.
2748 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2749 CL_DATA points to the callback data to be used for this menu bar.
2750
2751 This function calls itself to walk through the menu bar names. */
2752
2753 static void
2754 xg_update_menubar (GtkWidget *menubar,
2755 struct frame *f,
2756 GList **list,
2757 GList *iter,
2758 int pos,
2759 widget_value *val,
2760 GCallback select_cb,
2761 GCallback deactivate_cb,
2762 GCallback highlight_cb,
2763 xg_menu_cb_data *cl_data)
2764 {
2765 if (! iter && ! val)
2766 return;
2767 else if (iter && ! val)
2768 {
2769 /* Item(s) have been removed. Remove all remaining items. */
2770 xg_destroy_widgets (iter);
2771
2772 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2773 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar),
2774 gtk_menu_item_new_with_label (""),
2775 0);
2776 /* All updated. */
2777 val = 0;
2778 iter = 0;
2779 }
2780 else if (! iter && val)
2781 {
2782 /* Item(s) added. Add all new items in one call. */
2783 create_menus (val, f, select_cb, deactivate_cb, highlight_cb,
2784 0, 1, 0, menubar, cl_data, 0);
2785
2786 /* All updated. */
2787 val = 0;
2788 iter = 0;
2789 }
2790 /* Below this neither iter or val is NULL */
2791 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter->data), val->name))
2792 {
2793 /* This item is still the same, check next item. */
2794 val = val->next;
2795 iter = g_list_next (iter);
2796 ++pos;
2797 }
2798 else /* This item is changed. */
2799 {
2800 GtkMenuItem *witem = GTK_MENU_ITEM (iter->data);
2801 GtkMenuItem *witem2 = 0;
2802 bool val_in_menubar = 0;
2803 bool iter_in_new_menubar = 0;
2804 GList *iter2;
2805 widget_value *cur;
2806
2807 /* See if the changed entry (val) is present later in the menu bar */
2808 for (iter2 = iter;
2809 iter2 && ! val_in_menubar;
2810 iter2 = g_list_next (iter2))
2811 {
2812 witem2 = GTK_MENU_ITEM (iter2->data);
2813 val_in_menubar = xg_item_label_same_p (witem2, val->name);
2814 }
2815
2816 /* See if the current entry (iter) is present later in the
2817 specification for the new menu bar. */
2818 for (cur = val; cur && ! iter_in_new_menubar; cur = cur->next)
2819 iter_in_new_menubar = xg_item_label_same_p (witem, cur->name);
2820
2821 if (val_in_menubar && ! iter_in_new_menubar)
2822 {
2823 int nr = pos;
2824
2825 /* This corresponds to:
2826 Current: A B C
2827 New: A C
2828 Remove B. */
2829
2830 g_object_ref (G_OBJECT (witem));
2831 gtk_container_remove (GTK_CONTAINER (menubar), GTK_WIDGET (witem));
2832 gtk_widget_destroy (GTK_WIDGET (witem));
2833
2834 /* Must get new list since the old changed. */
2835 g_list_free (*list);
2836 *list = iter = gtk_container_get_children (GTK_CONTAINER (menubar));
2837 while (nr-- > 0) iter = g_list_next (iter);
2838 }
2839 else if (! val_in_menubar && ! iter_in_new_menubar)
2840 {
2841 /* This corresponds to:
2842 Current: A B C
2843 New: A X C
2844 Rename B to X. This might seem to be a strange thing to do,
2845 since if there is a menu under B it will be totally wrong for X.
2846 But consider editing a C file. Then there is a C-mode menu
2847 (corresponds to B above).
2848 If then doing C-x C-f the minibuf menu (X above) replaces the
2849 C-mode menu. When returning from the minibuffer, we get
2850 back the C-mode menu. Thus we do:
2851 Rename B to X (C-mode to minibuf menu)
2852 Rename X to B (minibuf to C-mode menu).
2853 If the X menu hasn't been invoked, the menu under B
2854 is up to date when leaving the minibuffer. */
2855 GtkLabel *wlabel = GTK_LABEL (XG_BIN_CHILD (witem));
2856 char *utf8_label = get_utf8_string (val->name);
2857 GtkWidget *submenu = gtk_menu_item_get_submenu (witem);
2858
2859 /* GTK menu items don't notice when their labels have been
2860 changed from underneath them, so we have to explicitly
2861 use g_object_notify to tell listeners (e.g., a GMenuModel
2862 bridge that might be loaded) that the item's label has
2863 changed. */
2864 gtk_label_set_text (wlabel, utf8_label);
2865 g_object_notify (G_OBJECT (witem), "label");
2866
2867 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2868 /* If this item has a submenu that has been detached, change
2869 the title in the WM decorations also. */
2870 if (submenu && gtk_menu_get_tearoff_state (GTK_MENU (submenu)))
2871 /* Set the title of the detached window. */
2872 gtk_menu_set_title (GTK_MENU (submenu), utf8_label);
2873 #endif
2874
2875 if (utf8_label) g_free (utf8_label);
2876 iter = g_list_next (iter);
2877 val = val->next;
2878 ++pos;
2879 }
2880 else if (! val_in_menubar && iter_in_new_menubar)
2881 {
2882 /* This corresponds to:
2883 Current: A B C
2884 New: A X B C
2885 Insert X. */
2886
2887 int nr = pos;
2888 GSList *group = 0;
2889 GtkWidget *w = xg_create_one_menuitem (val,
2890 f,
2891 select_cb,
2892 highlight_cb,
2893 cl_data,
2894 &group);
2895
2896 /* Create a possibly empty submenu for menu bar items, since some
2897 themes don't highlight items correctly without it. */
2898 GtkWidget *submenu = create_menus (NULL, f,
2899 select_cb, deactivate_cb,
2900 highlight_cb,
2901 0, 0, 0, 0, cl_data, 0);
2902
2903 gtk_widget_set_name (w, MENU_ITEM_NAME);
2904 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar), w, pos);
2905 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), submenu);
2906
2907 g_list_free (*list);
2908 *list = iter = gtk_container_get_children (GTK_CONTAINER (menubar));
2909 while (nr-- > 0) iter = g_list_next (iter);
2910 iter = g_list_next (iter);
2911 val = val->next;
2912 ++pos;
2913 }
2914 else /* if (val_in_menubar && iter_in_new_menubar) */
2915 {
2916 int nr = pos;
2917 /* This corresponds to:
2918 Current: A B C
2919 New: A C B
2920 Move C before B */
2921
2922 g_object_ref (G_OBJECT (witem2));
2923 gtk_container_remove (GTK_CONTAINER (menubar), GTK_WIDGET (witem2));
2924 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar),
2925 GTK_WIDGET (witem2), pos);
2926 g_object_unref (G_OBJECT (witem2));
2927
2928 g_list_free (*list);
2929 *list = iter = gtk_container_get_children (GTK_CONTAINER (menubar));
2930 while (nr-- > 0) iter = g_list_next (iter);
2931 if (iter) iter = g_list_next (iter);
2932 val = val->next;
2933 ++pos;
2934 }
2935 }
2936
2937 /* Update the rest of the menu bar. */
2938 xg_update_menubar (menubar, f, list, iter, pos, val,
2939 select_cb, deactivate_cb, highlight_cb, cl_data);
2940 }
2941
2942 /* Update the menu item W so it corresponds to VAL.
2943 SELECT_CB is the callback to use when a menu item is selected.
2944 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2945 CL_DATA is the data to set in the widget for menu invocation. */
2946
2947 static void
2948 xg_update_menu_item (widget_value *val,
2949 GtkWidget *w,
2950 GCallback select_cb,
2951 GCallback highlight_cb,
2952 xg_menu_cb_data *cl_data)
2953 {
2954 GtkWidget *wchild;
2955 GtkLabel *wlbl = 0;
2956 GtkLabel *wkey = 0;
2957 char *utf8_label;
2958 char *utf8_key;
2959 const char *old_label = 0;
2960 const char *old_key = 0;
2961 xg_menu_item_cb_data *cb_data;
2962 bool label_changed = false;
2963
2964 wchild = XG_BIN_CHILD (w);
2965 utf8_label = get_utf8_string (val->name);
2966 utf8_key = get_utf8_string (val->key);
2967
2968 /* See if W is a menu item with a key. See make_menu_item above. */
2969 if (GTK_IS_BOX (wchild))
2970 {
2971 GList *list = gtk_container_get_children (GTK_CONTAINER (wchild));
2972
2973 wlbl = GTK_LABEL (list->data);
2974 wkey = GTK_LABEL (list->next->data);
2975 g_list_free (list);
2976
2977 if (! utf8_key)
2978 {
2979 /* Remove the key and keep just the label. */
2980 g_object_ref (G_OBJECT (wlbl));
2981 gtk_container_remove (GTK_CONTAINER (w), wchild);
2982 gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (wlbl));
2983 g_object_unref (G_OBJECT (wlbl));
2984 wkey = 0;
2985 }
2986
2987 }
2988 else /* Just a label. */
2989 {
2990 wlbl = GTK_LABEL (wchild);
2991
2992 /* Check if there is now a key. */
2993 if (utf8_key)
2994 {
2995 GtkWidget *wtoadd = make_widget_for_menu_item (utf8_label, utf8_key);
2996 GList *list = gtk_container_get_children (GTK_CONTAINER (wtoadd));
2997
2998 wlbl = GTK_LABEL (list->data);
2999 wkey = GTK_LABEL (list->next->data);
3000 g_list_free (list);
3001
3002 gtk_container_remove (GTK_CONTAINER (w), wchild);
3003 gtk_container_add (GTK_CONTAINER (w), wtoadd);
3004 }
3005 }
3006
3007 if (wkey) old_key = gtk_label_get_label (wkey);
3008 if (wlbl) old_label = gtk_label_get_label (wlbl);
3009
3010 if (wkey && utf8_key && (! old_key || strcmp (utf8_key, old_key) != 0))
3011 {
3012 label_changed = true;
3013 gtk_label_set_text (wkey, utf8_key);
3014 }
3015
3016 if (! old_label || strcmp (utf8_label, old_label) != 0)
3017 {
3018 label_changed = true;
3019 gtk_label_set_text (wlbl, utf8_label);
3020 }
3021
3022 if (utf8_key) g_free (utf8_key);
3023 if (utf8_label) g_free (utf8_label);
3024
3025 if (! val->enabled && gtk_widget_get_sensitive (w))
3026 gtk_widget_set_sensitive (w, FALSE);
3027 else if (val->enabled && ! gtk_widget_get_sensitive (w))
3028 gtk_widget_set_sensitive (w, TRUE);
3029
3030 cb_data = g_object_get_data (G_OBJECT (w), XG_ITEM_DATA);
3031 if (cb_data)
3032 {
3033 cb_data->call_data = val->call_data;
3034 cb_data->help = val->help;
3035 cb_data->cl_data = cl_data;
3036
3037 /* We assume the callback functions don't change. */
3038 if (val->call_data && ! val->contents)
3039 {
3040 /* This item shall have a select callback. */
3041 if (! cb_data->select_id)
3042 cb_data->select_id
3043 = g_signal_connect (G_OBJECT (w), "activate",
3044 select_cb, cb_data);
3045 }
3046 else if (cb_data->select_id)
3047 {
3048 g_signal_handler_disconnect (w, cb_data->select_id);
3049 cb_data->select_id = 0;
3050 }
3051 }
3052
3053 if (label_changed) /* See comment in xg_update_menubar. */
3054 g_object_notify (G_OBJECT (w), "label");
3055 }
3056
3057 /* Update the toggle menu item W so it corresponds to VAL. */
3058
3059 static void
3060 xg_update_toggle_item (widget_value *val, GtkWidget *w)
3061 {
3062 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), val->selected);
3063 }
3064
3065 /* Update the radio menu item W so it corresponds to VAL. */
3066
3067 static void
3068 xg_update_radio_item (widget_value *val, GtkWidget *w)
3069 {
3070 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), val->selected);
3071 }
3072
3073 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3074 SUBMENU may be NULL, in that case a new menu is created.
3075 F is the frame the menu bar belongs to.
3076 VAL describes the contents of the menu bar.
3077 SELECT_CB is the callback to use when a menu item is selected.
3078 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3079 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3080 CL_DATA is the call back data to use for any newly created items.
3081
3082 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3083 was NULL. */
3084
3085 static GtkWidget *
3086 xg_update_submenu (GtkWidget *submenu,
3087 struct frame *f,
3088 widget_value *val,
3089 GCallback select_cb,
3090 GCallback deactivate_cb,
3091 GCallback highlight_cb,
3092 xg_menu_cb_data *cl_data)
3093 {
3094 GtkWidget *newsub = submenu;
3095 GList *list = 0;
3096 GList *iter;
3097 widget_value *cur;
3098 GList *first_radio = 0;
3099
3100 if (submenu)
3101 list = gtk_container_get_children (GTK_CONTAINER (submenu));
3102
3103 for (cur = val, iter = list;
3104 cur && iter;
3105 iter = g_list_next (iter), cur = cur->next)
3106 {
3107 GtkWidget *w = GTK_WIDGET (iter->data);
3108
3109 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
3110 /* Skip tearoff items, they have no counterpart in val. */
3111 if (GTK_IS_TEAROFF_MENU_ITEM (w))
3112 {
3113 iter = g_list_next (iter);
3114 if (iter) w = GTK_WIDGET (iter->data);
3115 else break;
3116 }
3117 #endif
3118
3119 /* Remember first radio button in a group. If we get a mismatch in
3120 a radio group we must rebuild the whole group so that the connections
3121 in GTK becomes correct. */
3122 if (cur->button_type == BUTTON_TYPE_RADIO && ! first_radio)
3123 first_radio = iter;
3124 else if (cur->button_type != BUTTON_TYPE_RADIO
3125 && ! GTK_IS_RADIO_MENU_ITEM (w))
3126 first_radio = 0;
3127
3128 if (GTK_IS_SEPARATOR_MENU_ITEM (w))
3129 {
3130 if (! menu_separator_name_p (cur->name))
3131 break;
3132 }
3133 else if (GTK_IS_CHECK_MENU_ITEM (w))
3134 {
3135 if (cur->button_type != BUTTON_TYPE_TOGGLE)
3136 break;
3137 xg_update_toggle_item (cur, w);
3138 xg_update_menu_item (cur, w, select_cb, highlight_cb, cl_data);
3139 }
3140 else if (GTK_IS_RADIO_MENU_ITEM (w))
3141 {
3142 if (cur->button_type != BUTTON_TYPE_RADIO)
3143 break;
3144 xg_update_radio_item (cur, w);
3145 xg_update_menu_item (cur, w, select_cb, highlight_cb, cl_data);
3146 }
3147 else if (GTK_IS_MENU_ITEM (w))
3148 {
3149 GtkMenuItem *witem = GTK_MENU_ITEM (w);
3150 GtkWidget *sub;
3151
3152 if (cur->button_type != BUTTON_TYPE_NONE ||
3153 menu_separator_name_p (cur->name))
3154 break;
3155
3156 xg_update_menu_item (cur, w, select_cb, highlight_cb, cl_data);
3157
3158 sub = gtk_menu_item_get_submenu (witem);
3159 if (sub && ! cur->contents)
3160 {
3161 /* Not a submenu anymore. */
3162 g_object_ref (G_OBJECT (sub));
3163 remove_submenu (witem);
3164 gtk_widget_destroy (sub);
3165 }
3166 else if (cur->contents)
3167 {
3168 GtkWidget *nsub;
3169
3170 nsub = xg_update_submenu (sub, f, cur->contents,
3171 select_cb, deactivate_cb,
3172 highlight_cb, cl_data);
3173
3174 /* If this item just became a submenu, we must set it. */
3175 if (nsub != sub)
3176 gtk_menu_item_set_submenu (witem, nsub);
3177 }
3178 }
3179 else
3180 {
3181 /* Structural difference. Remove everything from here and down
3182 in SUBMENU. */
3183 break;
3184 }
3185 }
3186
3187 /* Remove widgets from first structural change. */
3188 if (iter)
3189 {
3190 /* If we are adding new menu items below, we must remove from
3191 first radio button so that radio groups become correct. */
3192 if (cur && first_radio) xg_destroy_widgets (first_radio);
3193 else xg_destroy_widgets (iter);
3194 }
3195
3196 if (cur)
3197 {
3198 /* More items added. Create them. */
3199 newsub = create_menus (cur,
3200 f,
3201 select_cb,
3202 deactivate_cb,
3203 highlight_cb,
3204 0,
3205 0,
3206 1,
3207 submenu,
3208 cl_data,
3209 0);
3210 }
3211
3212 if (list) g_list_free (list);
3213
3214 return newsub;
3215 }
3216
3217 /* Update the MENUBAR.
3218 F is the frame the menu bar belongs to.
3219 VAL describes the contents of the menu bar.
3220 If DEEP_P, rebuild all but the top level menu names in
3221 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3222 SELECT_CB is the callback to use when a menu item is selected.
3223 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3224 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3225
3226 void
3227 xg_modify_menubar_widgets (GtkWidget *menubar, struct frame *f,
3228 widget_value *val, bool deep_p,
3229 GCallback select_cb, GCallback deactivate_cb,
3230 GCallback highlight_cb)
3231 {
3232 xg_menu_cb_data *cl_data;
3233 GList *list = gtk_container_get_children (GTK_CONTAINER (menubar));
3234
3235 if (! list) return;
3236
3237 cl_data = g_object_get_data (G_OBJECT (menubar), XG_FRAME_DATA);
3238
3239 xg_update_menubar (menubar, f, &list, list, 0, val->contents,
3240 select_cb, deactivate_cb, highlight_cb, cl_data);
3241
3242 if (deep_p)
3243 {
3244 widget_value *cur;
3245
3246 /* Update all sub menus.
3247 We must keep the submenus (GTK menu item widgets) since the
3248 X Window in the XEvent that activates the menu are those widgets. */
3249
3250 /* Update cl_data, menu_item things in F may have changed. */
3251 update_cl_data (cl_data, f, highlight_cb);
3252
3253 for (cur = val->contents; cur; cur = cur->next)
3254 {
3255 GList *iter;
3256 GtkWidget *sub = 0;
3257 GtkWidget *newsub;
3258 GtkMenuItem *witem = 0;
3259
3260 /* Find sub menu that corresponds to val and update it. */
3261 for (iter = list ; iter; iter = g_list_next (iter))
3262 {
3263 witem = GTK_MENU_ITEM (iter->data);
3264 if (xg_item_label_same_p (witem, cur->name))
3265 {
3266 sub = gtk_menu_item_get_submenu (witem);
3267 break;
3268 }
3269 }
3270
3271 newsub = xg_update_submenu (sub,
3272 f,
3273 cur->contents,
3274 select_cb,
3275 deactivate_cb,
3276 highlight_cb,
3277 cl_data);
3278 /* sub may still be NULL. If we just updated non deep and added
3279 a new menu bar item, it has no sub menu yet. So we set the
3280 newly created sub menu under witem. */
3281 if (newsub != sub && witem != 0)
3282 {
3283 xg_set_screen (newsub, f);
3284 gtk_menu_item_set_submenu (witem, newsub);
3285 }
3286 }
3287 }
3288
3289 g_list_free (list);
3290 gtk_widget_show_all (menubar);
3291 }
3292
3293 /* Callback called when the menu bar W is mapped.
3294 Used to find the height of the menu bar if we didn't get it
3295 after showing the widget. */
3296
3297 static void
3298 menubar_map_cb (GtkWidget *w, gpointer user_data)
3299 {
3300 GtkRequisition req;
3301 struct frame *f = user_data;
3302 gtk_widget_get_preferred_size (w, NULL, &req);
3303 if (FRAME_MENUBAR_HEIGHT (f) != req.height)
3304 {
3305 FRAME_MENUBAR_HEIGHT (f) = req.height;
3306 xg_height_or_width_changed (f);
3307 }
3308 }
3309
3310 /* Recompute all the widgets of frame F, when the menu bar has been
3311 changed. */
3312
3313 void
3314 xg_update_frame_menubar (struct frame *f)
3315 {
3316 struct x_output *x = f->output_data.x;
3317 GtkRequisition req;
3318
3319 if (!x->menubar_widget || gtk_widget_get_mapped (x->menubar_widget))
3320 return;
3321
3322 if (x->menubar_widget && gtk_widget_get_parent (x->menubar_widget))
3323 return; /* Already done this, happens for frames created invisible. */
3324
3325 block_input ();
3326
3327 gtk_box_pack_start (GTK_BOX (x->vbox_widget), x->menubar_widget,
3328 FALSE, FALSE, 0);
3329 gtk_box_reorder_child (GTK_BOX (x->vbox_widget), x->menubar_widget, 0);
3330
3331 g_signal_connect (x->menubar_widget, "map", G_CALLBACK (menubar_map_cb), f);
3332 gtk_widget_show_all (x->menubar_widget);
3333 gtk_widget_get_preferred_size (x->menubar_widget, NULL, &req);
3334
3335 if (FRAME_MENUBAR_HEIGHT (f) != req.height)
3336 {
3337 FRAME_MENUBAR_HEIGHT (f) = req.height;
3338 xg_height_or_width_changed (f);
3339 }
3340 unblock_input ();
3341 }
3342
3343 /* Get rid of the menu bar of frame F, and free its storage.
3344 This is used when deleting a frame, and when turning off the menu bar. */
3345
3346 void
3347 free_frame_menubar (struct frame *f)
3348 {
3349 struct x_output *x = f->output_data.x;
3350
3351 if (x->menubar_widget)
3352 {
3353 block_input ();
3354
3355 gtk_container_remove (GTK_CONTAINER (x->vbox_widget), x->menubar_widget);
3356 /* The menubar and its children shall be deleted when removed from
3357 the container. */
3358 x->menubar_widget = 0;
3359 FRAME_MENUBAR_HEIGHT (f) = 0;
3360 xg_height_or_width_changed (f);
3361 unblock_input ();
3362 }
3363 }
3364
3365 bool
3366 xg_event_is_for_menubar (struct frame *f, const XEvent *event)
3367 {
3368 struct x_output *x = f->output_data.x;
3369 GList *iter;
3370 GdkRectangle rec;
3371 GList *list;
3372 GdkDisplay *gdpy;
3373 GdkWindow *gw;
3374 GdkEvent gevent;
3375 GtkWidget *gwdesc;
3376
3377 if (! x->menubar_widget) return 0;
3378
3379 if (! (event->xbutton.x >= 0
3380 && event->xbutton.x < FRAME_PIXEL_WIDTH (f)
3381 && event->xbutton.y >= 0
3382 && event->xbutton.y < FRAME_MENUBAR_HEIGHT (f)
3383 && event->xbutton.same_screen))
3384 return 0;
3385
3386 gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
3387 gw = gdk_x11_window_lookup_for_display (gdpy, event->xbutton.window);
3388 if (! gw) return 0;
3389 gevent.any.window = gw;
3390 gevent.any.type = GDK_NOTHING;
3391 gwdesc = gtk_get_event_widget (&gevent);
3392 if (! gwdesc) return 0;
3393 if (! GTK_IS_MENU_BAR (gwdesc)
3394 && ! GTK_IS_MENU_ITEM (gwdesc)
3395 && ! gtk_widget_is_ancestor (x->menubar_widget, gwdesc))
3396 return 0;
3397
3398 list = gtk_container_get_children (GTK_CONTAINER (x->menubar_widget));
3399 if (! list) return 0;
3400 rec.x = event->xbutton.x;
3401 rec.y = event->xbutton.y;
3402 rec.width = 1;
3403 rec.height = 1;
3404
3405 for (iter = list ; iter; iter = g_list_next (iter))
3406 {
3407 GtkWidget *w = GTK_WIDGET (iter->data);
3408 if (gtk_widget_get_mapped (w) && gtk_widget_intersect (w, &rec, NULL))
3409 break;
3410 }
3411 g_list_free (list);
3412 return iter != 0;
3413 }
3414
3415
3416 \f
3417 /***********************************************************************
3418 Scroll bar functions
3419 ***********************************************************************/
3420
3421
3422 /* Setting scroll bar values invokes the callback. Use this variable
3423 to indicate that callback should do nothing. */
3424
3425 bool xg_ignore_gtk_scrollbar;
3426
3427 /* Width and height of scroll bars for the current theme. */
3428 static int scroll_bar_width_for_theme;
3429 static int scroll_bar_height_for_theme;
3430
3431 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3432 may be larger than 32 bits. Keep a mapping from integer index to widget
3433 pointers to get around the 32 bit limitation. */
3434
3435 static struct
3436 {
3437 GtkWidget **widgets;
3438 ptrdiff_t max_size;
3439 ptrdiff_t used;
3440 } id_to_widget;
3441
3442 /* Grow this much every time we need to allocate more */
3443
3444 #define ID_TO_WIDGET_INCR 32
3445
3446 /* Store the widget pointer W in id_to_widget and return the integer index. */
3447
3448 static ptrdiff_t
3449 xg_store_widget_in_map (GtkWidget *w)
3450 {
3451 ptrdiff_t i;
3452
3453 if (id_to_widget.max_size == id_to_widget.used)
3454 {
3455 ptrdiff_t new_size;
3456 if (TYPE_MAXIMUM (Window) - ID_TO_WIDGET_INCR < id_to_widget.max_size)
3457 memory_full (SIZE_MAX);
3458
3459 new_size = id_to_widget.max_size + ID_TO_WIDGET_INCR;
3460 id_to_widget.widgets = xnrealloc (id_to_widget.widgets,
3461 new_size, sizeof (GtkWidget *));
3462
3463 for (i = id_to_widget.max_size; i < new_size; ++i)
3464 id_to_widget.widgets[i] = 0;
3465 id_to_widget.max_size = new_size;
3466 }
3467
3468 /* Just loop over the array and find a free place. After all,
3469 how many scroll bars are we creating? Should be a small number.
3470 The check above guarantees we will find a free place. */
3471 for (i = 0; i < id_to_widget.max_size; ++i)
3472 {
3473 if (! id_to_widget.widgets[i])
3474 {
3475 id_to_widget.widgets[i] = w;
3476 ++id_to_widget.used;
3477
3478 return i;
3479 }
3480 }
3481
3482 /* Should never end up here */
3483 emacs_abort ();
3484 }
3485
3486 /* Remove pointer at IDX from id_to_widget.
3487 Called when scroll bar is destroyed. */
3488
3489 static void
3490 xg_remove_widget_from_map (ptrdiff_t idx)
3491 {
3492 if (idx < id_to_widget.max_size && id_to_widget.widgets[idx] != 0)
3493 {
3494 id_to_widget.widgets[idx] = 0;
3495 --id_to_widget.used;
3496 }
3497 }
3498
3499 /* Get the widget pointer at IDX from id_to_widget. */
3500
3501 static GtkWidget *
3502 xg_get_widget_from_map (ptrdiff_t idx)
3503 {
3504 if (idx < id_to_widget.max_size && id_to_widget.widgets[idx] != 0)
3505 return id_to_widget.widgets[idx];
3506
3507 return 0;
3508 }
3509
3510 static void
3511 update_theme_scrollbar_width (void)
3512 {
3513 #ifdef HAVE_GTK3
3514 GtkAdjustment *vadj;
3515 #else
3516 GtkObject *vadj;
3517 #endif
3518 GtkWidget *wscroll;
3519 int w = 0, b = 0;
3520
3521 vadj = gtk_adjustment_new (XG_SB_MIN, XG_SB_MIN, XG_SB_MAX, 0.1, 0.1, 0.1);
3522 wscroll = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (vadj));
3523 g_object_ref_sink (G_OBJECT (wscroll));
3524 gtk_widget_style_get (wscroll, "slider-width", &w, "trough-border", &b, NULL);
3525 gtk_widget_destroy (wscroll);
3526 g_object_unref (G_OBJECT (wscroll));
3527 w += 2*b;
3528 if (w < 16) w = 16;
3529 scroll_bar_width_for_theme = w;
3530 }
3531
3532 static void
3533 update_theme_scrollbar_height (void)
3534 {
3535 #ifdef HAVE_GTK3
3536 GtkAdjustment *hadj;
3537 #else
3538 GtkObject *hadj;
3539 #endif
3540 GtkWidget *wscroll;
3541 int w = 0, b = 0;
3542
3543 hadj = gtk_adjustment_new (YG_SB_MIN, YG_SB_MIN, YG_SB_MAX, 0.1, 0.1, 0.1);
3544 wscroll = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (hadj));
3545 g_object_ref_sink (G_OBJECT (wscroll));
3546 gtk_widget_style_get (wscroll, "slider-width", &w, "trough-border", &b, NULL);
3547 gtk_widget_destroy (wscroll);
3548 g_object_unref (G_OBJECT (wscroll));
3549 w += 2*b;
3550 if (w < 12) w = 12;
3551 scroll_bar_height_for_theme = w;
3552 }
3553
3554 int
3555 xg_get_default_scrollbar_width (void)
3556 {
3557 return scroll_bar_width_for_theme;
3558 }
3559
3560 int
3561 xg_get_default_scrollbar_height (void)
3562 {
3563 /* Apparently there's no default height for themes. */
3564 return scroll_bar_width_for_theme;
3565 }
3566
3567 /* Return the scrollbar id for X Window WID on display DPY.
3568 Return -1 if WID not in id_to_widget. */
3569
3570 ptrdiff_t
3571 xg_get_scroll_id_for_window (Display *dpy, Window wid)
3572 {
3573 ptrdiff_t idx;
3574 GtkWidget *w;
3575
3576 w = xg_win_to_widget (dpy, wid);
3577
3578 if (w)
3579 {
3580 for (idx = 0; idx < id_to_widget.max_size; ++idx)
3581 if (id_to_widget.widgets[idx] == w)
3582 return idx;
3583 }
3584
3585 return -1;
3586 }
3587
3588 /* Callback invoked when scroll bar WIDGET is destroyed.
3589 DATA is the index into id_to_widget for WIDGET.
3590 We free pointer to last scroll bar values here and remove the index. */
3591
3592 static void
3593 xg_gtk_scroll_destroy (GtkWidget *widget, gpointer data)
3594 {
3595 intptr_t id = (intptr_t) data;
3596 xg_remove_widget_from_map (id);
3597 }
3598
3599 /* Create a scroll bar widget for frame F. Store the scroll bar
3600 in BAR.
3601 SCROLL_CALLBACK is the callback to invoke when the value of the
3602 bar changes.
3603 END_CALLBACK is the callback to invoke when scrolling ends.
3604 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3605 to set resources for the widget. */
3606
3607 void
3608 xg_create_scroll_bar (struct frame *f,
3609 struct scroll_bar *bar,
3610 GCallback scroll_callback,
3611 GCallback end_callback,
3612 const char *scroll_bar_name)
3613 {
3614 GtkWidget *wscroll;
3615 GtkWidget *webox;
3616 intptr_t scroll_id;
3617 #ifdef HAVE_GTK3
3618 GtkAdjustment *vadj;
3619 #else
3620 GtkObject *vadj;
3621 #endif
3622
3623 /* Page, step increment values are not so important here, they
3624 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3625 vadj = gtk_adjustment_new (XG_SB_MIN, XG_SB_MIN, XG_SB_MAX,
3626 0.1, 0.1, 0.1);
3627
3628 wscroll = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (vadj));
3629 webox = gtk_event_box_new ();
3630 gtk_widget_set_name (wscroll, scroll_bar_name);
3631 #ifndef HAVE_GTK3
3632 gtk_range_set_update_policy (GTK_RANGE (wscroll), GTK_UPDATE_CONTINUOUS);
3633 #endif
3634 g_object_set_data (G_OBJECT (wscroll), XG_FRAME_DATA, (gpointer)f);
3635
3636 scroll_id = xg_store_widget_in_map (wscroll);
3637
3638 g_signal_connect (G_OBJECT (wscroll),
3639 "destroy",
3640 G_CALLBACK (xg_gtk_scroll_destroy),
3641 (gpointer) scroll_id);
3642 g_signal_connect (G_OBJECT (wscroll),
3643 "change-value",
3644 scroll_callback,
3645 (gpointer) bar);
3646 g_signal_connect (G_OBJECT (wscroll),
3647 "button-release-event",
3648 end_callback,
3649 (gpointer) bar);
3650
3651 /* The scroll bar widget does not draw on a window of its own. Instead
3652 it draws on the parent window, in this case the edit widget. So
3653 whenever the edit widget is cleared, the scroll bar needs to redraw
3654 also, which causes flicker. Put an event box between the edit widget
3655 and the scroll bar, so the scroll bar instead draws itself on the
3656 event box window. */
3657 gtk_fixed_put (GTK_FIXED (f->output_data.x->edit_widget), webox, -1, -1);
3658 gtk_container_add (GTK_CONTAINER (webox), wscroll);
3659
3660
3661 /* Set the cursor to an arrow. */
3662 xg_set_cursor (webox, FRAME_DISPLAY_INFO (f)->xg_cursor);
3663
3664 bar->x_window = scroll_id;
3665 bar->horizontal = 0;
3666 }
3667
3668 /* Create a horizontal scroll bar widget for frame F. Store the scroll
3669 bar in BAR. SCROLL_CALLBACK is the callback to invoke when the value
3670 of the bar changes. END_CALLBACK is the callback to invoke when
3671 scrolling ends. SCROLL_BAR_NAME is the name we use for the scroll
3672 bar. Can be used to set resources for the widget. */
3673
3674 void
3675 xg_create_horizontal_scroll_bar (struct frame *f,
3676 struct scroll_bar *bar,
3677 GCallback scroll_callback,
3678 GCallback end_callback,
3679 const char *scroll_bar_name)
3680 {
3681 GtkWidget *wscroll;
3682 GtkWidget *webox;
3683 intptr_t scroll_id;
3684 #ifdef HAVE_GTK3
3685 GtkAdjustment *hadj;
3686 #else
3687 GtkObject *hadj;
3688 #endif
3689
3690 /* Page, step increment values are not so important here, they
3691 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3692 hadj = gtk_adjustment_new (YG_SB_MIN, YG_SB_MIN, YG_SB_MAX,
3693 0.1, 0.1, 0.1);
3694
3695 wscroll = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (hadj));
3696 webox = gtk_event_box_new ();
3697 gtk_widget_set_name (wscroll, scroll_bar_name);
3698 #ifndef HAVE_GTK3
3699 gtk_range_set_update_policy (GTK_RANGE (wscroll), GTK_UPDATE_CONTINUOUS);
3700 #endif
3701 g_object_set_data (G_OBJECT (wscroll), XG_FRAME_DATA, (gpointer)f);
3702
3703 scroll_id = xg_store_widget_in_map (wscroll);
3704
3705 g_signal_connect (G_OBJECT (wscroll),
3706 "destroy",
3707 G_CALLBACK (xg_gtk_scroll_destroy),
3708 (gpointer) scroll_id);
3709 g_signal_connect (G_OBJECT (wscroll),
3710 "change-value",
3711 scroll_callback,
3712 (gpointer) bar);
3713 g_signal_connect (G_OBJECT (wscroll),
3714 "button-release-event",
3715 end_callback,
3716 (gpointer) bar);
3717
3718 /* The scroll bar widget does not draw on a window of its own. Instead
3719 it draws on the parent window, in this case the edit widget. So
3720 whenever the edit widget is cleared, the scroll bar needs to redraw
3721 also, which causes flicker. Put an event box between the edit widget
3722 and the scroll bar, so the scroll bar instead draws itself on the
3723 event box window. */
3724 gtk_fixed_put (GTK_FIXED (f->output_data.x->edit_widget), webox, -1, -1);
3725 gtk_container_add (GTK_CONTAINER (webox), wscroll);
3726
3727
3728 /* Set the cursor to an arrow. */
3729 xg_set_cursor (webox, FRAME_DISPLAY_INFO (f)->xg_cursor);
3730
3731 bar->x_window = scroll_id;
3732 bar->horizontal = 1;
3733 }
3734
3735 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3736
3737 void
3738 xg_remove_scroll_bar (struct frame *f, ptrdiff_t scrollbar_id)
3739 {
3740 GtkWidget *w = xg_get_widget_from_map (scrollbar_id);
3741 if (w)
3742 {
3743 GtkWidget *wparent = gtk_widget_get_parent (w);
3744 gtk_widget_destroy (w);
3745 gtk_widget_destroy (wparent);
3746 SET_FRAME_GARBAGED (f);
3747 }
3748 }
3749
3750 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3751 in frame F.
3752 TOP/LEFT are the new pixel positions where the bar shall appear.
3753 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3754
3755 void
3756 xg_update_scrollbar_pos (struct frame *f,
3757 ptrdiff_t scrollbar_id,
3758 int top,
3759 int left,
3760 int width,
3761 int height)
3762 {
3763
3764 GtkWidget *wscroll = xg_get_widget_from_map (scrollbar_id);
3765
3766 if (wscroll)
3767 {
3768 GtkWidget *wfixed = f->output_data.x->edit_widget;
3769 GtkWidget *wparent = gtk_widget_get_parent (wscroll);
3770 gint msl;
3771
3772 /* Clear out old position. */
3773 int oldx = -1, oldy = -1, oldw, oldh;
3774 if (gtk_widget_get_parent (wparent) == wfixed)
3775 {
3776 gtk_container_child_get (GTK_CONTAINER (wfixed), wparent,
3777 "x", &oldx, "y", &oldy, NULL);
3778 gtk_widget_get_size_request (wscroll, &oldw, &oldh);
3779 }
3780
3781 /* Move and resize to new values. */
3782 gtk_fixed_move (GTK_FIXED (wfixed), wparent, left, top);
3783 gtk_widget_style_get (wscroll, "min-slider-length", &msl, NULL);
3784 if (msl > height)
3785 {
3786 /* No room. Hide scroll bar as some themes output a warning if
3787 the height is less than the min size. */
3788 gtk_widget_hide (wparent);
3789 gtk_widget_hide (wscroll);
3790 }
3791 else
3792 {
3793 gtk_widget_show_all (wparent);
3794 gtk_widget_set_size_request (wscroll, width, height);
3795 }
3796 gtk_widget_queue_draw (wfixed);
3797 gdk_window_process_all_updates ();
3798 if (oldx != -1 && oldw > 0 && oldh > 0)
3799 /* Clear under old scroll bar position. This must be done after
3800 the gtk_widget_queue_draw and gdk_window_process_all_updates
3801 above. */
3802 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3803 oldx, oldy, oldw, oldh);
3804
3805 /* GTK does not redraw until the main loop is entered again, but
3806 if there are no X events pending we will not enter it. So we sync
3807 here to get some events. */
3808
3809 x_sync (f);
3810 SET_FRAME_GARBAGED (f);
3811 cancel_mouse_face (f);
3812 }
3813 }
3814
3815
3816 /* Update the position of the horizontal scroll bar represented by SCROLLBAR_ID
3817 in frame F.
3818 TOP/LEFT are the new pixel positions where the bar shall appear.
3819 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3820
3821 void
3822 xg_update_horizontal_scrollbar_pos (struct frame *f,
3823 ptrdiff_t scrollbar_id,
3824 int top,
3825 int left,
3826 int width,
3827 int height)
3828 {
3829
3830 GtkWidget *wscroll = xg_get_widget_from_map (scrollbar_id);
3831
3832 if (wscroll)
3833 {
3834 GtkWidget *wfixed = f->output_data.x->edit_widget;
3835 GtkWidget *wparent = gtk_widget_get_parent (wscroll);
3836 gint msl;
3837
3838 /* Clear out old position. */
3839 int oldx = -1, oldy = -1, oldw, oldh;
3840 if (gtk_widget_get_parent (wparent) == wfixed)
3841 {
3842 gtk_container_child_get (GTK_CONTAINER (wfixed), wparent,
3843 "x", &oldx, "y", &oldy, NULL);
3844 gtk_widget_get_size_request (wscroll, &oldw, &oldh);
3845 }
3846
3847 /* Move and resize to new values. */
3848 gtk_fixed_move (GTK_FIXED (wfixed), wparent, left, top);
3849 gtk_widget_style_get (wscroll, "min-slider-length", &msl, NULL);
3850 if (msl > width)
3851 {
3852 /* No room. Hide scroll bar as some themes output a warning if
3853 the width is less than the min size. */
3854 gtk_widget_hide (wparent);
3855 gtk_widget_hide (wscroll);
3856 }
3857 else
3858 {
3859 gtk_widget_show_all (wparent);
3860 gtk_widget_set_size_request (wscroll, width, height);
3861 }
3862 gtk_widget_queue_draw (wfixed);
3863 gdk_window_process_all_updates ();
3864 if (oldx != -1 && oldw > 0 && oldh > 0)
3865 /* Clear under old scroll bar position. This must be done after
3866 the gtk_widget_queue_draw and gdk_window_process_all_updates
3867 above. */
3868 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3869 oldx, oldy, oldw, oldh);
3870
3871 /* GTK does not redraw until the main loop is entered again, but
3872 if there are no X events pending we will not enter it. So we sync
3873 here to get some events. */
3874
3875 x_sync (f);
3876 SET_FRAME_GARBAGED (f);
3877 cancel_mouse_face (f);
3878 }
3879 }
3880
3881
3882 /* Get the current value of the range, truncated to an integer. */
3883
3884 static int
3885 int_gtk_range_get_value (GtkRange *range)
3886 {
3887 return gtk_range_get_value (range);
3888 }
3889
3890
3891 /* Set the thumb size and position of scroll bar BAR. We are currently
3892 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3893
3894 void
3895 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar,
3896 int portion,
3897 int position,
3898 int whole)
3899 {
3900 GtkWidget *wscroll = xg_get_widget_from_map (bar->x_window);
3901
3902 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3903
3904 if (wscroll && bar->dragging == -1)
3905 {
3906 GtkAdjustment *adj;
3907 gdouble shown;
3908 gdouble top;
3909 int size, value;
3910 int old_size;
3911 int new_step;
3912 bool changed = 0;
3913
3914 adj = gtk_range_get_adjustment (GTK_RANGE (wscroll));
3915
3916 if (scroll_bar_adjust_thumb_portion_p)
3917 {
3918 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3919 line rather than the real portion value. This makes the
3920 thumb less likely to resize and that looks better. */
3921 portion = WINDOW_TOTAL_LINES (XWINDOW (bar->window)) * 30;
3922
3923 /* When the thumb is at the bottom, position == whole.
3924 So we need to increase `whole' to make space for the thumb. */
3925 whole += portion;
3926 }
3927
3928 if (whole <= 0)
3929 top = 0, shown = 1;
3930 else
3931 {
3932 top = (gdouble) position / whole;
3933 shown = (gdouble) portion / whole;
3934 }
3935
3936 size = clip_to_bounds (1, shown * XG_SB_RANGE, XG_SB_RANGE);
3937 value = clip_to_bounds (XG_SB_MIN, top * XG_SB_RANGE, XG_SB_MAX - size);
3938
3939 /* Assume all lines are of equal size. */
3940 new_step = size / max (1, FRAME_LINES (f));
3941
3942 old_size = gtk_adjustment_get_page_size (adj);
3943 if (old_size != size)
3944 {
3945 int old_step = gtk_adjustment_get_step_increment (adj);
3946 if (old_step != new_step)
3947 {
3948 gtk_adjustment_set_page_size (adj, size);
3949 gtk_adjustment_set_step_increment (adj, new_step);
3950 /* Assume a page increment is about 95% of the page size */
3951 gtk_adjustment_set_page_increment (adj, size - size / 20);
3952 changed = 1;
3953 }
3954 }
3955
3956 if (changed || int_gtk_range_get_value (GTK_RANGE (wscroll)) != value)
3957 {
3958 block_input ();
3959
3960 /* gtk_range_set_value invokes the callback. Set
3961 ignore_gtk_scrollbar to make the callback do nothing */
3962 xg_ignore_gtk_scrollbar = 1;
3963
3964 if (int_gtk_range_get_value (GTK_RANGE (wscroll)) != value)
3965 gtk_range_set_value (GTK_RANGE (wscroll), (gdouble)value);
3966 else if (changed)
3967 gtk_adjustment_changed (adj);
3968
3969 xg_ignore_gtk_scrollbar = 0;
3970
3971 unblock_input ();
3972 }
3973 }
3974 }
3975
3976 /* Set the thumb size and position of horizontal scroll bar BAR. We are
3977 currently displaying PORTION out of a whole WHOLE, and our position
3978 POSITION. */
3979 void
3980 xg_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar *bar,
3981 int portion,
3982 int position,
3983 int whole)
3984 {
3985 GtkWidget *wscroll = xg_get_widget_from_map (bar->x_window);
3986
3987 if (wscroll && bar->dragging == -1)
3988 {
3989 GtkAdjustment *adj;
3990 int lower = 0;
3991 int upper = max (whole - 1, 0);
3992 int pagesize = min (upper, max (portion, 0));
3993 int value = max (0, min (position, upper - pagesize));
3994 /* These should be set to something more <portion, whole>
3995 related. */
3996 int page_increment = 4;
3997 int step_increment = 1;
3998
3999 block_input ();
4000 adj = gtk_range_get_adjustment (GTK_RANGE (wscroll));
4001 #if GTK_CHECK_VERSION (2, 3, 16)
4002 gtk_adjustment_configure (adj, (gdouble) value, (gdouble) lower,
4003 (gdouble) upper, (gdouble) step_increment,
4004 (gdouble) page_increment, (gdouble) pagesize);
4005 #else
4006 gtk_adjustment_set_lower (adj, (gdouble) lower);
4007 gtk_adjustment_set_upper (adj, (gdouble) upper);
4008 gtk_adjustment_set_page_size (adj, (gdouble) pagesize);
4009 gtk_adjustment_set_value (adj, (gdouble) value);
4010 gtk_adjustment_set_page_increment (adj, (gdouble) page_increment);
4011 gtk_adjustment_set_step_increment (adj, (gdouble) step_increment);
4012 #endif
4013 gtk_adjustment_changed (adj);
4014 unblock_input ();
4015 }
4016 }
4017
4018 /* Return true if EVENT is for a scroll bar in frame F.
4019 When the same X window is used for several Gtk+ widgets, we cannot
4020 say for sure based on the X window alone if an event is for the
4021 frame. This function does additional checks. */
4022
4023 bool
4024 xg_event_is_for_scrollbar (struct frame *f, const XEvent *event)
4025 {
4026 bool retval = 0;
4027
4028 if (f && event->type == ButtonPress && event->xbutton.button < 4)
4029 {
4030 /* Check if press occurred outside the edit widget. */
4031 GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
4032 GdkWindow *gwin;
4033 #ifdef HAVE_GTK3
4034 GdkDevice *gdev = gdk_device_manager_get_client_pointer
4035 (gdk_display_get_device_manager (gdpy));
4036 gwin = gdk_device_get_window_at_position (gdev, NULL, NULL);
4037 #else
4038 gwin = gdk_display_get_window_at_pointer (gdpy, NULL, NULL);
4039 #endif
4040 retval = gwin != gtk_widget_get_window (f->output_data.x->edit_widget);
4041 }
4042 else if (f
4043 && ((event->type == ButtonRelease && event->xbutton.button < 4)
4044 || event->type == MotionNotify))
4045 {
4046 /* If we are releasing or moving the scroll bar, it has the grab. */
4047 GtkWidget *w = gtk_grab_get_current ();
4048 retval = w != 0 && GTK_IS_SCROLLBAR (w);
4049 }
4050
4051 return retval;
4052 }
4053
4054
4055 \f
4056 /***********************************************************************
4057 Tool bar functions
4058 ***********************************************************************/
4059 /* The key for the data we put in the GtkImage widgets. The data is
4060 the image used by Emacs. We use this to see if we need to update
4061 the GtkImage with a new image. */
4062 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
4063
4064 /* The key for storing the latest modifiers so the activate callback can
4065 get them. */
4066 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
4067
4068 /* The key for storing the button widget in its proxy menu item. */
4069 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
4070
4071 /* The key for the data we put in the GtkImage widgets. The data is
4072 the stock name used by Emacs. We use this to see if we need to update
4073 the GtkImage with a new image. */
4074 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
4075
4076 /* As above, but this is used for named theme widgets, as opposed to
4077 stock items. */
4078 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
4079
4080 /* Callback function invoked when a tool bar item is pressed.
4081 W is the button widget in the tool bar that got pressed,
4082 CLIENT_DATA is an integer that is the index of the button in the
4083 tool bar. 0 is the first button. */
4084
4085 static gboolean
4086 xg_tool_bar_button_cb (GtkWidget *widget,
4087 GdkEventButton *event,
4088 gpointer user_data)
4089 {
4090 intptr_t state = event->state;
4091 gpointer ptr = (gpointer) state;
4092 g_object_set_data (G_OBJECT (widget), XG_TOOL_BAR_LAST_MODIFIER, ptr);
4093 return FALSE;
4094 }
4095
4096
4097 /* Callback function invoked when a tool bar item is pressed.
4098 W is the button widget in the tool bar that got pressed,
4099 CLIENT_DATA is an integer that is the index of the button in the
4100 tool bar. 0 is the first button. */
4101
4102 static void
4103 xg_tool_bar_callback (GtkWidget *w, gpointer client_data)
4104 {
4105 intptr_t idx = (intptr_t) client_data;
4106 gpointer gmod = g_object_get_data (G_OBJECT (w), XG_TOOL_BAR_LAST_MODIFIER);
4107 intptr_t mod = (intptr_t) gmod;
4108
4109 struct frame *f = g_object_get_data (G_OBJECT (w), XG_FRAME_DATA);
4110 Lisp_Object key, frame;
4111 struct input_event event;
4112 EVENT_INIT (event);
4113
4114 if (! f || ! f->n_tool_bar_items || NILP (f->tool_bar_items))
4115 return;
4116
4117 idx *= TOOL_BAR_ITEM_NSLOTS;
4118
4119 key = AREF (f->tool_bar_items, idx + TOOL_BAR_ITEM_KEY);
4120 XSETFRAME (frame, f);
4121
4122 /* We generate two events here. The first one is to set the prefix
4123 to `(tool_bar)', see keyboard.c. */
4124 event.kind = TOOL_BAR_EVENT;
4125 event.frame_or_window = frame;
4126 event.arg = frame;
4127 kbd_buffer_store_event (&event);
4128
4129 event.kind = TOOL_BAR_EVENT;
4130 event.frame_or_window = frame;
4131 event.arg = key;
4132 /* Convert between the modifier bits GDK uses and the modifier bits
4133 Emacs uses. This assumes GDK and X masks are the same, which they are when
4134 this is written. */
4135 event.modifiers = x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f), mod);
4136 kbd_buffer_store_event (&event);
4137
4138 /* Return focus to the frame after we have clicked on a detached
4139 tool bar button. */
4140 x_focus_frame (f);
4141 }
4142
4143 /* Callback function invoked when a tool bar item is pressed in a detached
4144 tool bar or the overflow drop down menu.
4145 We just call xg_tool_bar_callback.
4146 W is the menu item widget that got pressed,
4147 CLIENT_DATA is an integer that is the index of the button in the
4148 tool bar. 0 is the first button. */
4149
4150 static void
4151 xg_tool_bar_proxy_callback (GtkWidget *w, gpointer client_data)
4152 {
4153 GtkWidget *wbutton = GTK_WIDGET (g_object_get_data (G_OBJECT (w),
4154 XG_TOOL_BAR_PROXY_BUTTON));
4155 xg_tool_bar_callback (wbutton, client_data);
4156 }
4157
4158
4159 static gboolean
4160 xg_tool_bar_help_callback (GtkWidget *w,
4161 GdkEventCrossing *event,
4162 gpointer client_data);
4163
4164 /* This callback is called when a help is to be shown for an item in
4165 the detached tool bar when the detached tool bar it is not expanded. */
4166
4167 static gboolean
4168 xg_tool_bar_proxy_help_callback (GtkWidget *w,
4169 GdkEventCrossing *event,
4170 gpointer client_data)
4171 {
4172 GtkWidget *wbutton = GTK_WIDGET (g_object_get_data (G_OBJECT (w),
4173 XG_TOOL_BAR_PROXY_BUTTON));
4174
4175 return xg_tool_bar_help_callback (wbutton, event, client_data);
4176 }
4177
4178 static GtkWidget *
4179 xg_get_tool_bar_widgets (GtkWidget *vb, GtkWidget **wimage)
4180 {
4181 GList *clist = gtk_container_get_children (GTK_CONTAINER (vb));
4182 GtkWidget *c1 = clist->data;
4183 GtkWidget *c2 = clist->next ? clist->next->data : NULL;
4184
4185 *wimage = GTK_IS_IMAGE (c1) ? c1 : c2;
4186 g_list_free (clist);
4187 return GTK_IS_LABEL (c1) ? c1 : c2;
4188 }
4189
4190
4191 /* This callback is called when a tool item should create a proxy item,
4192 such as for the overflow menu. Also called when the tool bar is detached.
4193 If we don't create a proxy menu item, the detached tool bar will be
4194 blank. */
4195
4196 static gboolean
4197 xg_tool_bar_menu_proxy (GtkToolItem *toolitem, gpointer user_data)
4198 {
4199 GtkButton *wbutton = GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem)));
4200 GtkWidget *vb = XG_BIN_CHILD (wbutton);
4201 GtkWidget *c1;
4202 GtkLabel *wlbl = GTK_LABEL (xg_get_tool_bar_widgets (vb, &c1));
4203 GtkImage *wimage = GTK_IMAGE (c1);
4204 GtkWidget *wmenuitem = gtk_image_menu_item_new_with_label
4205 (wlbl ? gtk_label_get_text (wlbl) : "");
4206 GtkWidget *wmenuimage;
4207
4208
4209 if (gtk_button_get_use_stock (wbutton))
4210 wmenuimage = gtk_image_new_from_stock (gtk_button_get_label (wbutton),
4211 GTK_ICON_SIZE_MENU);
4212 else
4213 {
4214 GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (wbutton));
4215 GtkImageType store_type = gtk_image_get_storage_type (wimage);
4216
4217 g_object_set (G_OBJECT (settings), "gtk-menu-images", TRUE, NULL);
4218
4219 if (store_type == GTK_IMAGE_STOCK)
4220 {
4221 gchar *stock_id;
4222 gtk_image_get_stock (wimage, &stock_id, NULL);
4223 wmenuimage = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);
4224 }
4225 else if (store_type == GTK_IMAGE_ICON_SET)
4226 {
4227 GtkIconSet *icon_set;
4228 gtk_image_get_icon_set (wimage, &icon_set, NULL);
4229 wmenuimage = gtk_image_new_from_icon_set (icon_set,
4230 GTK_ICON_SIZE_MENU);
4231 }
4232 else if (store_type == GTK_IMAGE_PIXBUF)
4233 {
4234 gint width, height;
4235
4236 if (settings &&
4237 gtk_icon_size_lookup_for_settings (settings, GTK_ICON_SIZE_MENU,
4238 &width, &height))
4239 {
4240 GdkPixbuf *src_pixbuf, *dest_pixbuf;
4241
4242 src_pixbuf = gtk_image_get_pixbuf (wimage);
4243 dest_pixbuf = gdk_pixbuf_scale_simple (src_pixbuf, width, height,
4244 GDK_INTERP_BILINEAR);
4245
4246 wmenuimage = gtk_image_new_from_pixbuf (dest_pixbuf);
4247 }
4248 else
4249 {
4250 fprintf (stderr, "internal error: GTK_IMAGE_PIXBUF failed\n");
4251 emacs_abort ();
4252 }
4253 }
4254 else if (store_type == GTK_IMAGE_ICON_NAME)
4255 {
4256 const gchar *icon_name;
4257 GtkIconSize icon_size;
4258
4259 gtk_image_get_icon_name (wimage, &icon_name, &icon_size);
4260 wmenuimage = gtk_image_new_from_icon_name (icon_name,
4261 GTK_ICON_SIZE_MENU);
4262 }
4263 else
4264 {
4265 fprintf (stderr, "internal error: store_type is %d\n", store_type);
4266 emacs_abort ();
4267 }
4268 }
4269 if (wmenuimage)
4270 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem), wmenuimage);
4271
4272 g_signal_connect (G_OBJECT (wmenuitem),
4273 "activate",
4274 G_CALLBACK (xg_tool_bar_proxy_callback),
4275 user_data);
4276
4277
4278 g_object_set_data (G_OBJECT (wmenuitem), XG_TOOL_BAR_PROXY_BUTTON,
4279 (gpointer) wbutton);
4280 gtk_tool_item_set_proxy_menu_item (toolitem, "Emacs toolbar item", wmenuitem);
4281 gtk_widget_set_sensitive (wmenuitem,
4282 gtk_widget_get_sensitive (GTK_WIDGET (wbutton)));
4283
4284 /* Use enter/leave notify to show help. We use the events
4285 rather than the GtkButton specific signals "enter" and
4286 "leave", so we can have only one callback. The event
4287 will tell us what kind of event it is. */
4288 g_signal_connect (G_OBJECT (wmenuitem),
4289 "enter-notify-event",
4290 G_CALLBACK (xg_tool_bar_proxy_help_callback),
4291 user_data);
4292 g_signal_connect (G_OBJECT (wmenuitem),
4293 "leave-notify-event",
4294 G_CALLBACK (xg_tool_bar_proxy_help_callback),
4295 user_data);
4296
4297 return TRUE;
4298 }
4299
4300 /* This callback is called when a tool bar is detached. We must set
4301 the height of the tool bar to zero when this happens so frame sizes
4302 are correctly calculated.
4303 WBOX is the handle box widget that enables detach/attach of the tool bar.
4304 W is the tool bar widget.
4305 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4306
4307 static void
4308 xg_tool_bar_detach_callback (GtkHandleBox *wbox,
4309 GtkWidget *w,
4310 gpointer client_data)
4311 {
4312 struct frame *f = client_data;
4313
4314 g_object_set (G_OBJECT (w), "show-arrow", !x_gtk_whole_detached_tool_bar,
4315 NULL);
4316
4317 if (f)
4318 {
4319 GtkRequisition req, req2;
4320
4321 gtk_widget_get_preferred_size (GTK_WIDGET (wbox), NULL, &req);
4322 gtk_widget_get_preferred_size (w, NULL, &req2);
4323 req.width -= req2.width;
4324 req.height -= req2.height;
4325 if (FRAME_TOOLBAR_TOP_HEIGHT (f) != 0)
4326 FRAME_TOOLBAR_TOP_HEIGHT (f) = req.height;
4327 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f) != 0)
4328 FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = req.height;
4329 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f) != 0)
4330 FRAME_TOOLBAR_RIGHT_WIDTH (f) = req.width;
4331 else if (FRAME_TOOLBAR_LEFT_WIDTH (f) != 0)
4332 FRAME_TOOLBAR_LEFT_WIDTH (f) = req.width;
4333 xg_height_or_width_changed (f);
4334 }
4335 }
4336
4337 /* This callback is called when a tool bar is reattached. We must set
4338 the height of the tool bar when this happens so frame sizes
4339 are correctly calculated.
4340 WBOX is the handle box widget that enables detach/attach of the tool bar.
4341 W is the tool bar widget.
4342 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4343
4344 static void
4345 xg_tool_bar_attach_callback (GtkHandleBox *wbox,
4346 GtkWidget *w,
4347 gpointer client_data)
4348 {
4349 struct frame *f = client_data;
4350 g_object_set (G_OBJECT (w), "show-arrow", TRUE, NULL);
4351
4352 if (f)
4353 {
4354 GtkRequisition req, req2;
4355
4356 gtk_widget_get_preferred_size (GTK_WIDGET (wbox), NULL, &req);
4357 gtk_widget_get_preferred_size (w, NULL, &req2);
4358 req.width += req2.width;
4359 req.height += req2.height;
4360 if (FRAME_TOOLBAR_TOP_HEIGHT (f) != 0)
4361 FRAME_TOOLBAR_TOP_HEIGHT (f) = req.height;
4362 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f) != 0)
4363 FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = req.height;
4364 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f) != 0)
4365 FRAME_TOOLBAR_RIGHT_WIDTH (f) = req.width;
4366 else if (FRAME_TOOLBAR_LEFT_WIDTH (f) != 0)
4367 FRAME_TOOLBAR_LEFT_WIDTH (f) = req.width;
4368 xg_height_or_width_changed (f);
4369 }
4370 }
4371
4372 /* This callback is called when the mouse enters or leaves a tool bar item.
4373 It is used for displaying and hiding the help text.
4374 W is the tool bar item, a button.
4375 EVENT is either an enter event or leave event.
4376 CLIENT_DATA is an integer that is the index of the button in the
4377 tool bar. 0 is the first button.
4378
4379 Returns FALSE to tell GTK to keep processing this event. */
4380
4381 static gboolean
4382 xg_tool_bar_help_callback (GtkWidget *w,
4383 GdkEventCrossing *event,
4384 gpointer client_data)
4385 {
4386 intptr_t idx = (intptr_t) client_data;
4387 struct frame *f = g_object_get_data (G_OBJECT (w), XG_FRAME_DATA);
4388 Lisp_Object help, frame;
4389
4390 if (! f || ! f->n_tool_bar_items || NILP (f->tool_bar_items))
4391 return FALSE;
4392
4393 if (event->type == GDK_ENTER_NOTIFY)
4394 {
4395 idx *= TOOL_BAR_ITEM_NSLOTS;
4396 help = AREF (f->tool_bar_items, idx + TOOL_BAR_ITEM_HELP);
4397
4398 if (NILP (help))
4399 help = AREF (f->tool_bar_items, idx + TOOL_BAR_ITEM_CAPTION);
4400 }
4401 else
4402 help = Qnil;
4403
4404 XSETFRAME (frame, f);
4405 kbd_buffer_store_help_event (frame, help);
4406
4407 return FALSE;
4408 }
4409
4410
4411 /* This callback is called when a tool bar item shall be redrawn.
4412 It modifies the expose event so that the GtkImage widget redraws the
4413 whole image. This to overcome a bug that makes GtkImage draw the image
4414 in the wrong place when it tries to redraw just a part of the image.
4415 W is the GtkImage to be redrawn.
4416 EVENT is the expose event for W.
4417 CLIENT_DATA is unused.
4418
4419 Returns FALSE to tell GTK to keep processing this event. */
4420
4421 #ifndef HAVE_GTK3
4422 static gboolean
4423 xg_tool_bar_item_expose_callback (GtkWidget *w,
4424 GdkEventExpose *event,
4425 gpointer client_data)
4426 {
4427 gint width, height;
4428
4429 gdk_drawable_get_size (event->window, &width, &height);
4430 event->area.x -= width > event->area.width ? width-event->area.width : 0;
4431 event->area.y -= height > event->area.height ? height-event->area.height : 0;
4432
4433 event->area.x = max (0, event->area.x);
4434 event->area.y = max (0, event->area.y);
4435
4436 event->area.width = max (width, event->area.width);
4437 event->area.height = max (height, event->area.height);
4438
4439 return FALSE;
4440 }
4441 #endif
4442
4443 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4444 #define toolbar_set_orientation(w, o) \
4445 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4446 #else
4447 #define toolbar_set_orientation(w, o) \
4448 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4449 #endif
4450
4451 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4452 #define TOOLBAR_TOP_WIDGET(x) ((x)->handlebox_widget)
4453 #else
4454 #define TOOLBAR_TOP_WIDGET(x) ((x)->toolbar_widget)
4455 #endif
4456
4457 /* Attach a tool bar to frame F. */
4458
4459 static void
4460 xg_pack_tool_bar (struct frame *f, Lisp_Object pos)
4461 {
4462 struct x_output *x = f->output_data.x;
4463 bool into_hbox = EQ (pos, Qleft) || EQ (pos, Qright);
4464 GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
4465
4466 toolbar_set_orientation (x->toolbar_widget,
4467 into_hbox
4468 ? GTK_ORIENTATION_VERTICAL
4469 : GTK_ORIENTATION_HORIZONTAL);
4470 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4471 if (!x->handlebox_widget)
4472 {
4473 top_widget = x->handlebox_widget = gtk_handle_box_new ();
4474 g_signal_connect (G_OBJECT (x->handlebox_widget), "child-detached",
4475 G_CALLBACK (xg_tool_bar_detach_callback), f);
4476 g_signal_connect (G_OBJECT (x->handlebox_widget), "child-attached",
4477 G_CALLBACK (xg_tool_bar_attach_callback), f);
4478 gtk_container_add (GTK_CONTAINER (x->handlebox_widget),
4479 x->toolbar_widget);
4480 }
4481 #endif
4482
4483 if (into_hbox)
4484 {
4485 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4486 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x->handlebox_widget),
4487 GTK_POS_TOP);
4488 #endif
4489 gtk_box_pack_start (GTK_BOX (x->hbox_widget), top_widget,
4490 FALSE, FALSE, 0);
4491
4492 if (EQ (pos, Qleft))
4493 gtk_box_reorder_child (GTK_BOX (x->hbox_widget),
4494 top_widget,
4495 0);
4496 x->toolbar_in_hbox = true;
4497 }
4498 else
4499 {
4500 bool vbox_pos = x->menubar_widget != 0;
4501 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4502 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x->handlebox_widget),
4503 GTK_POS_LEFT);
4504 #endif
4505 gtk_box_pack_start (GTK_BOX (x->vbox_widget), top_widget,
4506 FALSE, FALSE, 0);
4507
4508 if (EQ (pos, Qtop))
4509 gtk_box_reorder_child (GTK_BOX (x->vbox_widget),
4510 top_widget,
4511 vbox_pos);
4512 x->toolbar_in_hbox = false;
4513 }
4514 x->toolbar_is_packed = true;
4515 }
4516
4517 static bool xg_update_tool_bar_sizes (struct frame *f);
4518
4519 static void
4520 tb_size_cb (GtkWidget *widget,
4521 GdkRectangle *allocation,
4522 gpointer user_data)
4523 {
4524 /* When tool bar is created it has one preferred size. But when size is
4525 allocated between widgets, it may get another. So we must update
4526 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4527 struct frame *f = user_data;
4528 if (xg_update_tool_bar_sizes (f))
4529 xg_height_or_width_changed (f);
4530 }
4531
4532 /* Create a tool bar for frame F. */
4533
4534 static void
4535 xg_create_tool_bar (struct frame *f)
4536 {
4537 struct x_output *x = f->output_data.x;
4538 #if GTK_CHECK_VERSION (3, 3, 6)
4539 GtkStyleContext *gsty;
4540 #endif
4541 struct xg_frame_tb_info *tbinfo
4542 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
4543 TB_INFO_KEY);
4544 if (! tbinfo)
4545 {
4546 tbinfo = xmalloc (sizeof (*tbinfo));
4547 tbinfo->last_tool_bar = Qnil;
4548 tbinfo->style = Qnil;
4549 tbinfo->hmargin = tbinfo->vmargin = 0;
4550 tbinfo->dir = GTK_TEXT_DIR_NONE;
4551 tbinfo->n_last_items = 0;
4552 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
4553 TB_INFO_KEY,
4554 tbinfo);
4555 }
4556
4557 x->toolbar_widget = gtk_toolbar_new ();
4558
4559 gtk_widget_set_name (x->toolbar_widget, "emacs-toolbar");
4560
4561 gtk_toolbar_set_style (GTK_TOOLBAR (x->toolbar_widget), GTK_TOOLBAR_ICONS);
4562 toolbar_set_orientation (x->toolbar_widget, GTK_ORIENTATION_HORIZONTAL);
4563 g_signal_connect (x->toolbar_widget, "size-allocate",
4564 G_CALLBACK (tb_size_cb), f);
4565 #if GTK_CHECK_VERSION (3, 3, 6)
4566 gsty = gtk_widget_get_style_context (x->toolbar_widget);
4567 gtk_style_context_add_class (gsty, "primary-toolbar");
4568 #endif
4569 }
4570
4571
4572 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4573
4574 /* Find the right-to-left image named by RTL in the tool bar images for F.
4575 Returns IMAGE if RTL is not found. */
4576
4577 static Lisp_Object
4578 find_rtl_image (struct frame *f, Lisp_Object image, Lisp_Object rtl)
4579 {
4580 int i;
4581 Lisp_Object file, rtl_name;
4582 struct gcpro gcpro1, gcpro2;
4583 GCPRO2 (file, rtl_name);
4584
4585 rtl_name = Ffile_name_nondirectory (rtl);
4586
4587 for (i = 0; i < f->n_tool_bar_items; ++i)
4588 {
4589 Lisp_Object rtl_image = PROP (TOOL_BAR_ITEM_IMAGES);
4590 if (!NILP (file = file_for_image (rtl_image)))
4591 {
4592 file = call1 (intern ("file-name-sans-extension"),
4593 Ffile_name_nondirectory (file));
4594 if (! NILP (Fequal (file, rtl_name)))
4595 {
4596 image = rtl_image;
4597 break;
4598 }
4599 }
4600 }
4601
4602 return image;
4603 }
4604
4605 static GtkToolItem *
4606 xg_make_tool_item (struct frame *f,
4607 GtkWidget *wimage,
4608 GtkWidget **wbutton,
4609 const char *label,
4610 int i, bool horiz, bool text_image)
4611 {
4612 GtkToolItem *ti = gtk_tool_item_new ();
4613 GtkWidget *vb = gtk_box_new (horiz
4614 ? GTK_ORIENTATION_HORIZONTAL
4615 : GTK_ORIENTATION_VERTICAL,
4616 0);
4617 GtkWidget *wb = gtk_button_new ();
4618 /* The eventbox is here so we can have tooltips on disabled items. */
4619 GtkWidget *weventbox = gtk_event_box_new ();
4620 #if GTK_CHECK_VERSION (3, 3, 6)
4621 GtkCssProvider *css_prov = gtk_css_provider_new ();
4622 GtkStyleContext *gsty;
4623
4624 gtk_css_provider_load_from_data (css_prov,
4625 "GtkEventBox {"
4626 " background-color: transparent;"
4627 "}",
4628 -1, NULL);
4629
4630 gsty = gtk_widget_get_style_context (weventbox);
4631 gtk_style_context_add_provider (gsty,
4632 GTK_STYLE_PROVIDER (css_prov),
4633 GTK_STYLE_PROVIDER_PRIORITY_USER);
4634 g_object_unref (css_prov);
4635 #endif
4636
4637 gtk_box_set_homogeneous (GTK_BOX (vb), FALSE);
4638
4639 if (wimage && !text_image)
4640 gtk_box_pack_start (GTK_BOX (vb), wimage, TRUE, TRUE, 0);
4641 if (label)
4642 gtk_box_pack_start (GTK_BOX (vb), gtk_label_new (label), TRUE, TRUE, 0);
4643 if (wimage && text_image)
4644 gtk_box_pack_start (GTK_BOX (vb), wimage, TRUE, TRUE, 0);
4645
4646 gtk_button_set_focus_on_click (GTK_BUTTON (wb), FALSE);
4647 gtk_button_set_relief (GTK_BUTTON (wb), GTK_RELIEF_NONE);
4648 gtk_container_add (GTK_CONTAINER (wb), vb);
4649 gtk_container_add (GTK_CONTAINER (weventbox), wb);
4650 gtk_container_add (GTK_CONTAINER (ti), weventbox);
4651
4652 if (wimage || label)
4653 {
4654 intptr_t ii = i;
4655 gpointer gi = (gpointer) ii;
4656
4657 g_signal_connect (G_OBJECT (ti), "create-menu-proxy",
4658 G_CALLBACK (xg_tool_bar_menu_proxy),
4659 gi);
4660
4661 g_signal_connect (G_OBJECT (wb), "clicked",
4662 G_CALLBACK (xg_tool_bar_callback),
4663 gi);
4664
4665 g_object_set_data (G_OBJECT (weventbox), XG_FRAME_DATA, (gpointer)f);
4666
4667 #ifndef HAVE_GTK3
4668 /* Catch expose events to overcome an annoying redraw bug, see
4669 comment for xg_tool_bar_item_expose_callback. */
4670 g_signal_connect (G_OBJECT (ti),
4671 "expose-event",
4672 G_CALLBACK (xg_tool_bar_item_expose_callback),
4673 0);
4674 #endif
4675 gtk_tool_item_set_homogeneous (ti, FALSE);
4676
4677 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4678 no distinction based on modifiers in the activate callback,
4679 so we have to do it ourselves. */
4680 g_signal_connect (wb, "button-release-event",
4681 G_CALLBACK (xg_tool_bar_button_cb),
4682 NULL);
4683
4684 g_object_set_data (G_OBJECT (wb), XG_FRAME_DATA, (gpointer)f);
4685
4686 /* Use enter/leave notify to show help. We use the events
4687 rather than the GtkButton specific signals "enter" and
4688 "leave", so we can have only one callback. The event
4689 will tell us what kind of event it is. */
4690 g_signal_connect (G_OBJECT (weventbox),
4691 "enter-notify-event",
4692 G_CALLBACK (xg_tool_bar_help_callback),
4693 gi);
4694 g_signal_connect (G_OBJECT (weventbox),
4695 "leave-notify-event",
4696 G_CALLBACK (xg_tool_bar_help_callback),
4697 gi);
4698 }
4699
4700 if (wbutton) *wbutton = wb;
4701
4702 return ti;
4703 }
4704
4705 static bool
4706 is_box_type (GtkWidget *vb, bool is_horizontal)
4707 {
4708 #ifdef HAVE_GTK3
4709 bool ret = 0;
4710 if (GTK_IS_BOX (vb))
4711 {
4712 GtkOrientation ori = gtk_orientable_get_orientation (GTK_ORIENTABLE (vb));
4713 ret = (ori == GTK_ORIENTATION_HORIZONTAL && is_horizontal)
4714 || (ori == GTK_ORIENTATION_VERTICAL && ! is_horizontal);
4715 }
4716 return ret;
4717 #else
4718 return is_horizontal ? GTK_IS_VBOX (vb) : GTK_IS_HBOX (vb);
4719 #endif
4720 }
4721
4722
4723 static bool
4724 xg_tool_item_stale_p (GtkWidget *wbutton, const char *stock_name,
4725 const char *icon_name, const struct image *img,
4726 const char *label, bool horiz)
4727 {
4728 gpointer old;
4729 GtkWidget *wimage;
4730 GtkWidget *vb = XG_BIN_CHILD (wbutton);
4731 GtkWidget *wlbl = xg_get_tool_bar_widgets (vb, &wimage);
4732
4733 /* Check if the tool icon matches. */
4734 if (stock_name && wimage)
4735 {
4736 old = g_object_get_data (G_OBJECT (wimage),
4737 XG_TOOL_BAR_STOCK_NAME);
4738 if (!old || strcmp (old, stock_name))
4739 return 1;
4740 }
4741 else if (icon_name && wimage)
4742 {
4743 old = g_object_get_data (G_OBJECT (wimage),
4744 XG_TOOL_BAR_ICON_NAME);
4745 if (!old || strcmp (old, icon_name))
4746 return 1;
4747 }
4748 else if (wimage)
4749 {
4750 gpointer gold_img = g_object_get_data (G_OBJECT (wimage),
4751 XG_TOOL_BAR_IMAGE_DATA);
4752 Pixmap old_img = (Pixmap) gold_img;
4753 if (old_img != img->pixmap)
4754 return 1;
4755 }
4756
4757 /* Check button configuration and label. */
4758 if (is_box_type (vb, horiz)
4759 || (label ? (wlbl == NULL) : (wlbl != NULL)))
4760 return 1;
4761
4762 /* Ensure label is correct. */
4763 if (label && wlbl)
4764 gtk_label_set_text (GTK_LABEL (wlbl), label);
4765 return 0;
4766 }
4767
4768 static bool
4769 xg_update_tool_bar_sizes (struct frame *f)
4770 {
4771 struct x_output *x = f->output_data.x;
4772 GtkRequisition req;
4773 int nl = 0, nr = 0, nt = 0, nb = 0;
4774 GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
4775
4776 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget), NULL, &req);
4777 if (x->toolbar_in_hbox)
4778 {
4779 int pos;
4780 gtk_container_child_get (GTK_CONTAINER (x->hbox_widget),
4781 top_widget,
4782 "position", &pos, NULL);
4783 if (pos == 0) nl = req.width;
4784 else nr = req.width;
4785 }
4786 else
4787 {
4788 int pos;
4789 gtk_container_child_get (GTK_CONTAINER (x->vbox_widget),
4790 top_widget,
4791 "position", &pos, NULL);
4792 if (pos == 0 || (pos == 1 && x->menubar_widget)) nt = req.height;
4793 else nb = req.height;
4794 }
4795
4796 if (nl != FRAME_TOOLBAR_LEFT_WIDTH (f)
4797 || nr != FRAME_TOOLBAR_RIGHT_WIDTH (f)
4798 || nt != FRAME_TOOLBAR_TOP_HEIGHT (f)
4799 || nb != FRAME_TOOLBAR_BOTTOM_HEIGHT (f))
4800 {
4801 FRAME_TOOLBAR_RIGHT_WIDTH (f) = FRAME_TOOLBAR_LEFT_WIDTH (f)
4802 = FRAME_TOOLBAR_TOP_HEIGHT (f) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = 0;
4803 FRAME_TOOLBAR_LEFT_WIDTH (f) = nl;
4804 FRAME_TOOLBAR_RIGHT_WIDTH (f) = nr;
4805 FRAME_TOOLBAR_TOP_HEIGHT (f) = nt;
4806 FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = nb;
4807 return 1;
4808 }
4809
4810 return 0;
4811 }
4812
4813
4814 /* Update the tool bar for frame F. Add new buttons and remove old. */
4815
4816 void
4817 update_frame_tool_bar (struct frame *f)
4818 {
4819 int i, j;
4820 struct x_output *x = f->output_data.x;
4821 int hmargin = 0, vmargin = 0;
4822 GtkToolbar *wtoolbar;
4823 GtkToolItem *ti;
4824 GtkTextDirection dir;
4825 Lisp_Object style;
4826 bool text_image, horiz;
4827 struct xg_frame_tb_info *tbinfo;
4828
4829 if (! FRAME_GTK_WIDGET (f))
4830 return;
4831
4832 block_input ();
4833
4834 if (RANGED_INTEGERP (1, Vtool_bar_button_margin, INT_MAX))
4835 {
4836 hmargin = XFASTINT (Vtool_bar_button_margin);
4837 vmargin = XFASTINT (Vtool_bar_button_margin);
4838 }
4839 else if (CONSP (Vtool_bar_button_margin))
4840 {
4841 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin), INT_MAX))
4842 hmargin = XFASTINT (XCAR (Vtool_bar_button_margin));
4843
4844 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin), INT_MAX))
4845 vmargin = XFASTINT (XCDR (Vtool_bar_button_margin));
4846 }
4847
4848 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4849 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4850 i.e. zero. This means that margins less than
4851 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4852 hmargin = max (0, hmargin - DEFAULT_TOOL_BAR_BUTTON_MARGIN);
4853 vmargin = max (0, vmargin - DEFAULT_TOOL_BAR_BUTTON_MARGIN);
4854
4855 if (! x->toolbar_widget)
4856 xg_create_tool_bar (f);
4857
4858 wtoolbar = GTK_TOOLBAR (x->toolbar_widget);
4859 dir = gtk_widget_get_direction (GTK_WIDGET (wtoolbar));
4860
4861 style = Ftool_bar_get_system_style ();
4862
4863 /* Are we up to date? */
4864 tbinfo = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
4865 TB_INFO_KEY);
4866
4867 if (! NILP (tbinfo->last_tool_bar) && ! NILP (f->tool_bar_items)
4868 && tbinfo->n_last_items == f->n_tool_bar_items
4869 && tbinfo->hmargin == hmargin && tbinfo->vmargin == vmargin
4870 && tbinfo->dir == dir
4871 && ! NILP (Fequal (tbinfo->style, style))
4872 && ! NILP (Fequal (tbinfo->last_tool_bar, f->tool_bar_items)))
4873 {
4874 unblock_input ();
4875 return;
4876 }
4877
4878 tbinfo->last_tool_bar = f->tool_bar_items;
4879 tbinfo->n_last_items = f->n_tool_bar_items;
4880 tbinfo->style = style;
4881 tbinfo->hmargin = hmargin;
4882 tbinfo->vmargin = vmargin;
4883 tbinfo->dir = dir;
4884
4885 text_image = EQ (style, Qtext_image_horiz);
4886 horiz = EQ (style, Qboth_horiz) || text_image;
4887
4888 for (i = j = 0; i < f->n_tool_bar_items; ++i)
4889 {
4890 bool enabled_p = !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P));
4891 bool selected_p = !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P));
4892 int idx;
4893 ptrdiff_t img_id;
4894 int icon_size = 0;
4895 struct image *img = NULL;
4896 Lisp_Object image;
4897 Lisp_Object stock = Qnil;
4898 GtkStockItem stock_item;
4899 char *stock_name = NULL;
4900 char *icon_name = NULL;
4901 Lisp_Object rtl;
4902 GtkWidget *wbutton = NULL;
4903 Lisp_Object specified_file;
4904 bool vert_only = ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY));
4905 const char *label
4906 = (EQ (style, Qimage) || (vert_only && horiz)) ? NULL
4907 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL))
4908 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL))
4909 : "";
4910
4911 ti = gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar), j);
4912
4913 /* If this is a separator, use a gtk separator item. */
4914 if (EQ (PROP (TOOL_BAR_ITEM_TYPE), Qt))
4915 {
4916 if (ti == NULL || !GTK_IS_SEPARATOR_TOOL_ITEM (ti))
4917 {
4918 if (ti)
4919 gtk_container_remove (GTK_CONTAINER (wtoolbar),
4920 GTK_WIDGET (ti));
4921 ti = gtk_separator_tool_item_new ();
4922 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar), ti, j);
4923 }
4924 j++;
4925 continue;
4926 }
4927
4928 /* Otherwise, the tool-bar item is an ordinary button. */
4929
4930 if (ti && GTK_IS_SEPARATOR_TOOL_ITEM (ti))
4931 {
4932 gtk_container_remove (GTK_CONTAINER (wtoolbar), GTK_WIDGET (ti));
4933 ti = NULL;
4934 }
4935
4936 if (ti) wbutton = XG_BIN_CHILD (XG_BIN_CHILD (ti));
4937
4938 /* Ignore invalid image specifications. */
4939 image = PROP (TOOL_BAR_ITEM_IMAGES);
4940 if (!valid_image_p (image))
4941 {
4942 if (ti)
4943 gtk_container_remove (GTK_CONTAINER (wtoolbar),
4944 GTK_WIDGET (ti));
4945 continue;
4946 }
4947
4948 specified_file = file_for_image (image);
4949 if (!NILP (specified_file) && !NILP (Ffboundp (Qx_gtk_map_stock)))
4950 stock = call1 (Qx_gtk_map_stock, specified_file);
4951
4952 if (STRINGP (stock))
4953 {
4954 stock_name = SSDATA (stock);
4955 if (stock_name[0] == 'n' && stock_name[1] == ':')
4956 {
4957 GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (wtoolbar));
4958 GtkIconTheme *icon_theme = gtk_icon_theme_get_for_screen (screen);
4959
4960 icon_name = stock_name + 2;
4961 stock_name = NULL;
4962 stock = Qnil;
4963
4964 if (! gtk_icon_theme_has_icon (icon_theme, icon_name))
4965 icon_name = NULL;
4966 else
4967 icon_size = gtk_toolbar_get_icon_size (wtoolbar);
4968 }
4969 else if (gtk_stock_lookup (SSDATA (stock), &stock_item))
4970 icon_size = gtk_toolbar_get_icon_size (wtoolbar);
4971 else
4972 {
4973 stock = Qnil;
4974 stock_name = NULL;
4975 }
4976 }
4977
4978 if (stock_name == NULL && icon_name == NULL)
4979 {
4980 /* No stock image, or stock item not known. Try regular
4981 image. If image is a vector, choose it according to the
4982 button state. */
4983 if (dir == GTK_TEXT_DIR_RTL
4984 && !NILP (rtl = PROP (TOOL_BAR_ITEM_RTL_IMAGE))
4985 && STRINGP (rtl))
4986 image = find_rtl_image (f, image, rtl);
4987
4988 if (VECTORP (image))
4989 {
4990 if (enabled_p)
4991 idx = (selected_p
4992 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4993 : TOOL_BAR_IMAGE_ENABLED_DESELECTED);
4994 else
4995 idx = (selected_p
4996 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4997 : TOOL_BAR_IMAGE_DISABLED_DESELECTED);
4998
4999 eassert (ASIZE (image) >= idx);
5000 image = AREF (image, idx);
5001 }
5002 else
5003 idx = -1;
5004
5005 img_id = lookup_image (f, image);
5006 img = IMAGE_FROM_ID (f, img_id);
5007 prepare_image_for_display (f, img);
5008
5009 if (img->load_failed_p || img->pixmap == None)
5010 {
5011 if (ti)
5012 gtk_container_remove (GTK_CONTAINER (wtoolbar),
5013 GTK_WIDGET (ti));
5014 continue;
5015 }
5016 }
5017
5018 /* If there is an existing widget, check if it's stale; if so,
5019 remove it and make a new tool item from scratch. */
5020 if (ti && xg_tool_item_stale_p (wbutton, stock_name, icon_name,
5021 img, label, horiz))
5022 {
5023 gtk_container_remove (GTK_CONTAINER (wtoolbar),
5024 GTK_WIDGET (ti));
5025 ti = NULL;
5026 }
5027
5028 if (ti == NULL)
5029 {
5030 GtkWidget *w;
5031
5032 /* Save the image so we can see if an update is needed the
5033 next time we call xg_tool_item_match_p. */
5034 if (EQ (style, Qtext))
5035 w = NULL;
5036 else if (stock_name)
5037 {
5038 w = gtk_image_new_from_stock (stock_name, icon_size);
5039 g_object_set_data_full (G_OBJECT (w), XG_TOOL_BAR_STOCK_NAME,
5040 (gpointer) xstrdup (stock_name),
5041 (GDestroyNotify) xfree);
5042 }
5043 else if (icon_name)
5044 {
5045 w = gtk_image_new_from_icon_name (icon_name, icon_size);
5046 g_object_set_data_full (G_OBJECT (w), XG_TOOL_BAR_ICON_NAME,
5047 (gpointer) xstrdup (icon_name),
5048 (GDestroyNotify) xfree);
5049 }
5050 else
5051 {
5052 w = xg_get_image_for_pixmap (f, img, x->widget, NULL);
5053 g_object_set_data (G_OBJECT (w), XG_TOOL_BAR_IMAGE_DATA,
5054 (gpointer)img->pixmap);
5055 }
5056
5057 if (w) gtk_misc_set_padding (GTK_MISC (w), hmargin, vmargin);
5058 ti = xg_make_tool_item (f, w, &wbutton, label, i, horiz, text_image);
5059 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar), ti, j);
5060 }
5061
5062 #undef PROP
5063
5064 gtk_widget_set_sensitive (wbutton, enabled_p);
5065 j++;
5066 }
5067
5068 /* Remove buttons not longer needed. */
5069 do
5070 {
5071 ti = gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar), j);
5072 if (ti)
5073 gtk_container_remove (GTK_CONTAINER (wtoolbar), GTK_WIDGET (ti));
5074 } while (ti != NULL);
5075
5076 if (f->n_tool_bar_items != 0)
5077 {
5078 if (! x->toolbar_is_packed)
5079 xg_pack_tool_bar (f, FRAME_TOOL_BAR_POSITION (f));
5080 gtk_widget_show_all (TOOLBAR_TOP_WIDGET (x));
5081 if (xg_update_tool_bar_sizes (f))
5082 xg_height_or_width_changed (f);
5083 }
5084
5085 unblock_input ();
5086 }
5087
5088 /* Deallocate all resources for the tool bar on frame F.
5089 Remove the tool bar. */
5090
5091 void
5092 free_frame_tool_bar (struct frame *f)
5093 {
5094 struct x_output *x = f->output_data.x;
5095
5096 if (x->toolbar_widget)
5097 {
5098 struct xg_frame_tb_info *tbinfo;
5099 GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
5100
5101 block_input ();
5102 /* We may have created the toolbar_widget in xg_create_tool_bar, but
5103 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
5104 if (x->toolbar_is_packed)
5105 {
5106 if (x->toolbar_in_hbox)
5107 gtk_container_remove (GTK_CONTAINER (x->hbox_widget),
5108 top_widget);
5109 else
5110 gtk_container_remove (GTK_CONTAINER (x->vbox_widget),
5111 top_widget);
5112 }
5113 else
5114 gtk_widget_destroy (x->toolbar_widget);
5115
5116 x->toolbar_widget = 0;
5117 TOOLBAR_TOP_WIDGET (x) = 0;
5118 x->toolbar_is_packed = false;
5119 FRAME_TOOLBAR_TOP_HEIGHT (f) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = 0;
5120 FRAME_TOOLBAR_LEFT_WIDTH (f) = FRAME_TOOLBAR_RIGHT_WIDTH (f) = 0;
5121
5122 tbinfo = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
5123 TB_INFO_KEY);
5124 if (tbinfo)
5125 {
5126 xfree (tbinfo);
5127 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f)),
5128 TB_INFO_KEY,
5129 NULL);
5130 }
5131
5132 xg_height_or_width_changed (f);
5133
5134 unblock_input ();
5135 }
5136 }
5137
5138 void
5139 xg_change_toolbar_position (struct frame *f, Lisp_Object pos)
5140 {
5141 struct x_output *x = f->output_data.x;
5142 GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
5143
5144 if (! x->toolbar_widget || ! top_widget)
5145 return;
5146
5147 block_input ();
5148 g_object_ref (top_widget);
5149 if (x->toolbar_is_packed)
5150 {
5151 if (x->toolbar_in_hbox)
5152 gtk_container_remove (GTK_CONTAINER (x->hbox_widget),
5153 top_widget);
5154 else
5155 gtk_container_remove (GTK_CONTAINER (x->vbox_widget),
5156 top_widget);
5157 }
5158
5159 xg_pack_tool_bar (f, pos);
5160 g_object_unref (top_widget);
5161 if (xg_update_tool_bar_sizes (f))
5162 xg_height_or_width_changed (f);
5163
5164 unblock_input ();
5165 }
5166
5167
5168 \f
5169 /***********************************************************************
5170 Initializing
5171 ***********************************************************************/
5172 void
5173 xg_initialize (void)
5174 {
5175 GtkBindingSet *binding_set;
5176 GtkSettings *settings;
5177
5178 #if HAVE_XFT
5179 /* Work around a bug with corrupted data if libXft gets unloaded. This way
5180 we keep it permanently linked in. */
5181 XftInit (0);
5182 #endif
5183
5184 gdpy_def = NULL;
5185 xg_ignore_gtk_scrollbar = 0;
5186 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
5187 xg_detached_menus = 0;
5188 #endif
5189 xg_menu_cb_list.prev = xg_menu_cb_list.next =
5190 xg_menu_item_cb_list.prev = xg_menu_item_cb_list.next = 0;
5191
5192 id_to_widget.max_size = id_to_widget.used = 0;
5193 id_to_widget.widgets = 0;
5194
5195 settings = gtk_settings_get_for_screen (gdk_display_get_default_screen
5196 (gdk_display_get_default ()));
5197 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5198 bindings. It doesn't seem to be any way to remove properties,
5199 so we set it to "" which in means "no key". */
5200 gtk_settings_set_string_property (settings,
5201 "gtk-menu-bar-accel",
5202 "",
5203 EMACS_CLASS);
5204
5205 /* Make GTK text input widgets use Emacs style keybindings. This is
5206 Emacs after all. */
5207 gtk_settings_set_string_property (settings,
5208 "gtk-key-theme-name",
5209 "Emacs",
5210 EMACS_CLASS);
5211
5212 /* Make dialogs close on C-g. Since file dialog inherits from
5213 dialog, this works for them also. */
5214 binding_set = gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG));
5215 gtk_binding_entry_add_signal (binding_set, GDK_KEY_g, GDK_CONTROL_MASK,
5216 "close", 0);
5217
5218 /* Make menus close on C-g. */
5219 binding_set = gtk_binding_set_by_class (g_type_class_ref
5220 (GTK_TYPE_MENU_SHELL));
5221 gtk_binding_entry_add_signal (binding_set, GDK_KEY_g, GDK_CONTROL_MASK,
5222 "cancel", 0);
5223 update_theme_scrollbar_width ();
5224 update_theme_scrollbar_height ();
5225
5226 #ifdef HAVE_FREETYPE
5227 x_last_font_name = NULL;
5228 #endif
5229 }
5230
5231 #endif /* USE_GTK */