1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2014 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
30 #include "blockinput.h"
31 #include "syssignal.h"
35 #include "termhooks.h"
41 #include <gdk/gdkkeysyms.h>
42 #include "xsettings.h"
45 #include <X11/Xft/Xft.h>
50 #include "emacsgtkfixed.h"
53 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
54 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
56 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
57 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
59 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
60 #define gtk_widget_set_has_window(w, b) \
61 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
63 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
64 #define gtk_dialog_get_action_area(w) ((w)->action_area)
65 #define gtk_dialog_get_content_area(w) ((w)->vbox)
67 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
68 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
70 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
71 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
72 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
73 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
74 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
76 #if GTK_CHECK_VERSION (2, 12, 0)
77 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
79 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
83 #if GTK_CHECK_VERSION (3, 2, 0)
84 #define USE_NEW_GTK_FONT_CHOOSER 1
86 #define USE_NEW_GTK_FONT_CHOOSER 0
87 #define gtk_font_chooser_dialog_new(x, y) \
88 gtk_font_selection_dialog_new (x)
89 #undef GTK_FONT_CHOOSER
90 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
91 #define gtk_font_chooser_set_font(x, y) \
92 gtk_font_selection_dialog_set_font_name (x, y)
94 #endif /* HAVE_FREETYPE */
97 #ifdef USE_GTK_TOOLTIP
98 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
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)))
111 #define GDK_KEY_g GDK_g
113 #endif /* HAVE_GTK3 */
115 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
117 static void update_theme_scrollbar_width (void);
118 static void update_theme_scrollbar_height (void);
120 #define TB_INFO_KEY "xg_frame_tb_info"
121 struct xg_frame_tb_info
123 Lisp_Object last_tool_bar
;
126 int hmargin
, vmargin
;
127 GtkTextDirection dir
;
131 /***********************************************************************
132 Display handling functions
133 ***********************************************************************/
135 /* Keep track of the default display, or NULL if there is none. Emacs
136 may close all its displays. */
138 static GdkDisplay
*gdpy_def
;
140 /* When the GTK widget W is to be created on a display for F that
141 is not the default display, set the display for W.
142 W can be a GtkMenu or a GtkWindow widget. */
145 xg_set_screen (GtkWidget
*w
, struct frame
*f
)
147 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
149 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
150 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
153 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
155 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
160 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
161 *DPY is set to NULL if the display can't be opened.
163 Returns non-zero if display could be opened, zero if display could not
164 be opened, and less than zero if the GTK version doesn't support
165 multiple displays. */
168 xg_display_open (char *display_name
, Display
**dpy
)
172 gdpy
= gdk_display_open (display_name
);
173 if (!gdpy_def
&& gdpy
)
176 gdk_display_manager_set_default_display (gdk_display_manager_get (),
180 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
184 /* Close display DPY. */
187 xg_display_close (Display
*dpy
)
189 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
191 /* If this is the default display, try to change it before closing.
192 If there is no other display to use, gdpy_def is set to NULL, and
193 the next call to xg_display_open resets the default display. */
194 if (gdk_display_get_default () == gdpy
)
196 struct x_display_info
*dpyinfo
;
197 GdkDisplay
*gdpy_new
= NULL
;
199 /* Find another display. */
200 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
201 if (dpyinfo
->display
!= dpy
)
203 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
204 gdk_display_manager_set_default_display (gdk_display_manager_get (),
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
));
217 /* This seems to be fixed in GTK 2.10. */
218 gdk_display_close (gdpy
);
223 /***********************************************************************
225 ***********************************************************************/
227 /* Create and return the cursor to be used for popup menus and
228 scroll bars on display DPY. */
231 xg_create_default_cursor (Display
*dpy
)
233 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
234 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
238 xg_get_pixbuf_from_pixmap (struct frame
*f
, Pixmap pix
)
243 unsigned int width
, height
, uunused
;
246 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
247 &width
, &height
, &uunused
, &uunused
);
249 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
253 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
266 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
269 xg_get_pixbuf_from_pix_and_mask (struct frame
*f
,
274 GdkPixbuf
*icon_buf
, *tmp_buf
;
276 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
277 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
278 g_object_unref (G_OBJECT (tmp_buf
));
280 width
= gdk_pixbuf_get_width (icon_buf
);
281 height
= gdk_pixbuf_get_height (icon_buf
);
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
);
292 for (y
= 0; y
< height
; ++y
)
294 guchar
*iconptr
, *maskptr
;
297 iconptr
= pixels
+ y
* rowstride
;
298 maskptr
= mask_pixels
+ y
* mask_rowstride
;
300 for (x
= 0; x
< width
; ++x
)
302 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
303 just R is sufficient. */
305 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
307 iconptr
+= rowstride
/width
;
308 maskptr
+= mask_rowstride
/width
;
312 g_object_unref (G_OBJECT (mask_buf
));
319 file_for_image (Lisp_Object image
)
321 Lisp_Object specified_file
= Qnil
;
324 for (tail
= XCDR (image
);
325 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
326 tail
= XCDR (XCDR (tail
)))
327 if (EQ (XCAR (tail
), QCfile
))
328 specified_file
= XCAR (XCDR (tail
));
330 return specified_file
;
333 /* For the image defined in IMG, make and return a GtkImage. For displays with
334 8 planes or less we must make a GdkPixbuf and apply the mask manually.
335 Otherwise the highlighting and dimming the tool bar code in GTK does
336 will look bad. For display with more than 8 planes we just use the
337 pixmap and mask directly. For monochrome displays, GTK doesn't seem
338 able to use external pixmaps, it looks bad whatever we do.
339 The image is defined on the display where frame F is.
340 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
341 If OLD_WIDGET is NULL, a new widget is constructed and returned.
342 If OLD_WIDGET is not NULL, that widget is modified. */
345 xg_get_image_for_pixmap (struct frame
*f
,
348 GtkImage
*old_widget
)
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
);
358 /* We already loaded the image once before calling this
359 function, so this only fails if the image file has been removed.
360 In that case, use the pixmap already loaded. */
362 if (STRINGP (specified_file
)
363 && STRINGP (file
= x_find_image_file (specified_file
)))
366 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
368 gtk_image_set_from_file (old_widget
, SSDATA (file
));
370 return GTK_WIDGET (old_widget
);
373 /* No file, do the image handling ourselves. This will look very bad
374 on a monochrome display, and sometimes bad on all displays with
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
);
391 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
393 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
395 g_object_unref (G_OBJECT (icon_buf
));
398 return GTK_WIDGET (old_widget
);
402 /* Set CURSOR on W and all widgets W contain. We must do like this
403 for scroll bars and menu because they create widgets internally,
404 and it is those widgets that are visible. */
407 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
409 GdkWindow
*window
= gtk_widget_get_window (w
);
410 GList
*children
= gdk_window_peek_children (window
);
412 gdk_window_set_cursor (window
, cursor
);
414 /* The scroll bar widget has more than one GDK window (had to look at
415 the source to figure this out), and there is no way to set cursor
416 on widgets in GTK. So we must set the cursor for all GDK windows.
419 for ( ; children
; children
= g_list_next (children
))
420 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
423 /* Insert NODE into linked LIST. */
426 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
428 xg_list_node
*list_start
= list
->next
;
430 if (list_start
) list_start
->prev
= node
;
431 node
->next
= list_start
;
436 /* Remove NODE from linked LIST. */
439 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
441 xg_list_node
*list_start
= list
->next
;
442 if (node
== list_start
)
444 list
->next
= node
->next
;
445 if (list
->next
) list
->next
->prev
= 0;
449 node
->prev
->next
= node
->next
;
450 if (node
->next
) node
->next
->prev
= node
->prev
;
454 /* Allocate and return a utf8 version of STR. If STR is already
455 utf8 or NULL, just return a copy of STR.
456 A new string is allocated and the caller must free the result
460 get_utf8_string (const char *str
)
464 if (!str
) return NULL
;
466 /* If not UTF-8, try current locale. */
467 if (!g_utf8_validate (str
, -1, NULL
))
468 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
470 return g_strdup (str
);
474 /* Probably some control characters in str. Escape them. */
476 ptrdiff_t nr_bad
= 0;
479 unsigned char *p
= (unsigned char *)str
;
483 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
484 &bytes_written
, &err
))
485 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
488 p
+= bytes_written
+1;
501 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
502 memory_full (SIZE_MAX
);
503 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
504 p
= (unsigned char *)str
;
506 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
507 &bytes_written
, &err
))
508 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
510 memcpy (up
, p
, bytes_written
);
511 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
512 up
+= bytes_written
+4;
513 p
+= bytes_written
+1;
520 strcat (utf8_str
, cp
);
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. */
537 xg_check_special_colors (struct frame
*f
,
538 const char *color_name
,
542 bool get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
543 bool get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
545 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
551 GtkStyleContext
*gsty
552 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
554 char buf
[sizeof "rgb://rrrr/gggg/bbbb"];
555 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
557 gtk_style_context_get_color (gsty
, state
, &col
);
559 gtk_style_context_get_background_color (gsty
, state
, &col
);
561 sprintf (buf
, "rgb:%04x/%04x/%04x",
562 (int)(col
.red
* 65535),
563 (int)(col
.green
* 65535),
564 (int)(col
.blue
* 65535));
565 success_p
= (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
569 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
570 GdkColor
*grgb
= get_bg
571 ? &gsty
->bg
[GTK_STATE_SELECTED
]
572 : &gsty
->fg
[GTK_STATE_SELECTED
];
574 color
->red
= grgb
->red
;
575 color
->green
= grgb
->green
;
576 color
->blue
= grgb
->blue
;
577 color
->pixel
= grgb
->pixel
;
588 /***********************************************************************
590 ***********************************************************************/
591 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
592 We use that to pop down the tooltip. This happens if Gtk+ for some
593 reason wants to change or hide the tooltip. */
595 #ifdef USE_GTK_TOOLTIP
598 hierarchy_ch_cb (GtkWidget
*widget
,
599 GtkWidget
*previous_toplevel
,
602 struct frame
*f
= user_data
;
603 struct x_output
*x
= f
->output_data
.x
;
604 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
606 if (! top
|| ! GTK_IS_WINDOW (top
))
607 gtk_widget_hide (previous_toplevel
);
610 /* Callback called when Gtk+ thinks a tooltip should be displayed.
611 We use it to get the tooltip window and the tooltip widget so
612 we can manipulate the ourselves.
614 Return FALSE ensures that the tooltip is not shown. */
617 qttip_cb (GtkWidget
*widget
,
620 gboolean keyboard_mode
,
624 struct frame
*f
= user_data
;
625 struct x_output
*x
= f
->output_data
.x
;
626 if (x
->ttip_widget
== NULL
)
631 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
632 x
->ttip_widget
= tooltip
;
633 g_object_ref (G_OBJECT (tooltip
));
634 x
->ttip_lbl
= gtk_label_new ("");
635 g_object_ref (G_OBJECT (x
->ttip_lbl
));
636 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
637 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
639 /* Change stupid Gtk+ default line wrapping. */
640 p
= gtk_widget_get_parent (x
->ttip_lbl
);
641 list
= gtk_container_get_children (GTK_CONTAINER (p
));
642 for (iter
= list
; iter
; iter
= g_list_next (iter
))
644 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
645 if (GTK_IS_LABEL (w
))
646 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
650 /* ATK needs an empty title for some reason. */
651 gtk_window_set_title (x
->ttip_window
, "");
652 /* Realize so we can safely get screen later on. */
653 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
654 gtk_widget_realize (x
->ttip_lbl
);
656 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
657 G_CALLBACK (hierarchy_ch_cb
), f
);
662 #endif /* USE_GTK_TOOLTIP */
664 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
665 Return true if a system tooltip is available. */
668 xg_prepare_tooltip (struct frame
*f
,
673 #ifndef USE_GTK_TOOLTIP
676 struct x_output
*x
= f
->output_data
.x
;
680 GtkSettings
*settings
;
681 gboolean tt_enabled
= TRUE
;
683 Lisp_Object encoded_string
;
685 if (!x
->ttip_lbl
) return 0;
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
);
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",
702 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
703 g_object_set_data (G_OBJECT
704 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
705 "gdk-display-current-tooltip", NULL
);
707 /* Put our dummy widget in so we can get callbacks for unrealize and
708 hierarchy-changed. */
709 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
710 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
711 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
712 if (width
) *width
= req
.width
;
713 if (height
) *height
= req
.height
;
718 #endif /* USE_GTK_TOOLTIP */
721 /* Show the tooltip at ROOT_X and ROOT_Y.
722 xg_prepare_tooltip must have been called before this function. */
725 xg_show_tooltip (struct frame
*f
, int root_x
, int root_y
)
727 #ifdef USE_GTK_TOOLTIP
728 struct x_output
*x
= f
->output_data
.x
;
732 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
733 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
739 /* Hide tooltip if shown. Do nothing if not shown.
740 Return true if tip was hidden, false if not (i.e. not using
744 xg_hide_tooltip (struct frame
*f
)
747 #ifdef USE_GTK_TOOLTIP
748 if (f
->output_data
.x
->ttip_window
)
750 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
752 gtk_widget_hide (GTK_WIDGET (win
));
754 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
756 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
757 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
758 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
759 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
770 /***********************************************************************
771 General functions for creating widgets, resizing, events, e.t.c.
772 ***********************************************************************/
775 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
776 const gchar
*msg
, gpointer user_data
)
778 if (!strstr (msg
, "visible children"))
779 fprintf (stderr
, "XX %s-WARNING **: %s\n", log_domain
, msg
);
782 /* Make a geometry string and pass that to GTK. It seems this is the
783 only way to get geometry position right if the user explicitly
784 asked for a position when starting Emacs.
785 F is the frame we shall set geometry for. */
788 xg_set_geometry (struct frame
*f
)
790 if (f
->size_hint_flags
& (USPosition
| PPosition
))
792 int left
= f
->left_pos
;
793 int xneg
= f
->size_hint_flags
& XNegative
;
794 int top
= f
->top_pos
;
795 int yneg
= f
->size_hint_flags
& YNegative
;
796 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
804 sprintf (geom_str
, "=%dx%d%c%d%c%d",
805 FRAME_PIXEL_WIDTH (f
),
806 FRAME_PIXEL_HEIGHT (f
),
807 (xneg
? '-' : '+'), left
,
808 (yneg
? '-' : '+'), top
);
810 /* Silence warning about visible children. */
811 id
= g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
812 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
814 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
816 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
818 g_log_remove_handler ("Gtk", id
);
822 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
823 and use a GtkFixed widget, this doesn't happen automatically. */
826 xg_clear_under_internal_border (struct frame
*f
)
828 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
830 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
832 gtk_widget_queue_draw (wfixed
);
833 gdk_window_process_all_updates ();
835 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0, 0,
836 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
838 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0, 0,
839 FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
841 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0,
842 FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
843 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
845 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
846 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
847 0, FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
851 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
852 and a Gtk+ menu bar, we get resize events for the edit part of the
853 frame only. We let Gtk+ deal with the Gtk+ parts.
854 F is the frame to resize.
855 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
858 xg_frame_resized (struct frame
*f
, int pixelwidth
, int pixelheight
)
862 if (pixelwidth
== -1 && pixelheight
== -1)
864 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
865 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
867 &pixelwidth
, &pixelheight
);
872 width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
);
873 height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
);
875 if (width
!= FRAME_TEXT_WIDTH (f
)
876 || height
!= FRAME_TEXT_HEIGHT (f
)
877 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
878 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
880 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
881 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
883 xg_clear_under_internal_border (f
);
884 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
885 SET_FRAME_GARBAGED (f
);
886 cancel_mouse_face (f
);
888 do_pending_window_change (0);
892 /* Resize the outer window of frame F after changing the height.
893 COLUMNS/ROWS is the size the edit area shall have after the resize. */
896 xg_frame_set_char_size (struct frame
*f
, int width
, int height
)
898 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
899 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
901 if (FRAME_PIXEL_HEIGHT (f
) == 0)
904 /* Do this before resize, as we don't know yet if we will be resized. */
905 xg_clear_under_internal_border (f
);
907 /* Must resize our top level widget. Font size may have changed,
908 but not rows/cols. */
909 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
910 pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
),
911 pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
)
912 + FRAME_MENUBAR_HEIGHT (f
));
913 x_wm_set_size_hint (f
, 0, 0);
915 SET_FRAME_GARBAGED (f
);
916 cancel_mouse_face (f
);
918 /* We can not call change_frame_size for a mapped frame,
919 we can not set pixel width/height either. The window manager may
920 override our resize request, XMonad does this all the time.
921 The best we can do is try to sync, so lisp code sees the updated
922 size as fast as possible.
923 For unmapped windows, we can set rows/cols. When
924 the frame is mapped again we will (hopefully) get the correct size. */
925 if (FRAME_VISIBLE_P (f
))
927 /* Must call this to flush out events */
928 (void)gtk_events_pending ();
930 x_wait_for_event (f
, ConfigureNotify
);
933 adjust_frame_size (f
, -1, -1, 5, 0);
936 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
937 The policy is to keep the number of editable lines. */
940 xg_height_or_width_changed (struct frame
*f
)
942 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
943 FRAME_TOTAL_PIXEL_WIDTH (f
),
944 FRAME_TOTAL_PIXEL_HEIGHT (f
));
945 f
->output_data
.x
->hint_flags
= 0;
946 x_wm_set_size_hint (f
, 0, 0);
949 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
950 Must be done like this, because GtkWidget:s can have "hidden"
951 X Window that aren't accessible.
953 Return 0 if no widget match WDESC. */
956 xg_win_to_widget (Display
*dpy
, Window wdesc
)
959 GtkWidget
*gwdesc
= 0;
963 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
968 event
.any
.window
= gdkwin
;
969 event
.any
.type
= GDK_NOTHING
;
970 gwdesc
= gtk_get_event_widget (&event
);
977 /* Set the background of widget W to PIXEL. */
980 xg_set_widget_bg (struct frame
*f
, GtkWidget
*w
, unsigned long pixel
)
986 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
988 bg
.red
= (double)xbg
.red
/65535.0;
989 bg
.green
= (double)xbg
.green
/65535.0;
990 bg
.blue
= (double)xbg
.blue
/65535.0;
992 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &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
);
1002 /* Callback called when the gtk theme changes.
1003 We notify lisp code so it can fix faces used for region for example. */
1006 style_changed_cb (GObject
*go
,
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
);
1016 event
.kind
= CONFIG_CHANGED_EVENT
;
1017 event
.frame_or_window
= build_string (display_name
);
1018 /* Theme doesn't change often, so intern is called seldom. */
1019 event
.arg
= intern ("theme-name");
1020 kbd_buffer_store_event (&event
);
1022 update_theme_scrollbar_width ();
1023 update_theme_scrollbar_height ();
1025 /* If scroll bar width changed, we need set the new size on all frames
1029 Lisp_Object rest
, frame
;
1030 FOR_EACH_FRAME (rest
, frame
)
1032 struct frame
*f
= XFRAME (frame
);
1033 if (FRAME_LIVE_P (f
)
1035 && FRAME_X_DISPLAY (f
) == dpy
)
1037 x_set_scroll_bar_default_width (f
);
1038 x_set_scroll_bar_default_height (f
);
1039 xg_frame_set_char_size (f
, FRAME_TEXT_WIDTH (f
), FRAME_TEXT_HEIGHT (f
));
1045 /* Called when a delete-event occurs on WIDGET. */
1048 delete_cb (GtkWidget
*widget
,
1053 /* The event doesn't arrive in the normal event loop. Send event
1055 struct frame
*f
= user_data
;
1056 struct input_event ie
;
1059 ie
.kind
= DELETE_WINDOW_EVENT
;
1060 XSETFRAME (ie
.frame_or_window
, f
);
1061 kbd_buffer_store_event (&ie
);
1067 /* Create and set up the GTK widgets for frame F.
1068 Return true if creation succeeded. */
1071 xg_create_frame_widgets (struct frame
*f
)
1074 GtkWidget
*wvbox
, *whbox
;
1083 if (FRAME_X_EMBEDDED_P (f
))
1085 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1086 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1089 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1091 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1092 has backported it to Gtk+ 2.0 and they add the resize grip for
1093 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1094 forever, so disable the grip. */
1095 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1096 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1097 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1100 xg_set_screen (wtop
, f
);
1102 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1103 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1104 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1105 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1108 wfixed
= emacs_fixed_new (f
);
1110 wfixed
= gtk_fixed_new ();
1113 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1115 if (wtop
) gtk_widget_destroy (wtop
);
1116 if (wvbox
) gtk_widget_destroy (wvbox
);
1117 if (whbox
) gtk_widget_destroy (whbox
);
1118 if (wfixed
) gtk_widget_destroy (wfixed
);
1124 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1125 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1126 gtk_widget_set_name (wvbox
, "pane");
1127 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1129 /* If this frame has a title or name, set it in the title bar. */
1130 if (! NILP (f
->title
))
1131 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1132 else if (! NILP (f
->name
))
1133 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1135 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1137 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1138 FRAME_GTK_WIDGET (f
) = wfixed
;
1139 f
->output_data
.x
->vbox_widget
= wvbox
;
1140 f
->output_data
.x
->hbox_widget
= whbox
;
1142 gtk_widget_set_has_window (wfixed
, TRUE
);
1144 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1145 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1146 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1148 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1149 update_frame_tool_bar (f
);
1151 /* We don't want this widget double buffered, because we draw on it
1152 with regular X drawing primitives, so from a GTK/GDK point of
1153 view, the widget is totally blank. When an expose comes, this
1154 will make the widget blank, and then Emacs redraws it. This flickers
1155 a lot, so we turn off double buffering. */
1156 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1158 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1159 SSDATA (Vx_resource_name
),
1160 SSDATA (Vx_resource_class
));
1162 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1163 GTK is to destroy the widget. We want Emacs to do that instead. */
1164 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1165 G_CALLBACK (delete_cb
), f
);
1167 /* Convert our geometry parameters into a geometry string
1169 GTK will itself handle calculating the real position this way. */
1170 xg_set_geometry (f
);
1172 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1174 gtk_widget_add_events (wfixed
,
1175 GDK_POINTER_MOTION_MASK
1177 | GDK_BUTTON_PRESS_MASK
1178 | GDK_BUTTON_RELEASE_MASK
1179 | GDK_KEY_PRESS_MASK
1180 | GDK_ENTER_NOTIFY_MASK
1181 | GDK_LEAVE_NOTIFY_MASK
1182 | GDK_FOCUS_CHANGE_MASK
1183 | GDK_STRUCTURE_MASK
1184 | GDK_VISIBILITY_NOTIFY_MASK
);
1186 /* Must realize the windows so the X window gets created. It is used
1187 by callers of this function. */
1188 gtk_widget_realize (wfixed
);
1189 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1191 /* Since GTK clears its window by filling with the background color,
1192 we must keep X and GTK background in sync. */
1193 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1196 /* Also, do not let any background pixmap to be set, this looks very
1197 bad as Emacs overwrites the background pixmap with its own idea
1198 of background color. */
1199 style
= gtk_widget_get_modifier_style (wfixed
);
1201 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1202 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1203 gtk_widget_modify_style (wfixed
, style
);
1205 gtk_widget_set_can_focus (wfixed
, TRUE
);
1206 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
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
);
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
,
1225 G_CALLBACK (style_changed_cb
),
1228 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1229 G_CALLBACK (style_changed_cb
),
1230 gdk_screen_get_display (screen
));
1240 xg_free_frame_widgets (struct frame
*f
)
1242 if (FRAME_GTK_OUTER_WIDGET (f
))
1244 #ifdef USE_GTK_TOOLTIP
1245 struct x_output
*x
= f
->output_data
.x
;
1247 struct xg_frame_tb_info
*tbinfo
1248 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
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
1258 gtk_widget_destroy (x
->ttip_lbl
);
1260 g_object_unref (G_OBJECT (x
->ttip_widget
));
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). */
1272 x_wm_set_size_hint (struct frame
*f
, long int flags
, bool user_position
)
1274 /* Must use GTK routines here, otherwise GTK resets the size hints
1275 to its own defaults. */
1276 GdkGeometry size_hints
;
1277 gint hint_flags
= 0;
1278 int base_width
, base_height
;
1279 int min_rows
= 0, min_cols
= 0;
1280 int win_gravity
= f
->win_gravity
;
1281 Lisp_Object fs_state
, frame
;
1283 /* Don't set size hints during initialization; that apparently leads
1284 to a race condition. See the thread at
1285 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1286 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1289 XSETFRAME (frame
, f
);
1290 fs_state
= Fframe_parameter (frame
, Qfullscreen
);
1291 if (EQ (fs_state
, Qmaximized
) || EQ (fs_state
, Qfullboth
))
1293 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1294 Gtk3 don't get along and the frame shrinks (!).
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
;
1306 flags
= f
->size_hint_flags
;
1308 size_hints
= f
->output_data
.x
->size_hints
;
1309 hint_flags
= f
->output_data
.x
->hint_flags
;
1311 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1312 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
1313 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
1315 hint_flags
|= GDK_HINT_BASE_SIZE
;
1316 /* Use one row/col here so base_height/width does not become zero.
1317 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1318 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1319 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1320 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1322 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1323 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1325 size_hints
.base_width
= base_width
;
1326 size_hints
.base_height
= base_height
;
1327 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);
1328 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
1330 /* These currently have a one to one mapping with the X values, but I
1331 don't think we should rely on that. */
1332 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1333 size_hints
.win_gravity
= 0;
1334 if (win_gravity
== NorthWestGravity
)
1335 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1336 else if (win_gravity
== NorthGravity
)
1337 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1338 else if (win_gravity
== NorthEastGravity
)
1339 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1340 else if (win_gravity
== WestGravity
)
1341 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1342 else if (win_gravity
== CenterGravity
)
1343 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1344 else if (win_gravity
== EastGravity
)
1345 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1346 else if (win_gravity
== SouthWestGravity
)
1347 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1348 else if (win_gravity
== SouthGravity
)
1349 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1350 else if (win_gravity
== SouthEastGravity
)
1351 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1352 else if (win_gravity
== StaticGravity
)
1353 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1357 hint_flags
&= ~GDK_HINT_POS
;
1358 hint_flags
|= GDK_HINT_USER_POS
;
1361 if (hint_flags
!= f
->output_data
.x
->hint_flags
1362 || memcmp (&size_hints
,
1363 &f
->output_data
.x
->size_hints
,
1364 sizeof (size_hints
)) != 0)
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
;
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. */
1382 xg_set_background_color (struct frame
*f
, unsigned long bg
)
1384 if (FRAME_GTK_WIDGET (f
))
1387 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1393 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1394 functions so GTK does not overwrite the icon. */
1397 xg_set_frame_icon (struct frame
*f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1399 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1403 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1408 /***********************************************************************
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. */
1415 get_dialog_title (char key
)
1417 const char *title
= "";
1425 title
= "Information";
1444 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1445 the dialog, but return TRUE so the event does not propagate further
1446 in GTK. This prevents GTK from destroying the dialog widget automatically
1447 and we can always destroy the widget manually, regardless of how
1448 it was popped down (button press or WM_DELETE_WINDOW).
1449 W is the dialog widget.
1450 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1451 user_data is NULL (not used).
1453 Returns TRUE to end propagation of event. */
1456 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1458 gtk_widget_unmap (w
);
1462 /* Create a popup dialog window. See also xg_create_widget below.
1463 WV is a widget_value describing the dialog.
1464 SELECT_CB is the callback to use when a button has been pressed.
1465 DEACTIVATE_CB is the callback to use when the dialog pops down.
1467 Returns the GTK dialog widget. */
1470 create_dialog (widget_value
*wv
,
1471 GCallback select_cb
,
1472 GCallback deactivate_cb
)
1474 const char *title
= get_dialog_title (wv
->name
[0]);
1475 int total_buttons
= wv
->name
[1] - '0';
1476 int right_buttons
= wv
->name
[4] - '0';
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
));
1484 GtkWidget
*whbox_down
;
1486 /* If the number of buttons is greater than 4, make two rows of buttons
1487 instead. This looks better. */
1488 bool make_two_rows
= total_buttons
> 4;
1490 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1491 left_buttons
= total_buttons
- right_buttons
;
1493 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1494 gtk_widget_set_name (wdialog
, "emacs-dialog");
1499 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1500 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1501 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1502 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1503 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1504 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1506 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1507 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1508 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1510 cur_box
= GTK_BOX (whbox_up
);
1513 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1514 G_CALLBACK (dialog_delete_callback
), 0);
1518 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1519 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1522 for (item
= wv
->contents
; item
; item
= item
->next
)
1524 char *utf8_label
= get_utf8_string (item
->value
);
1528 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1530 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1531 /* This is the text part of the dialog. */
1532 w
= gtk_label_new (utf8_label
);
1533 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1534 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1535 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1537 /* Try to make dialog look better. Must realize first so
1538 the widget can calculate the size it needs. */
1539 gtk_widget_realize (w
);
1540 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1541 gtk_box_set_spacing (wvbox
, req
.height
);
1542 if (item
->value
&& strlen (item
->value
) > 0)
1543 button_spacing
= 2*req
.width
/strlen (item
->value
);
1544 if (button_spacing
< 10) button_spacing
= 10;
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
);
1553 g_signal_connect (G_OBJECT (w
), "clicked",
1554 select_cb
, item
->call_data
);
1556 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1557 if (++button_nr
== left_buttons
)
1560 cur_box
= GTK_BOX (whbox_down
);
1565 g_free (utf8_label
);
1571 struct xg_dialog_data
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. */
1584 xg_dialog_response_cb (GtkDialog
*w
,
1588 struct xg_dialog_data
*dd
= user_data
;
1589 dd
->response
= response
;
1590 g_main_loop_quit (dd
->loop
);
1594 /* Destroy the dialog. This makes it pop down. */
1597 pop_down_dialog (void *arg
)
1599 struct xg_dialog_data
*dd
= arg
;
1602 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1603 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1605 g_main_loop_quit (dd
->loop
);
1606 g_main_loop_unref (dd
->loop
);
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. */
1615 xg_maybe_add_timer (gpointer data
)
1617 struct xg_dialog_data
*dd
= data
;
1618 struct timespec next_time
= timer_check ();
1622 if (timespec_valid_p (next_time
))
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
);
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. */
1639 xg_dialog_run (struct frame
*f
, GtkWidget
*w
)
1641 ptrdiff_t count
= SPECPDL_INDEX ();
1642 struct xg_dialog_data dd
;
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
);
1650 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1651 dd
.response
= GTK_RESPONSE_CANCEL
;
1655 g_signal_connect (G_OBJECT (w
),
1657 G_CALLBACK (xg_dialog_response_cb
),
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
);
1663 record_unwind_protect_ptr (pop_down_dialog
, &dd
);
1665 (void) xg_maybe_add_timer (&dd
);
1666 g_main_loop_run (dd
.loop
);
1669 unbind_to (count
, Qnil
);
1675 /***********************************************************************
1676 File dialog functions
1677 ***********************************************************************/
1678 /* Return true if the old file selection dialog is being used. */
1681 xg_uses_old_file_dialog (void)
1683 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1684 return x_gtk_use_old_file_dialog
;
1691 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1693 /* Return the selected file for file chooser dialog W.
1694 The returned string must be free:d. */
1697 xg_get_file_name_from_chooser (GtkWidget
*w
)
1699 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1702 /* Callback called when the "Show hidden files" toggle is pressed.
1703 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1706 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1708 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1710 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1711 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
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. */
1722 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1724 if (strcmp (arg1
->name
, "show-hidden") == 0)
1726 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1727 gboolean visible
, toggle_on
;
1729 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1730 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1732 if (!!visible
!= !!toggle_on
)
1734 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1735 G_CALLBACK (xg_toggle_visibility_cb
),
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
),
1743 x_gtk_show_hidden_files
= visible
;
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.
1756 Returns the created widget. */
1759 xg_get_file_with_chooser (struct frame
*f
,
1761 char *default_filename
,
1762 bool mustmatch_p
, bool only_dir_p
,
1763 xg_get_file_func
*func
)
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
);
1774 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
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
),
1782 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
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.");
1789 if (x_gtk_show_hidden_files
)
1791 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1792 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
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
);
1800 if (x_gtk_file_dialog_help_text
)
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.");
1811 wmessage
= gtk_label_new (msgbuf
);
1812 gtk_widget_show (wmessage
);
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
);
1820 if (default_filename
)
1823 struct gcpro gcpro1
;
1824 char *utf8_filename
;
1827 file
= build_string (default_filename
);
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
);
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
),
1840 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1842 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1844 char *cp
= strrchr (utf8_filename
, '/');
1846 else cp
= utf8_filename
;
1847 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1854 *func
= xg_get_file_name_from_chooser
;
1858 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1860 /* Return the selected file for file selector dialog W.
1861 The returned string must be free:d. */
1864 xg_get_file_name_from_selector (GtkWidget
*w
)
1866 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1867 return xstrdup (gtk_file_selection_get_filename (filesel
));
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.
1878 Returns the created widget. */
1881 xg_get_file_with_selection (struct frame
*f
,
1883 char *default_filename
,
1884 bool mustmatch_p
, bool only_dir_p
,
1885 xg_get_file_func
*func
)
1888 GtkFileSelection
*filesel
;
1890 filewin
= gtk_file_selection_new (prompt
);
1891 filesel
= GTK_FILE_SELECTION (filewin
);
1893 if (default_filename
)
1894 gtk_file_selection_set_filename (filesel
, default_filename
);
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
);
1903 *func
= xg_get_file_name_from_selector
;
1907 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
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
1919 Returns a file name or NULL if no file was selected.
1920 The returned string must be freed by the caller. */
1923 xg_get_file_name (struct frame
*f
,
1925 char *default_filename
,
1931 int filesel_done
= 0;
1932 xg_get_file_func func
;
1934 #ifdef HAVE_GTK_FILE_SELECTION_NEW
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
);
1940 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1941 mustmatch_p
, only_dir_p
, &func
);
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 */
1948 gtk_widget_set_name (w
, "emacs-filedialog");
1950 filesel_done
= xg_dialog_run (f
, w
);
1951 if (filesel_done
== GTK_RESPONSE_OK
)
1954 gtk_widget_destroy (w
);
1958 /***********************************************************************
1960 ***********************************************************************/
1962 #ifdef HAVE_FREETYPE
1964 #if USE_NEW_GTK_FONT_CHOOSER
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 \
1976 #define XG_STYLE_TO_SYMBOL(s) \
1977 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
1978 : s == PANGO_STYLE_ITALIC ? Qitalic \
1981 #endif /* USE_NEW_GTK_FONT_CHOOSER */
1984 static char *x_last_font_name
;
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
1990 `FAMILY [VALUE1 VALUE2] SIZE'
1992 This can be parsed using font_parse_fcname in font.c.
1993 DEFAULT_NAME, if non-zero, is the default font name. */
1996 xg_get_font (struct frame
*f
, const char *default_name
)
2000 Lisp_Object font
= Qnil
;
2002 w
= gtk_font_chooser_dialog_new
2003 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2007 /* Convert fontconfig names to Gtk names, i.e. remove - before
2009 char *p
= strrchr (default_name
, '-');
2013 while (c_isdigit (*ep
))
2015 if (*ep
== '\0') *p
= ' ';
2018 else if (x_last_font_name
)
2019 default_name
= x_last_font_name
;
2022 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2024 gtk_widget_set_name (w
, "emacs-fontdialog");
2025 done
= xg_dialog_run (f
, w
);
2026 if (done
== GTK_RESPONSE_OK
)
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
));
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
);
2042 args
[1] = build_string (name
);
2045 args
[3] = make_float (pango_units_to_double (size
));
2048 args
[5] = XG_WEIGHT_TO_SYMBOL (weight
);
2051 args
[7] = XG_STYLE_TO_SYMBOL (style
);
2056 font
= Ffont_spec (8, args
);
2058 pango_font_description_free (desc
);
2059 dupstring (&x_last_font_name
, name
);
2062 #else /* Use old font selector, which just returns the font name. */
2065 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2069 font
= build_string (font_name
);
2070 g_free (x_last_font_name
);
2071 x_last_font_name
= font_name
;
2073 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2076 gtk_widget_destroy (w
);
2079 #endif /* HAVE_FREETYPE */
2083 /***********************************************************************
2085 ***********************************************************************/
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. */
2091 #define MENU_ITEM_NAME "emacs-menuitem"
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
;
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
;
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.
2106 The menu bar and all sub menus under the menu bar in a frame
2107 share the same structure, hence the reference count.
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. */
2112 static xg_menu_cb_data
*
2113 make_cl_data (xg_menu_cb_data
*cl_data
, struct frame
*f
, GCallback highlight_cb
)
2117 cl_data
= xmalloc (sizeof *cl_data
);
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;
2124 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2127 cl_data
->ref_count
++;
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.
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. */
2144 update_cl_data (xg_menu_cb_data
*cl_data
,
2146 GCallback highlight_cb
)
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
;
2157 /* Decrease reference count for CL_DATA.
2158 If reference count is zero, free CL_DATA. */
2161 unref_cl_data (xg_menu_cb_data
*cl_data
)
2163 if (cl_data
&& cl_data
->ref_count
> 0)
2165 cl_data
->ref_count
--;
2166 if (cl_data
->ref_count
== 0)
2168 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2174 /* Function that marks all lisp data during GC. */
2180 Lisp_Object rest
, frame
;
2182 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2183 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2185 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2187 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2189 if (! NILP (cb_data
->help
))
2190 mark_object (cb_data
->help
);
2193 FOR_EACH_FRAME (rest
, frame
)
2195 struct frame
*f
= XFRAME (frame
);
2197 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2199 struct xg_frame_tb_info
*tbinfo
2200 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2204 mark_object (tbinfo
->last_tool_bar
);
2205 mark_object (tbinfo
->style
);
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. */
2217 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2221 xg_menu_item_cb_data
*data
= client_data
;
2222 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
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.
2232 Returns FALSE to tell GTK to keep processing this event. */
2235 menuitem_highlight_callback (GtkWidget
*w
,
2236 GdkEventCrossing
*event
,
2237 gpointer client_data
)
2240 GtkWidget
*subwidget
;
2241 xg_menu_item_cb_data
*data
;
2243 ev
.crossing
= *event
;
2244 subwidget
= gtk_get_event_widget (&ev
);
2245 data
= g_object_get_data (G_OBJECT (subwidget
), XG_ITEM_DATA
);
2248 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
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
);
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. */
2264 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2266 unref_cl_data (client_data
);
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.
2272 Returns the GtkHBox. */
2275 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
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
);
2286 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2287 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2289 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2290 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
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
);
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.
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.
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. */
2314 make_menu_item (const char *utf8_label
,
2315 const char *utf8_key
,
2320 GtkWidget
*wtoadd
= 0;
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
= " ";
2329 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2331 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
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
);
2338 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
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
));
2344 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2349 if (utf8_key
) w
= gtk_menu_item_new ();
2350 else w
= gtk_menu_item_new_with_label (utf8_label
);
2353 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2354 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2359 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2361 static int xg_detached_menus
;
2363 /* Return true if there are detached menus. */
2366 xg_have_tear_offs (struct frame
*f
)
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;
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. */
2380 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2382 if (xg_detached_menus
> 0) --xg_detached_menus
;
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. */
2391 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2393 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2394 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2396 ++xg_detached_menus
;
2397 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2399 G_CALLBACK (tearoff_remove
), 0);
2402 #else /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2404 xg_have_tear_offs (struct frame
*f
)
2406 return FRAME_MENUBAR_HEIGHT (f
) == 0;
2408 #endif /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
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.
2422 Returns the created GtkWidget. */
2425 xg_create_one_menuitem (widget_value
*item
,
2427 GCallback select_cb
,
2428 GCallback highlight_cb
,
2429 xg_menu_cb_data
*cl_data
,
2435 xg_menu_item_cb_data
*cb_data
;
2437 utf8_label
= get_utf8_string (item
->name
);
2438 utf8_key
= get_utf8_string (item
->key
);
2440 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2442 if (utf8_label
) g_free (utf8_label
);
2443 if (utf8_key
) g_free (utf8_key
);
2445 cb_data
= xmalloc (sizeof *cb_data
);
2447 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
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
;
2454 g_signal_connect (G_OBJECT (w
),
2456 G_CALLBACK (menuitem_destroy_callback
),
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
);
2462 /* final item, not a submenu */
2463 if (item
->call_data
&& ! item
->contents
)
2467 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
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.
2490 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2493 This function calls itself to create submenus. */
2496 create_menus (widget_value
*data
,
2498 GCallback select_cb
,
2499 GCallback deactivate_cb
,
2500 GCallback highlight_cb
,
2505 xg_menu_cb_data
*cl_data
,
2509 GtkWidget
*wmenu
= topmenu
;
2510 GSList
*group
= NULL
;
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
),
2525 g_signal_connect (G_OBJECT (wmenu
),
2526 "leave-notify-event",
2527 G_CALLBACK (menuitem_highlight_callback
),
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);
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
);
2547 gtk_widget_set_name (wmenu
, name
);
2550 g_signal_connect (G_OBJECT (wmenu
),
2551 "selection-done", deactivate_cb
, 0);
2554 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2555 if (! menu_bar_p
&& add_tearoff_p
)
2557 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2558 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2560 g_signal_connect (G_OBJECT (tearoff
), "activate",
2561 G_CALLBACK (tearoff_activate
), 0);
2565 for (item
= data
; item
; item
= item
->next
)
2569 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2570 && !menu_separator_name_p (item
->name
))
2573 /* A title for a popup. We do the same as GTK does when
2574 creating titles, but it does not look good. */
2576 utf8_label
= get_utf8_string (item
->name
);
2578 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2579 w
= gtk_menu_item_new_with_label (utf8_label
);
2580 gtk_widget_set_sensitive (w
, FALSE
);
2581 if (utf8_label
) g_free (utf8_label
);
2583 else if (menu_separator_name_p (item
->name
))
2586 /* GTK only have one separator type. */
2587 w
= gtk_separator_menu_item_new ();
2591 w
= xg_create_one_menuitem (item
,
2593 item
->contents
? 0 : select_cb
,
2598 /* Create a possibly empty submenu for menu bar items, since some
2599 themes don't highlight items correctly without it. */
2600 if (item
->contents
|| menu_bar_p
)
2602 GtkWidget
*submenu
= create_menus (item
->contents
,
2613 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2617 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2618 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2624 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2625 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2626 with some text and buttons.
2627 F is the frame the created item belongs to.
2628 NAME is the name to use for the top widget.
2629 VAL is a widget_value structure describing items to be created.
2630 SELECT_CB is the callback to use when a menu item is selected or
2631 a dialog button is pressed.
2632 DEACTIVATE_CB is the callback to use when an item is deactivated.
2633 For a menu, when a sub menu is not shown anymore, for a dialog it is
2634 called when the dialog is popped down.
2635 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2637 Returns the widget created. */
2640 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2641 widget_value
*val
, GCallback select_cb
,
2642 GCallback deactivate_cb
, GCallback highlight_cb
)
2645 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2646 bool pop_up_p
= strcmp (type
, "popup") == 0;
2648 if (strcmp (type
, "dialog") == 0)
2650 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2651 xg_set_screen (w
, f
);
2652 gtk_window_set_transient_for (GTK_WINDOW (w
),
2653 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2654 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2655 gtk_widget_set_name (w
, "emacs-dialog");
2656 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2658 else if (menu_bar_p
|| pop_up_p
)
2660 w
= create_menus (val
->contents
,
2672 /* Set the cursor to an arrow for popup menus when they are mapped.
2673 This is done by default for menu bar menus. */
2676 /* Must realize so the GdkWindow inside the widget is created. */
2677 gtk_widget_realize (w
);
2678 xg_set_cursor (w
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
2683 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2690 /* Return the label for menu item WITEM. */
2693 xg_get_menu_item_label (GtkMenuItem
*witem
)
2695 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2696 return gtk_label_get_label (wlabel
);
2699 /* Return true if the menu item WITEM has the text LABEL. */
2702 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2705 char *utf8_label
= get_utf8_string (label
);
2706 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2708 if (! old_label
&& ! utf8_label
)
2710 else if (old_label
&& utf8_label
)
2711 is_same
= strcmp (utf8_label
, old_label
) == 0;
2713 if (utf8_label
) g_free (utf8_label
);
2718 /* Destroy widgets in LIST. */
2721 xg_destroy_widgets (GList
*list
)
2725 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2727 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2729 /* Destroying the widget will remove it from the container it is in. */
2730 gtk_widget_destroy (w
);
2734 /* Update the top level names in MENUBAR (i.e. not submenus).
2735 F is the frame the menu bar belongs to.
2736 *LIST is a list with the current menu bar names (menu item widgets).
2737 ITER is the item within *LIST that shall be updated.
2738 POS is the numerical position, starting at 0, of ITER in *LIST.
2739 VAL describes what the menu bar shall look like after the update.
2740 SELECT_CB is the callback to use when a menu item is selected.
2741 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2742 CL_DATA points to the callback data to be used for this menu bar.
2744 This function calls itself to walk through the menu bar names. */
2747 xg_update_menubar (GtkWidget
*menubar
,
2753 GCallback select_cb
,
2754 GCallback deactivate_cb
,
2755 GCallback highlight_cb
,
2756 xg_menu_cb_data
*cl_data
)
2758 if (! iter
&& ! val
)
2760 else if (iter
&& ! val
)
2762 /* Item(s) have been removed. Remove all remaining items. */
2763 xg_destroy_widgets (iter
);
2765 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2766 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2767 gtk_menu_item_new_with_label (""),
2773 else if (! iter
&& val
)
2775 /* Item(s) added. Add all new items in one call. */
2776 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2777 0, 1, 0, menubar
, cl_data
, 0);
2783 /* Below this neither iter or val is NULL */
2784 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2786 /* This item is still the same, check next item. */
2788 iter
= g_list_next (iter
);
2791 else /* This item is changed. */
2793 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2794 GtkMenuItem
*witem2
= 0;
2795 bool val_in_menubar
= 0;
2796 bool iter_in_new_menubar
= 0;
2800 /* See if the changed entry (val) is present later in the menu bar */
2802 iter2
&& ! val_in_menubar
;
2803 iter2
= g_list_next (iter2
))
2805 witem2
= GTK_MENU_ITEM (iter2
->data
);
2806 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2809 /* See if the current entry (iter) is present later in the
2810 specification for the new menu bar. */
2811 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2812 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2814 if (val_in_menubar
&& ! iter_in_new_menubar
)
2818 /* This corresponds to:
2823 g_object_ref (G_OBJECT (witem
));
2824 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2825 gtk_widget_destroy (GTK_WIDGET (witem
));
2827 /* Must get new list since the old changed. */
2828 g_list_free (*list
);
2829 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2830 while (nr
-- > 0) iter
= g_list_next (iter
);
2832 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2834 /* This corresponds to:
2837 Rename B to X. This might seem to be a strange thing to do,
2838 since if there is a menu under B it will be totally wrong for X.
2839 But consider editing a C file. Then there is a C-mode menu
2840 (corresponds to B above).
2841 If then doing C-x C-f the minibuf menu (X above) replaces the
2842 C-mode menu. When returning from the minibuffer, we get
2843 back the C-mode menu. Thus we do:
2844 Rename B to X (C-mode to minibuf menu)
2845 Rename X to B (minibuf to C-mode menu).
2846 If the X menu hasn't been invoked, the menu under B
2847 is up to date when leaving the minibuffer. */
2848 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2849 char *utf8_label
= get_utf8_string (val
->name
);
2850 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2852 /* GTK menu items don't notice when their labels have been
2853 changed from underneath them, so we have to explicitly
2854 use g_object_notify to tell listeners (e.g., a GMenuModel
2855 bridge that might be loaded) that the item's label has
2857 gtk_label_set_text (wlabel
, utf8_label
);
2858 g_object_notify (G_OBJECT (witem
), "label");
2860 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2861 /* If this item has a submenu that has been detached, change
2862 the title in the WM decorations also. */
2863 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2864 /* Set the title of the detached window. */
2865 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2868 if (utf8_label
) g_free (utf8_label
);
2869 iter
= g_list_next (iter
);
2873 else if (! val_in_menubar
&& iter_in_new_menubar
)
2875 /* This corresponds to:
2882 GtkWidget
*w
= xg_create_one_menuitem (val
,
2889 /* Create a possibly empty submenu for menu bar items, since some
2890 themes don't highlight items correctly without it. */
2891 GtkWidget
*submenu
= create_menus (NULL
, f
,
2892 select_cb
, deactivate_cb
,
2894 0, 0, 0, 0, cl_data
, 0);
2896 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2897 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2898 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2900 g_list_free (*list
);
2901 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2902 while (nr
-- > 0) iter
= g_list_next (iter
);
2903 iter
= g_list_next (iter
);
2907 else /* if (val_in_menubar && iter_in_new_menubar) */
2910 /* This corresponds to:
2915 g_object_ref (G_OBJECT (witem2
));
2916 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2917 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2918 GTK_WIDGET (witem2
), pos
);
2919 g_object_unref (G_OBJECT (witem2
));
2921 g_list_free (*list
);
2922 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2923 while (nr
-- > 0) iter
= g_list_next (iter
);
2924 if (iter
) iter
= g_list_next (iter
);
2930 /* Update the rest of the menu bar. */
2931 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2932 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2935 /* Update the menu item W so it corresponds to VAL.
2936 SELECT_CB is the callback to use when a menu item is selected.
2937 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2938 CL_DATA is the data to set in the widget for menu invocation. */
2941 xg_update_menu_item (widget_value
*val
,
2943 GCallback select_cb
,
2944 GCallback highlight_cb
,
2945 xg_menu_cb_data
*cl_data
)
2952 const char *old_label
= 0;
2953 const char *old_key
= 0;
2954 xg_menu_item_cb_data
*cb_data
;
2955 bool label_changed
= false;
2957 wchild
= XG_BIN_CHILD (w
);
2958 utf8_label
= get_utf8_string (val
->name
);
2959 utf8_key
= get_utf8_string (val
->key
);
2961 /* See if W is a menu item with a key. See make_menu_item above. */
2962 if (GTK_IS_BOX (wchild
))
2964 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2966 wlbl
= GTK_LABEL (list
->data
);
2967 wkey
= GTK_LABEL (list
->next
->data
);
2972 /* Remove the key and keep just the label. */
2973 g_object_ref (G_OBJECT (wlbl
));
2974 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2975 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2976 g_object_unref (G_OBJECT (wlbl
));
2981 else /* Just a label. */
2983 wlbl
= GTK_LABEL (wchild
);
2985 /* Check if there is now a key. */
2988 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2989 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2991 wlbl
= GTK_LABEL (list
->data
);
2992 wkey
= GTK_LABEL (list
->next
->data
);
2995 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2996 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3000 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3001 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3003 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3005 label_changed
= true;
3006 gtk_label_set_text (wkey
, utf8_key
);
3009 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3011 label_changed
= true;
3012 gtk_label_set_text (wlbl
, utf8_label
);
3015 if (utf8_key
) g_free (utf8_key
);
3016 if (utf8_label
) g_free (utf8_label
);
3018 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3019 gtk_widget_set_sensitive (w
, FALSE
);
3020 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3021 gtk_widget_set_sensitive (w
, TRUE
);
3023 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
3026 cb_data
->call_data
= val
->call_data
;
3027 cb_data
->help
= val
->help
;
3028 cb_data
->cl_data
= cl_data
;
3030 /* We assume the callback functions don't change. */
3031 if (val
->call_data
&& ! val
->contents
)
3033 /* This item shall have a select callback. */
3034 if (! cb_data
->select_id
)
3036 = g_signal_connect (G_OBJECT (w
), "activate",
3037 select_cb
, cb_data
);
3039 else if (cb_data
->select_id
)
3041 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3042 cb_data
->select_id
= 0;
3046 if (label_changed
) /* See comment in xg_update_menubar. */
3047 g_object_notify (G_OBJECT (w
), "label");
3050 /* Update the toggle menu item W so it corresponds to VAL. */
3053 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3055 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3058 /* Update the radio menu item W so it corresponds to VAL. */
3061 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3063 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3066 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3067 SUBMENU may be NULL, in that case a new menu is created.
3068 F is the frame the menu bar belongs to.
3069 VAL describes the contents of the menu bar.
3070 SELECT_CB is the callback to use when a menu item is selected.
3071 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3072 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3073 CL_DATA is the call back data to use for any newly created items.
3075 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3079 xg_update_submenu (GtkWidget
*submenu
,
3082 GCallback select_cb
,
3083 GCallback deactivate_cb
,
3084 GCallback highlight_cb
,
3085 xg_menu_cb_data
*cl_data
)
3087 GtkWidget
*newsub
= submenu
;
3091 bool has_tearoff_p
= 0;
3092 GList
*first_radio
= 0;
3095 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3097 for (cur
= val
, iter
= list
;
3099 iter
= g_list_next (iter
), cur
= cur
->next
)
3101 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3103 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
3104 /* Skip tearoff items, they have no counterpart in val. */
3105 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
3108 iter
= g_list_next (iter
);
3109 if (iter
) w
= GTK_WIDGET (iter
->data
);
3114 /* Remember first radio button in a group. If we get a mismatch in
3115 a radio group we must rebuild the whole group so that the connections
3116 in GTK becomes correct. */
3117 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3119 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3120 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3123 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3125 if (! menu_separator_name_p (cur
->name
))
3128 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3130 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3132 xg_update_toggle_item (cur
, w
);
3133 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3135 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3137 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3139 xg_update_radio_item (cur
, w
);
3140 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3142 else if (GTK_IS_MENU_ITEM (w
))
3144 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3147 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3148 menu_separator_name_p (cur
->name
))
3151 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3153 sub
= gtk_menu_item_get_submenu (witem
);
3154 if (sub
&& ! cur
->contents
)
3156 /* Not a submenu anymore. */
3157 g_object_ref (G_OBJECT (sub
));
3158 remove_submenu (witem
);
3159 gtk_widget_destroy (sub
);
3161 else if (cur
->contents
)
3165 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3166 select_cb
, deactivate_cb
,
3167 highlight_cb
, cl_data
);
3169 /* If this item just became a submenu, we must set it. */
3171 gtk_menu_item_set_submenu (witem
, nsub
);
3176 /* Structural difference. Remove everything from here and down
3182 /* Remove widgets from first structural change. */
3185 /* If we are adding new menu items below, we must remove from
3186 first radio button so that radio groups become correct. */
3187 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3188 else xg_destroy_widgets (iter
);
3193 /* More items added. Create them. */
3194 newsub
= create_menus (cur
,
3207 if (list
) g_list_free (list
);
3212 /* Update the MENUBAR.
3213 F is the frame the menu bar belongs to.
3214 VAL describes the contents of the menu bar.
3215 If DEEP_P, rebuild all but the top level menu names in
3216 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3217 SELECT_CB is the callback to use when a menu item is selected.
3218 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3219 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3222 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3223 widget_value
*val
, bool deep_p
,
3224 GCallback select_cb
, GCallback deactivate_cb
,
3225 GCallback highlight_cb
)
3227 xg_menu_cb_data
*cl_data
;
3228 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3232 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3234 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3235 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3241 /* Update all sub menus.
3242 We must keep the submenus (GTK menu item widgets) since the
3243 X Window in the XEvent that activates the menu are those widgets. */
3245 /* Update cl_data, menu_item things in F may have changed. */
3246 update_cl_data (cl_data
, f
, highlight_cb
);
3248 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3253 GtkMenuItem
*witem
= 0;
3255 /* Find sub menu that corresponds to val and update it. */
3256 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3258 witem
= GTK_MENU_ITEM (iter
->data
);
3259 if (xg_item_label_same_p (witem
, cur
->name
))
3261 sub
= gtk_menu_item_get_submenu (witem
);
3266 newsub
= xg_update_submenu (sub
,
3273 /* sub may still be NULL. If we just updated non deep and added
3274 a new menu bar item, it has no sub menu yet. So we set the
3275 newly created sub menu under witem. */
3276 if (newsub
!= sub
&& witem
!= 0)
3278 xg_set_screen (newsub
, f
);
3279 gtk_menu_item_set_submenu (witem
, newsub
);
3285 gtk_widget_show_all (menubar
);
3288 /* Callback called when the menu bar W is mapped.
3289 Used to find the height of the menu bar if we didn't get it
3290 after showing the widget. */
3293 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3296 struct frame
*f
= user_data
;
3297 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3298 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3300 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3301 xg_height_or_width_changed (f
);
3305 /* Recompute all the widgets of frame F, when the menu bar has been
3309 xg_update_frame_menubar (struct frame
*f
)
3311 struct x_output
*x
= f
->output_data
.x
;
3314 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3317 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3318 return; /* Already done this, happens for frames created invisible. */
3322 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3324 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3326 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3327 gtk_widget_show_all (x
->menubar_widget
);
3328 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3330 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3332 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3333 xg_height_or_width_changed (f
);
3338 /* Get rid of the menu bar of frame F, and free its storage.
3339 This is used when deleting a frame, and when turning off the menu bar. */
3342 free_frame_menubar (struct frame
*f
)
3344 struct x_output
*x
= f
->output_data
.x
;
3346 if (x
->menubar_widget
)
3350 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3351 /* The menubar and its children shall be deleted when removed from
3353 x
->menubar_widget
= 0;
3354 FRAME_MENUBAR_HEIGHT (f
) = 0;
3355 xg_height_or_width_changed (f
);
3361 xg_event_is_for_menubar (struct frame
*f
, const XEvent
*event
)
3363 struct x_output
*x
= f
->output_data
.x
;
3372 if (! x
->menubar_widget
) return 0;
3374 if (! (event
->xbutton
.x
>= 0
3375 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3376 && event
->xbutton
.y
>= 0
3377 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
3378 && event
->xbutton
.same_screen
))
3381 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3382 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3384 gevent
.any
.window
= gw
;
3385 gevent
.any
.type
= GDK_NOTHING
;
3386 gwdesc
= gtk_get_event_widget (&gevent
);
3387 if (! gwdesc
) return 0;
3388 if (! GTK_IS_MENU_BAR (gwdesc
)
3389 && ! GTK_IS_MENU_ITEM (gwdesc
)
3390 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3393 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3394 if (! list
) return 0;
3395 rec
.x
= event
->xbutton
.x
;
3396 rec
.y
= event
->xbutton
.y
;
3400 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3402 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3403 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3412 /***********************************************************************
3413 Scroll bar functions
3414 ***********************************************************************/
3417 /* Setting scroll bar values invokes the callback. Use this variable
3418 to indicate that callback should do nothing. */
3420 bool xg_ignore_gtk_scrollbar
;
3422 /* Width and height of scroll bars for the current theme. */
3423 static int scroll_bar_width_for_theme
;
3424 static int scroll_bar_height_for_theme
;
3426 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3427 may be larger than 32 bits. Keep a mapping from integer index to widget
3428 pointers to get around the 32 bit limitation. */
3432 GtkWidget
**widgets
;
3437 /* Grow this much every time we need to allocate more */
3439 #define ID_TO_WIDGET_INCR 32
3441 /* Store the widget pointer W in id_to_widget and return the integer index. */
3444 xg_store_widget_in_map (GtkWidget
*w
)
3448 if (id_to_widget
.max_size
== id_to_widget
.used
)
3451 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3452 memory_full (SIZE_MAX
);
3454 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3455 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3456 new_size
, sizeof (GtkWidget
*));
3458 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3459 id_to_widget
.widgets
[i
] = 0;
3460 id_to_widget
.max_size
= new_size
;
3463 /* Just loop over the array and find a free place. After all,
3464 how many scroll bars are we creating? Should be a small number.
3465 The check above guarantees we will find a free place. */
3466 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3468 if (! id_to_widget
.widgets
[i
])
3470 id_to_widget
.widgets
[i
] = w
;
3471 ++id_to_widget
.used
;
3477 /* Should never end up here */
3481 /* Remove pointer at IDX from id_to_widget.
3482 Called when scroll bar is destroyed. */
3485 xg_remove_widget_from_map (ptrdiff_t idx
)
3487 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3489 id_to_widget
.widgets
[idx
] = 0;
3490 --id_to_widget
.used
;
3494 /* Get the widget pointer at IDX from id_to_widget. */
3497 xg_get_widget_from_map (ptrdiff_t idx
)
3499 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3500 return id_to_widget
.widgets
[idx
];
3506 update_theme_scrollbar_width (void)
3509 GtkAdjustment
*vadj
;
3516 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3517 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3518 g_object_ref_sink (G_OBJECT (wscroll
));
3519 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3520 gtk_widget_destroy (wscroll
);
3521 g_object_unref (G_OBJECT (wscroll
));
3524 scroll_bar_width_for_theme
= w
;
3528 update_theme_scrollbar_height (void)
3531 GtkAdjustment
*hadj
;
3538 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
, 0.1, 0.1, 0.1);
3539 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3540 g_object_ref_sink (G_OBJECT (wscroll
));
3541 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3542 gtk_widget_destroy (wscroll
);
3543 g_object_unref (G_OBJECT (wscroll
));
3546 scroll_bar_height_for_theme
= w
;
3550 xg_get_default_scrollbar_width (void)
3552 return scroll_bar_width_for_theme
;
3556 xg_get_default_scrollbar_height (void)
3558 /* Apparently there's no default height for themes. */
3559 return scroll_bar_width_for_theme
;
3562 /* Return the scrollbar id for X Window WID on display DPY.
3563 Return -1 if WID not in id_to_widget. */
3566 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3571 w
= xg_win_to_widget (dpy
, wid
);
3575 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3576 if (id_to_widget
.widgets
[idx
] == w
)
3583 /* Callback invoked when scroll bar WIDGET is destroyed.
3584 DATA is the index into id_to_widget for WIDGET.
3585 We free pointer to last scroll bar values here and remove the index. */
3588 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3590 intptr_t id
= (intptr_t) data
;
3591 xg_remove_widget_from_map (id
);
3594 /* Create a scroll bar widget for frame F. Store the scroll bar
3596 SCROLL_CALLBACK is the callback to invoke when the value of the
3598 END_CALLBACK is the callback to invoke when scrolling ends.
3599 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3600 to set resources for the widget. */
3603 xg_create_scroll_bar (struct frame
*f
,
3604 struct scroll_bar
*bar
,
3605 GCallback scroll_callback
,
3606 GCallback end_callback
,
3607 const char *scroll_bar_name
)
3613 GtkAdjustment
*vadj
;
3618 /* Page, step increment values are not so important here, they
3619 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3620 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3623 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3624 webox
= gtk_event_box_new ();
3625 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3627 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3629 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3631 scroll_id
= xg_store_widget_in_map (wscroll
);
3633 g_signal_connect (G_OBJECT (wscroll
),
3635 G_CALLBACK (xg_gtk_scroll_destroy
),
3636 (gpointer
) scroll_id
);
3637 g_signal_connect (G_OBJECT (wscroll
),
3641 g_signal_connect (G_OBJECT (wscroll
),
3642 "button-release-event",
3646 /* The scroll bar widget does not draw on a window of its own. Instead
3647 it draws on the parent window, in this case the edit widget. So
3648 whenever the edit widget is cleared, the scroll bar needs to redraw
3649 also, which causes flicker. Put an event box between the edit widget
3650 and the scroll bar, so the scroll bar instead draws itself on the
3651 event box window. */
3652 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3653 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3656 /* Set the cursor to an arrow. */
3657 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3659 bar
->x_window
= scroll_id
;
3660 bar
->horizontal
= 0;
3663 /* Create a horizontal scroll bar widget for frame F. Store the scroll
3664 bar in BAR. SCROLL_CALLBACK is the callback to invoke when the value
3665 of the bar changes. END_CALLBACK is the callback to invoke when
3666 scrolling ends. SCROLL_BAR_NAME is the name we use for the scroll
3667 bar. Can be used to set resources for the widget. */
3670 xg_create_horizontal_scroll_bar (struct frame
*f
,
3671 struct scroll_bar
*bar
,
3672 GCallback scroll_callback
,
3673 GCallback end_callback
,
3674 const char *scroll_bar_name
)
3680 GtkAdjustment
*hadj
;
3685 /* Page, step increment values are not so important here, they
3686 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3687 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
,
3690 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3691 webox
= gtk_event_box_new ();
3692 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3694 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3696 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3698 scroll_id
= xg_store_widget_in_map (wscroll
);
3700 g_signal_connect (G_OBJECT (wscroll
),
3702 G_CALLBACK (xg_gtk_scroll_destroy
),
3703 (gpointer
) scroll_id
);
3704 g_signal_connect (G_OBJECT (wscroll
),
3708 g_signal_connect (G_OBJECT (wscroll
),
3709 "button-release-event",
3713 /* The scroll bar widget does not draw on a window of its own. Instead
3714 it draws on the parent window, in this case the edit widget. So
3715 whenever the edit widget is cleared, the scroll bar needs to redraw
3716 also, which causes flicker. Put an event box between the edit widget
3717 and the scroll bar, so the scroll bar instead draws itself on the
3718 event box window. */
3719 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3720 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3723 /* Set the cursor to an arrow. */
3724 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3726 bar
->x_window
= scroll_id
;
3727 bar
->horizontal
= 1;
3730 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3733 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3735 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3738 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3739 gtk_widget_destroy (w
);
3740 gtk_widget_destroy (wparent
);
3741 SET_FRAME_GARBAGED (f
);
3745 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3747 TOP/LEFT are the new pixel positions where the bar shall appear.
3748 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3751 xg_update_scrollbar_pos (struct frame
*f
,
3752 ptrdiff_t scrollbar_id
,
3759 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3763 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3764 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3767 /* Clear out old position. */
3768 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3769 if (gtk_widget_get_parent (wparent
) == wfixed
)
3771 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3772 "x", &oldx
, "y", &oldy
, NULL
);
3773 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3776 /* Move and resize to new values. */
3777 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3778 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3781 /* No room. Hide scroll bar as some themes output a warning if
3782 the height is less than the min size. */
3783 gtk_widget_hide (wparent
);
3784 gtk_widget_hide (wscroll
);
3788 gtk_widget_show_all (wparent
);
3789 gtk_widget_set_size_request (wscroll
, width
, height
);
3791 gtk_widget_queue_draw (wfixed
);
3792 gdk_window_process_all_updates ();
3793 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3794 /* Clear under old scroll bar position. This must be done after
3795 the gtk_widget_queue_draw and gdk_window_process_all_updates
3797 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3798 oldx
, oldy
, oldw
, oldh
);
3800 /* GTK does not redraw until the main loop is entered again, but
3801 if there are no X events pending we will not enter it. So we sync
3802 here to get some events. */
3805 SET_FRAME_GARBAGED (f
);
3806 cancel_mouse_face (f
);
3811 /* Update the position of the horizontal scroll bar represented by SCROLLBAR_ID
3813 TOP/LEFT are the new pixel positions where the bar shall appear.
3814 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3817 xg_update_horizontal_scrollbar_pos (struct frame
*f
,
3818 ptrdiff_t scrollbar_id
,
3825 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3829 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3830 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3833 /* Clear out old position. */
3834 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3835 if (gtk_widget_get_parent (wparent
) == wfixed
)
3837 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3838 "x", &oldx
, "y", &oldy
, NULL
);
3839 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3842 /* Move and resize to new values. */
3843 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3844 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3847 /* No room. Hide scroll bar as some themes output a warning if
3848 the width is less than the min size. */
3849 gtk_widget_hide (wparent
);
3850 gtk_widget_hide (wscroll
);
3854 gtk_widget_show_all (wparent
);
3855 gtk_widget_set_size_request (wscroll
, width
, height
);
3857 gtk_widget_queue_draw (wfixed
);
3858 gdk_window_process_all_updates ();
3859 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3860 /* Clear under old scroll bar position. This must be done after
3861 the gtk_widget_queue_draw and gdk_window_process_all_updates
3863 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3864 oldx
, oldy
, oldw
, oldh
);
3866 /* GTK does not redraw until the main loop is entered again, but
3867 if there are no X events pending we will not enter it. So we sync
3868 here to get some events. */
3871 SET_FRAME_GARBAGED (f
);
3872 cancel_mouse_face (f
);
3877 /* Get the current value of the range, truncated to an integer. */
3880 int_gtk_range_get_value (GtkRange
*range
)
3882 return gtk_range_get_value (range
);
3886 /* Set the thumb size and position of scroll bar BAR. We are currently
3887 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3890 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3895 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3897 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3899 if (wscroll
&& bar
->dragging
== -1)
3909 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3911 if (scroll_bar_adjust_thumb_portion_p
)
3913 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3914 line rather than the real portion value. This makes the
3915 thumb less likely to resize and that looks better. */
3916 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3918 /* When the thumb is at the bottom, position == whole.
3919 So we need to increase `whole' to make space for the thumb. */
3927 top
= (gdouble
) position
/ whole
;
3928 shown
= (gdouble
) portion
/ whole
;
3931 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
3932 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
3934 /* Assume all lines are of equal size. */
3935 new_step
= size
/ max (1, FRAME_LINES (f
));
3937 old_size
= gtk_adjustment_get_page_size (adj
);
3938 if (old_size
!= size
)
3940 int old_step
= gtk_adjustment_get_step_increment (adj
);
3941 if (old_step
!= new_step
)
3943 gtk_adjustment_set_page_size (adj
, size
);
3944 gtk_adjustment_set_step_increment (adj
, new_step
);
3945 /* Assume a page increment is about 95% of the page size */
3946 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3951 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3955 /* gtk_range_set_value invokes the callback. Set
3956 ignore_gtk_scrollbar to make the callback do nothing */
3957 xg_ignore_gtk_scrollbar
= 1;
3959 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3960 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3962 gtk_adjustment_changed (adj
);
3964 xg_ignore_gtk_scrollbar
= 0;
3971 /* Set the thumb size and position of horizontal scroll bar BAR. We are
3972 currently displaying PORTION out of a whole WHOLE, and our position
3975 xg_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
3980 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3982 if (wscroll
&& bar
->dragging
== -1)
3986 int upper
= max (whole
- 1, 0);
3987 int pagesize
= min (upper
, max (portion
, 0));
3988 int value
= max (0, min (position
, upper
- pagesize
));
3989 /* These should be set to something more <portion, whole>
3991 int page_increment
= 4;
3992 int step_increment
= 1;
3995 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3997 /* gtk_adjustment_set_lower (adj, (gdouble) lower);
3998 gtk_adjustment_set_upper (adj, (gdouble) upper);
3999 gtk_adjustment_set_page_size (adj, (gdouble) pagesize);
4000 gtk_adjustment_set_value (adj, (gdouble) value);
4001 gtk_adjustment_set_page_increment (adj, (gdouble) page_increment);
4002 gtk_adjustment_set_step_increment (adj, (gdouble)
4004 gtk_adjustment_configure (adj
, (gdouble
) value
, (gdouble
) lower
,
4005 (gdouble
) upper
, (gdouble
) step_increment
,
4006 (gdouble
) page_increment
, (gdouble
) pagesize
);
4007 gtk_adjustment_changed (adj
);
4012 /* Return true if EVENT is for a scroll bar in frame F.
4013 When the same X window is used for several Gtk+ widgets, we cannot
4014 say for sure based on the X window alone if an event is for the
4015 frame. This function does additional checks. */
4018 xg_event_is_for_scrollbar (struct frame
*f
, const XEvent
*event
)
4022 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
4024 /* Check if press occurred outside the edit widget. */
4025 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
4028 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
4029 (gdk_display_get_device_manager (gdpy
));
4030 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
4032 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
4034 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
4037 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
4038 || event
->type
== MotionNotify
))
4040 /* If we are releasing or moving the scroll bar, it has the grab. */
4041 GtkWidget
*w
= gtk_grab_get_current ();
4042 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
4050 /***********************************************************************
4052 ***********************************************************************/
4053 /* The key for the data we put in the GtkImage widgets. The data is
4054 the image used by Emacs. We use this to see if we need to update
4055 the GtkImage with a new image. */
4056 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
4058 /* The key for storing the latest modifiers so the activate callback can
4060 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
4062 /* The key for storing the button widget in its proxy menu item. */
4063 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
4065 /* The key for the data we put in the GtkImage widgets. The data is
4066 the stock name used by Emacs. We use this to see if we need to update
4067 the GtkImage with a new image. */
4068 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
4070 /* As above, but this is used for named theme widgets, as opposed to
4072 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
4074 /* Callback function invoked when a tool bar item is pressed.
4075 W is the button widget in the tool bar that got pressed,
4076 CLIENT_DATA is an integer that is the index of the button in the
4077 tool bar. 0 is the first button. */
4080 xg_tool_bar_button_cb (GtkWidget
*widget
,
4081 GdkEventButton
*event
,
4084 intptr_t state
= event
->state
;
4085 gpointer ptr
= (gpointer
) state
;
4086 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
4091 /* Callback function invoked when a tool bar item is pressed.
4092 W is the button widget in the tool bar that got pressed,
4093 CLIENT_DATA is an integer that is the index of the button in the
4094 tool bar. 0 is the first button. */
4097 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
4099 intptr_t idx
= (intptr_t) client_data
;
4100 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
4101 intptr_t mod
= (intptr_t) gmod
;
4103 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4104 Lisp_Object key
, frame
;
4105 struct input_event event
;
4108 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4111 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4113 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
4114 XSETFRAME (frame
, f
);
4116 /* We generate two events here. The first one is to set the prefix
4117 to `(tool_bar)', see keyboard.c. */
4118 event
.kind
= TOOL_BAR_EVENT
;
4119 event
.frame_or_window
= frame
;
4121 kbd_buffer_store_event (&event
);
4123 event
.kind
= TOOL_BAR_EVENT
;
4124 event
.frame_or_window
= frame
;
4126 /* Convert between the modifier bits GDK uses and the modifier bits
4127 Emacs uses. This assumes GDK and X masks are the same, which they are when
4129 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), mod
);
4130 kbd_buffer_store_event (&event
);
4132 /* Return focus to the frame after we have clicked on a detached
4137 /* Callback function invoked when a tool bar item is pressed in a detached
4138 tool bar or the overflow drop down menu.
4139 We just call xg_tool_bar_callback.
4140 W is the menu item widget that got pressed,
4141 CLIENT_DATA is an integer that is the index of the button in the
4142 tool bar. 0 is the first button. */
4145 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
4147 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
4148 XG_TOOL_BAR_PROXY_BUTTON
));
4149 xg_tool_bar_callback (wbutton
, client_data
);
4154 xg_tool_bar_help_callback (GtkWidget
*w
,
4155 GdkEventCrossing
*event
,
4156 gpointer client_data
);
4158 /* This callback is called when a help is to be shown for an item in
4159 the detached tool bar when the detached tool bar it is not expanded. */
4162 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
4163 GdkEventCrossing
*event
,
4164 gpointer client_data
)
4166 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
4167 XG_TOOL_BAR_PROXY_BUTTON
));
4169 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
4173 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
4175 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
4176 GtkWidget
*c1
= clist
->data
;
4177 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
4179 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4180 g_list_free (clist
);
4181 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4185 /* This callback is called when a tool item should create a proxy item,
4186 such as for the overflow menu. Also called when the tool bar is detached.
4187 If we don't create a proxy menu item, the detached tool bar will be
4191 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
4193 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
4194 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4196 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
4197 GtkImage
*wimage
= GTK_IMAGE (c1
);
4198 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
4199 (wlbl
? gtk_label_get_text (wlbl
) : "");
4200 GtkWidget
*wmenuimage
;
4203 if (gtk_button_get_use_stock (wbutton
))
4204 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
4205 GTK_ICON_SIZE_MENU
);
4208 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
4209 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
4211 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
4213 if (store_type
== GTK_IMAGE_STOCK
)
4216 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
4217 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
4219 else if (store_type
== GTK_IMAGE_ICON_SET
)
4221 GtkIconSet
*icon_set
;
4222 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
4223 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
4224 GTK_ICON_SIZE_MENU
);
4226 else if (store_type
== GTK_IMAGE_PIXBUF
)
4231 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
4234 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
4236 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
4237 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
4238 GDK_INTERP_BILINEAR
);
4240 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
4244 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
4248 else if (store_type
== GTK_IMAGE_ICON_NAME
)
4250 const gchar
*icon_name
;
4251 GtkIconSize icon_size
;
4253 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
4254 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
4255 GTK_ICON_SIZE_MENU
);
4259 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
4264 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
4266 g_signal_connect (G_OBJECT (wmenuitem
),
4268 G_CALLBACK (xg_tool_bar_proxy_callback
),
4272 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
4273 (gpointer
) wbutton
);
4274 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
4275 gtk_widget_set_sensitive (wmenuitem
,
4276 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
4278 /* Use enter/leave notify to show help. We use the events
4279 rather than the GtkButton specific signals "enter" and
4280 "leave", so we can have only one callback. The event
4281 will tell us what kind of event it is. */
4282 g_signal_connect (G_OBJECT (wmenuitem
),
4283 "enter-notify-event",
4284 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4286 g_signal_connect (G_OBJECT (wmenuitem
),
4287 "leave-notify-event",
4288 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4294 /* This callback is called when a tool bar is detached. We must set
4295 the height of the tool bar to zero when this happens so frame sizes
4296 are correctly calculated.
4297 WBOX is the handle box widget that enables detach/attach of the tool bar.
4298 W is the tool bar widget.
4299 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4302 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
4304 gpointer client_data
)
4306 struct frame
*f
= client_data
;
4308 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
4313 GtkRequisition req
, req2
;
4315 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4316 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4317 req
.width
-= req2
.width
;
4318 req
.height
-= req2
.height
;
4319 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4320 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4321 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4322 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4323 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4324 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4325 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4326 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4327 xg_height_or_width_changed (f
);
4331 /* This callback is called when a tool bar is reattached. We must set
4332 the height of the tool bar when this happens so frame sizes
4333 are correctly calculated.
4334 WBOX is the handle box widget that enables detach/attach of the tool bar.
4335 W is the tool bar widget.
4336 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4339 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
4341 gpointer client_data
)
4343 struct frame
*f
= client_data
;
4344 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4348 GtkRequisition req
, req2
;
4350 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4351 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4352 req
.width
+= req2
.width
;
4353 req
.height
+= req2
.height
;
4354 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4355 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4356 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4357 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4358 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4359 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4360 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4361 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4362 xg_height_or_width_changed (f
);
4366 /* This callback is called when the mouse enters or leaves a tool bar item.
4367 It is used for displaying and hiding the help text.
4368 W is the tool bar item, a button.
4369 EVENT is either an enter event or leave event.
4370 CLIENT_DATA is an integer that is the index of the button in the
4371 tool bar. 0 is the first button.
4373 Returns FALSE to tell GTK to keep processing this event. */
4376 xg_tool_bar_help_callback (GtkWidget
*w
,
4377 GdkEventCrossing
*event
,
4378 gpointer client_data
)
4380 intptr_t idx
= (intptr_t) client_data
;
4381 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4382 Lisp_Object help
, frame
;
4384 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4387 if (event
->type
== GDK_ENTER_NOTIFY
)
4389 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4390 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4393 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4398 XSETFRAME (frame
, f
);
4399 kbd_buffer_store_help_event (frame
, help
);
4405 /* This callback is called when a tool bar item shall be redrawn.
4406 It modifies the expose event so that the GtkImage widget redraws the
4407 whole image. This to overcome a bug that makes GtkImage draw the image
4408 in the wrong place when it tries to redraw just a part of the image.
4409 W is the GtkImage to be redrawn.
4410 EVENT is the expose event for W.
4411 CLIENT_DATA is unused.
4413 Returns FALSE to tell GTK to keep processing this event. */
4417 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4418 GdkEventExpose
*event
,
4419 gpointer client_data
)
4423 gdk_drawable_get_size (event
->window
, &width
, &height
);
4424 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4425 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4427 event
->area
.x
= max (0, event
->area
.x
);
4428 event
->area
.y
= max (0, event
->area
.y
);
4430 event
->area
.width
= max (width
, event
->area
.width
);
4431 event
->area
.height
= max (height
, event
->area
.height
);
4437 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4438 #define toolbar_set_orientation(w, o) \
4439 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4441 #define toolbar_set_orientation(w, o) \
4442 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4445 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4446 #define TOOLBAR_TOP_WIDGET(x) ((x)->handlebox_widget)
4448 #define TOOLBAR_TOP_WIDGET(x) ((x)->toolbar_widget)
4451 /* Attach a tool bar to frame F. */
4454 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4456 struct x_output
*x
= f
->output_data
.x
;
4457 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4458 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4460 toolbar_set_orientation (x
->toolbar_widget
,
4462 ? GTK_ORIENTATION_VERTICAL
4463 : GTK_ORIENTATION_HORIZONTAL
);
4464 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4465 if (!x
->handlebox_widget
)
4467 top_widget
= x
->handlebox_widget
= gtk_handle_box_new ();
4468 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4469 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4470 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4471 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4472 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4479 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4480 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4483 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4486 if (EQ (pos
, Qleft
))
4487 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4490 x
->toolbar_in_hbox
= true;
4494 bool vbox_pos
= x
->menubar_widget
!= 0;
4495 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4496 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4499 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4503 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4506 x
->toolbar_in_hbox
= false;
4508 x
->toolbar_is_packed
= true;
4511 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4514 tb_size_cb (GtkWidget
*widget
,
4515 GdkRectangle
*allocation
,
4518 /* When tool bar is created it has one preferred size. But when size is
4519 allocated between widgets, it may get another. So we must update
4520 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4521 struct frame
*f
= user_data
;
4522 if (xg_update_tool_bar_sizes (f
))
4523 xg_height_or_width_changed (f
);
4526 /* Create a tool bar for frame F. */
4529 xg_create_tool_bar (struct frame
*f
)
4531 struct x_output
*x
= f
->output_data
.x
;
4532 #if GTK_CHECK_VERSION (3, 3, 6)
4533 GtkStyleContext
*gsty
;
4535 struct xg_frame_tb_info
*tbinfo
4536 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4540 tbinfo
= xmalloc (sizeof (*tbinfo
));
4541 tbinfo
->last_tool_bar
= Qnil
;
4542 tbinfo
->style
= Qnil
;
4543 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4544 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4545 tbinfo
->n_last_items
= 0;
4546 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4551 x
->toolbar_widget
= gtk_toolbar_new ();
4553 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4555 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4556 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4557 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4558 G_CALLBACK (tb_size_cb
), f
);
4559 #if GTK_CHECK_VERSION (3, 3, 6)
4560 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4561 gtk_style_context_add_class (gsty
, "primary-toolbar");
4566 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4568 /* Find the right-to-left image named by RTL in the tool bar images for F.
4569 Returns IMAGE if RTL is not found. */
4572 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4575 Lisp_Object file
, rtl_name
;
4576 struct gcpro gcpro1
, gcpro2
;
4577 GCPRO2 (file
, rtl_name
);
4579 rtl_name
= Ffile_name_nondirectory (rtl
);
4581 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4583 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4584 if (!NILP (file
= file_for_image (rtl_image
)))
4586 file
= call1 (intern ("file-name-sans-extension"),
4587 Ffile_name_nondirectory (file
));
4588 if (! NILP (Fequal (file
, rtl_name
)))
4599 static GtkToolItem
*
4600 xg_make_tool_item (struct frame
*f
,
4602 GtkWidget
**wbutton
,
4604 int i
, bool horiz
, bool text_image
)
4606 GtkToolItem
*ti
= gtk_tool_item_new ();
4607 GtkWidget
*vb
= gtk_box_new (horiz
4608 ? GTK_ORIENTATION_HORIZONTAL
4609 : GTK_ORIENTATION_VERTICAL
,
4611 GtkWidget
*wb
= gtk_button_new ();
4612 /* The eventbox is here so we can have tooltips on disabled items. */
4613 GtkWidget
*weventbox
= gtk_event_box_new ();
4614 #if GTK_CHECK_VERSION (3, 3, 6)
4615 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4616 GtkStyleContext
*gsty
;
4618 gtk_css_provider_load_from_data (css_prov
,
4620 " background-color: transparent;"
4624 gsty
= gtk_widget_get_style_context (weventbox
);
4625 gtk_style_context_add_provider (gsty
,
4626 GTK_STYLE_PROVIDER (css_prov
),
4627 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4628 g_object_unref (css_prov
);
4631 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4633 if (wimage
&& !text_image
)
4634 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4636 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4637 if (wimage
&& text_image
)
4638 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4640 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4641 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4642 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4643 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4644 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4646 if (wimage
|| label
)
4649 gpointer gi
= (gpointer
) ii
;
4651 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4652 G_CALLBACK (xg_tool_bar_menu_proxy
),
4655 g_signal_connect (G_OBJECT (wb
), "clicked",
4656 G_CALLBACK (xg_tool_bar_callback
),
4659 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4662 /* Catch expose events to overcome an annoying redraw bug, see
4663 comment for xg_tool_bar_item_expose_callback. */
4664 g_signal_connect (G_OBJECT (ti
),
4666 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4669 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4671 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4672 no distinction based on modifiers in the activate callback,
4673 so we have to do it ourselves. */
4674 g_signal_connect (wb
, "button-release-event",
4675 G_CALLBACK (xg_tool_bar_button_cb
),
4678 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4680 /* Use enter/leave notify to show help. We use the events
4681 rather than the GtkButton specific signals "enter" and
4682 "leave", so we can have only one callback. The event
4683 will tell us what kind of event it is. */
4684 g_signal_connect (G_OBJECT (weventbox
),
4685 "enter-notify-event",
4686 G_CALLBACK (xg_tool_bar_help_callback
),
4688 g_signal_connect (G_OBJECT (weventbox
),
4689 "leave-notify-event",
4690 G_CALLBACK (xg_tool_bar_help_callback
),
4694 if (wbutton
) *wbutton
= wb
;
4700 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4704 if (GTK_IS_BOX (vb
))
4706 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4707 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4708 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4712 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4718 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4719 const char *icon_name
, const struct image
*img
,
4720 const char *label
, bool horiz
)
4724 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4725 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4727 /* Check if the tool icon matches. */
4728 if (stock_name
&& wimage
)
4730 old
= g_object_get_data (G_OBJECT (wimage
),
4731 XG_TOOL_BAR_STOCK_NAME
);
4732 if (!old
|| strcmp (old
, stock_name
))
4735 else if (icon_name
&& wimage
)
4737 old
= g_object_get_data (G_OBJECT (wimage
),
4738 XG_TOOL_BAR_ICON_NAME
);
4739 if (!old
|| strcmp (old
, icon_name
))
4744 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4745 XG_TOOL_BAR_IMAGE_DATA
);
4746 Pixmap old_img
= (Pixmap
) gold_img
;
4747 if (old_img
!= img
->pixmap
)
4751 /* Check button configuration and label. */
4752 if (is_box_type (vb
, horiz
)
4753 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4756 /* Ensure label is correct. */
4758 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4763 xg_update_tool_bar_sizes (struct frame
*f
)
4765 struct x_output
*x
= f
->output_data
.x
;
4767 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4768 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4770 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4771 if (x
->toolbar_in_hbox
)
4774 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4776 "position", &pos
, NULL
);
4777 if (pos
== 0) nl
= req
.width
;
4778 else nr
= req
.width
;
4783 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4785 "position", &pos
, NULL
);
4786 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4787 else nb
= req
.height
;
4790 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4791 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4792 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4793 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4795 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4796 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4797 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4798 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4799 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4800 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4808 /* Update the tool bar for frame F. Add new buttons and remove old. */
4811 update_frame_tool_bar (struct frame
*f
)
4814 struct x_output
*x
= f
->output_data
.x
;
4815 int hmargin
= 0, vmargin
= 0;
4816 GtkToolbar
*wtoolbar
;
4818 GtkTextDirection dir
;
4820 bool text_image
, horiz
;
4821 struct xg_frame_tb_info
*tbinfo
;
4823 if (! FRAME_GTK_WIDGET (f
))
4828 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4830 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4831 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4833 else if (CONSP (Vtool_bar_button_margin
))
4835 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4836 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4838 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4839 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4842 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4843 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4844 i.e. zero. This means that margins less than
4845 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4846 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4847 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4849 if (! x
->toolbar_widget
)
4850 xg_create_tool_bar (f
);
4852 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4853 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4855 style
= Ftool_bar_get_system_style ();
4857 /* Are we up to date? */
4858 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4861 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4862 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4863 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4864 && tbinfo
->dir
== dir
4865 && ! NILP (Fequal (tbinfo
->style
, style
))
4866 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4872 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4873 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4874 tbinfo
->style
= style
;
4875 tbinfo
->hmargin
= hmargin
;
4876 tbinfo
->vmargin
= vmargin
;
4879 text_image
= EQ (style
, Qtext_image_horiz
);
4880 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4882 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4884 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4885 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4889 struct image
*img
= NULL
;
4891 Lisp_Object stock
= Qnil
;
4892 GtkStockItem stock_item
;
4893 char *stock_name
= NULL
;
4894 char *icon_name
= NULL
;
4896 GtkWidget
*wbutton
= NULL
;
4897 Lisp_Object specified_file
;
4898 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4900 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4901 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4902 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4905 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4907 /* If this is a separator, use a gtk separator item. */
4908 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4910 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4913 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4915 ti
= gtk_separator_tool_item_new ();
4916 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4922 /* Otherwise, the tool-bar item is an ordinary button. */
4924 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4926 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4930 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4932 /* Ignore invalid image specifications. */
4933 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4934 if (!valid_image_p (image
))
4937 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4942 specified_file
= file_for_image (image
);
4943 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4944 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4946 if (STRINGP (stock
))
4948 stock_name
= SSDATA (stock
);
4949 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4951 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4952 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4954 icon_name
= stock_name
+ 2;
4958 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4961 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4963 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4964 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4972 if (stock_name
== NULL
&& icon_name
== NULL
)
4974 /* No stock image, or stock item not known. Try regular
4975 image. If image is a vector, choose it according to the
4977 if (dir
== GTK_TEXT_DIR_RTL
4978 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4980 image
= find_rtl_image (f
, image
, rtl
);
4982 if (VECTORP (image
))
4986 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4987 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4990 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4991 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4993 eassert (ASIZE (image
) >= idx
);
4994 image
= AREF (image
, idx
);
4999 img_id
= lookup_image (f
, image
);
5000 img
= IMAGE_FROM_ID (f
, img_id
);
5001 prepare_image_for_display (f
, img
);
5003 if (img
->load_failed_p
|| img
->pixmap
== None
)
5006 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
5012 /* If there is an existing widget, check if it's stale; if so,
5013 remove it and make a new tool item from scratch. */
5014 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
5017 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
5026 /* Save the image so we can see if an update is needed the
5027 next time we call xg_tool_item_match_p. */
5028 if (EQ (style
, Qtext
))
5030 else if (stock_name
)
5032 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
5033 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
5034 (gpointer
) xstrdup (stock_name
),
5035 (GDestroyNotify
) xfree
);
5039 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
5040 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
5041 (gpointer
) xstrdup (icon_name
),
5042 (GDestroyNotify
) xfree
);
5046 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
5047 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
5048 (gpointer
)img
->pixmap
);
5051 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
5052 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
5053 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
5058 gtk_widget_set_sensitive (wbutton
, enabled_p
);
5062 /* Remove buttons not longer needed. */
5065 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
5067 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
5068 } while (ti
!= NULL
);
5070 if (f
->n_tool_bar_items
!= 0)
5072 if (! x
->toolbar_is_packed
)
5073 xg_pack_tool_bar (f
, FRAME_TOOL_BAR_POSITION (f
));
5074 gtk_widget_show_all (TOOLBAR_TOP_WIDGET (x
));
5075 if (xg_update_tool_bar_sizes (f
))
5076 xg_height_or_width_changed (f
);
5082 /* Deallocate all resources for the tool bar on frame F.
5083 Remove the tool bar. */
5086 free_frame_tool_bar (struct frame
*f
)
5088 struct x_output
*x
= f
->output_data
.x
;
5090 if (x
->toolbar_widget
)
5092 struct xg_frame_tb_info
*tbinfo
;
5093 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
5096 /* We may have created the toolbar_widget in xg_create_tool_bar, but
5097 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
5098 if (x
->toolbar_is_packed
)
5100 if (x
->toolbar_in_hbox
)
5101 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5104 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5108 gtk_widget_destroy (x
->toolbar_widget
);
5110 x
->toolbar_widget
= 0;
5111 TOOLBAR_TOP_WIDGET (x
) = 0;
5112 x
->toolbar_is_packed
= false;
5113 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
5114 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
5116 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5121 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5126 xg_height_or_width_changed (f
);
5133 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
5135 struct x_output
*x
= f
->output_data
.x
;
5136 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
5138 if (! x
->toolbar_widget
|| ! top_widget
)
5142 g_object_ref (top_widget
);
5143 if (x
->toolbar_is_packed
)
5145 if (x
->toolbar_in_hbox
)
5146 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5149 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5153 xg_pack_tool_bar (f
, pos
);
5154 g_object_unref (top_widget
);
5155 if (xg_update_tool_bar_sizes (f
))
5156 xg_height_or_width_changed (f
);
5163 /***********************************************************************
5165 ***********************************************************************/
5167 xg_initialize (void)
5169 GtkBindingSet
*binding_set
;
5170 GtkSettings
*settings
;
5173 /* Work around a bug with corrupted data if libXft gets unloaded. This way
5174 we keep it permanently linked in. */
5179 xg_ignore_gtk_scrollbar
= 0;
5180 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
5181 xg_detached_menus
= 0;
5183 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
5184 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
5186 id_to_widget
.max_size
= id_to_widget
.used
= 0;
5187 id_to_widget
.widgets
= 0;
5189 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
5190 (gdk_display_get_default ()));
5191 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5192 bindings. It doesn't seem to be any way to remove properties,
5193 so we set it to "" which in means "no key". */
5194 gtk_settings_set_string_property (settings
,
5195 "gtk-menu-bar-accel",
5199 /* Make GTK text input widgets use Emacs style keybindings. This is
5201 gtk_settings_set_string_property (settings
,
5202 "gtk-key-theme-name",
5206 /* Make dialogs close on C-g. Since file dialog inherits from
5207 dialog, this works for them also. */
5208 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
5209 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5212 /* Make menus close on C-g. */
5213 binding_set
= gtk_binding_set_by_class (g_type_class_ref
5214 (GTK_TYPE_MENU_SHELL
));
5215 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5217 update_theme_scrollbar_width ();
5218 update_theme_scrollbar_height ();
5220 #ifdef HAVE_FREETYPE
5221 x_last_font_name
= NULL
;
5225 #endif /* USE_GTK */