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
);
512 up
+= sprintf (up
, "\\%03o", p
[bytes_written
]);
513 p
+= bytes_written
+ 1;
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 // Only add tearoff if menu is empty.
2558 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wmenu
));
2561 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2562 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2564 g_signal_connect (G_OBJECT (tearoff
), "activate",
2565 G_CALLBACK (tearoff_activate
), 0);
2572 for (item
= data
; item
; item
= item
->next
)
2576 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2577 && !menu_separator_name_p (item
->name
))
2580 /* A title for a popup. We do the same as GTK does when
2581 creating titles, but it does not look good. */
2583 utf8_label
= get_utf8_string (item
->name
);
2585 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2586 w
= gtk_menu_item_new_with_label (utf8_label
);
2587 gtk_widget_set_sensitive (w
, FALSE
);
2588 if (utf8_label
) g_free (utf8_label
);
2590 else if (menu_separator_name_p (item
->name
))
2593 /* GTK only have one separator type. */
2594 w
= gtk_separator_menu_item_new ();
2598 w
= xg_create_one_menuitem (item
,
2600 item
->contents
? 0 : select_cb
,
2605 /* Create a possibly empty submenu for menu bar items, since some
2606 themes don't highlight items correctly without it. */
2607 if (item
->contents
|| menu_bar_p
)
2609 GtkWidget
*submenu
= create_menus (item
->contents
,
2620 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2624 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2625 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2631 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2632 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2633 with some text and buttons.
2634 F is the frame the created item belongs to.
2635 NAME is the name to use for the top widget.
2636 VAL is a widget_value structure describing items to be created.
2637 SELECT_CB is the callback to use when a menu item is selected or
2638 a dialog button is pressed.
2639 DEACTIVATE_CB is the callback to use when an item is deactivated.
2640 For a menu, when a sub menu is not shown anymore, for a dialog it is
2641 called when the dialog is popped down.
2642 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2644 Returns the widget created. */
2647 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2648 widget_value
*val
, GCallback select_cb
,
2649 GCallback deactivate_cb
, GCallback highlight_cb
)
2652 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2653 bool pop_up_p
= strcmp (type
, "popup") == 0;
2655 if (strcmp (type
, "dialog") == 0)
2657 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2658 xg_set_screen (w
, f
);
2659 gtk_window_set_transient_for (GTK_WINDOW (w
),
2660 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2661 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2662 gtk_widget_set_name (w
, "emacs-dialog");
2663 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2665 else if (menu_bar_p
|| pop_up_p
)
2667 w
= create_menus (val
->contents
,
2679 /* Set the cursor to an arrow for popup menus when they are mapped.
2680 This is done by default for menu bar menus. */
2683 /* Must realize so the GdkWindow inside the widget is created. */
2684 gtk_widget_realize (w
);
2685 xg_set_cursor (w
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
2690 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2697 /* Return the label for menu item WITEM. */
2700 xg_get_menu_item_label (GtkMenuItem
*witem
)
2702 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2703 return gtk_label_get_label (wlabel
);
2706 /* Return true if the menu item WITEM has the text LABEL. */
2709 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2712 char *utf8_label
= get_utf8_string (label
);
2713 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2715 if (! old_label
&& ! utf8_label
)
2717 else if (old_label
&& utf8_label
)
2718 is_same
= strcmp (utf8_label
, old_label
) == 0;
2720 if (utf8_label
) g_free (utf8_label
);
2725 /* Destroy widgets in LIST. */
2728 xg_destroy_widgets (GList
*list
)
2732 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2734 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2736 /* Destroying the widget will remove it from the container it is in. */
2737 gtk_widget_destroy (w
);
2741 /* Update the top level names in MENUBAR (i.e. not submenus).
2742 F is the frame the menu bar belongs to.
2743 *LIST is a list with the current menu bar names (menu item widgets).
2744 ITER is the item within *LIST that shall be updated.
2745 POS is the numerical position, starting at 0, of ITER in *LIST.
2746 VAL describes what the menu bar shall look like after the update.
2747 SELECT_CB is the callback to use when a menu item is selected.
2748 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2749 CL_DATA points to the callback data to be used for this menu bar.
2751 This function calls itself to walk through the menu bar names. */
2754 xg_update_menubar (GtkWidget
*menubar
,
2760 GCallback select_cb
,
2761 GCallback deactivate_cb
,
2762 GCallback highlight_cb
,
2763 xg_menu_cb_data
*cl_data
)
2765 if (! iter
&& ! val
)
2767 else if (iter
&& ! val
)
2769 /* Item(s) have been removed. Remove all remaining items. */
2770 xg_destroy_widgets (iter
);
2772 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2773 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2774 gtk_menu_item_new_with_label (""),
2780 else if (! iter
&& val
)
2782 /* Item(s) added. Add all new items in one call. */
2783 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2784 0, 1, 0, menubar
, cl_data
, 0);
2790 /* Below this neither iter or val is NULL */
2791 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2793 /* This item is still the same, check next item. */
2795 iter
= g_list_next (iter
);
2798 else /* This item is changed. */
2800 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2801 GtkMenuItem
*witem2
= 0;
2802 bool val_in_menubar
= 0;
2803 bool iter_in_new_menubar
= 0;
2807 /* See if the changed entry (val) is present later in the menu bar */
2809 iter2
&& ! val_in_menubar
;
2810 iter2
= g_list_next (iter2
))
2812 witem2
= GTK_MENU_ITEM (iter2
->data
);
2813 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2816 /* See if the current entry (iter) is present later in the
2817 specification for the new menu bar. */
2818 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2819 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2821 if (val_in_menubar
&& ! iter_in_new_menubar
)
2825 /* This corresponds to:
2830 g_object_ref (G_OBJECT (witem
));
2831 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2832 gtk_widget_destroy (GTK_WIDGET (witem
));
2834 /* Must get new list since the old changed. */
2835 g_list_free (*list
);
2836 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2837 while (nr
-- > 0) iter
= g_list_next (iter
);
2839 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2841 /* This corresponds to:
2844 Rename B to X. This might seem to be a strange thing to do,
2845 since if there is a menu under B it will be totally wrong for X.
2846 But consider editing a C file. Then there is a C-mode menu
2847 (corresponds to B above).
2848 If then doing C-x C-f the minibuf menu (X above) replaces the
2849 C-mode menu. When returning from the minibuffer, we get
2850 back the C-mode menu. Thus we do:
2851 Rename B to X (C-mode to minibuf menu)
2852 Rename X to B (minibuf to C-mode menu).
2853 If the X menu hasn't been invoked, the menu under B
2854 is up to date when leaving the minibuffer. */
2855 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2856 char *utf8_label
= get_utf8_string (val
->name
);
2857 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2859 /* GTK menu items don't notice when their labels have been
2860 changed from underneath them, so we have to explicitly
2861 use g_object_notify to tell listeners (e.g., a GMenuModel
2862 bridge that might be loaded) that the item's label has
2864 gtk_label_set_text (wlabel
, utf8_label
);
2865 g_object_notify (G_OBJECT (witem
), "label");
2867 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2868 /* If this item has a submenu that has been detached, change
2869 the title in the WM decorations also. */
2870 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2871 /* Set the title of the detached window. */
2872 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2875 if (utf8_label
) g_free (utf8_label
);
2876 iter
= g_list_next (iter
);
2880 else if (! val_in_menubar
&& iter_in_new_menubar
)
2882 /* This corresponds to:
2889 GtkWidget
*w
= xg_create_one_menuitem (val
,
2896 /* Create a possibly empty submenu for menu bar items, since some
2897 themes don't highlight items correctly without it. */
2898 GtkWidget
*submenu
= create_menus (NULL
, f
,
2899 select_cb
, deactivate_cb
,
2901 0, 0, 0, 0, cl_data
, 0);
2903 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2904 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2905 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2907 g_list_free (*list
);
2908 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2909 while (nr
-- > 0) iter
= g_list_next (iter
);
2910 iter
= g_list_next (iter
);
2914 else /* if (val_in_menubar && iter_in_new_menubar) */
2917 /* This corresponds to:
2922 g_object_ref (G_OBJECT (witem2
));
2923 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2924 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2925 GTK_WIDGET (witem2
), pos
);
2926 g_object_unref (G_OBJECT (witem2
));
2928 g_list_free (*list
);
2929 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2930 while (nr
-- > 0) iter
= g_list_next (iter
);
2931 if (iter
) iter
= g_list_next (iter
);
2937 /* Update the rest of the menu bar. */
2938 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2939 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2942 /* Update the menu item W so it corresponds to VAL.
2943 SELECT_CB is the callback to use when a menu item is selected.
2944 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2945 CL_DATA is the data to set in the widget for menu invocation. */
2948 xg_update_menu_item (widget_value
*val
,
2950 GCallback select_cb
,
2951 GCallback highlight_cb
,
2952 xg_menu_cb_data
*cl_data
)
2959 const char *old_label
= 0;
2960 const char *old_key
= 0;
2961 xg_menu_item_cb_data
*cb_data
;
2962 bool label_changed
= false;
2964 wchild
= XG_BIN_CHILD (w
);
2965 utf8_label
= get_utf8_string (val
->name
);
2966 utf8_key
= get_utf8_string (val
->key
);
2968 /* See if W is a menu item with a key. See make_menu_item above. */
2969 if (GTK_IS_BOX (wchild
))
2971 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2973 wlbl
= GTK_LABEL (list
->data
);
2974 wkey
= GTK_LABEL (list
->next
->data
);
2979 /* Remove the key and keep just the label. */
2980 g_object_ref (G_OBJECT (wlbl
));
2981 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2982 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2983 g_object_unref (G_OBJECT (wlbl
));
2988 else /* Just a label. */
2990 wlbl
= GTK_LABEL (wchild
);
2992 /* Check if there is now a key. */
2995 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2996 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2998 wlbl
= GTK_LABEL (list
->data
);
2999 wkey
= GTK_LABEL (list
->next
->data
);
3002 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3003 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3007 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3008 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3010 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3012 label_changed
= true;
3013 gtk_label_set_text (wkey
, utf8_key
);
3016 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3018 label_changed
= true;
3019 gtk_label_set_text (wlbl
, utf8_label
);
3022 if (utf8_key
) g_free (utf8_key
);
3023 if (utf8_label
) g_free (utf8_label
);
3025 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3026 gtk_widget_set_sensitive (w
, FALSE
);
3027 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3028 gtk_widget_set_sensitive (w
, TRUE
);
3030 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
3033 cb_data
->call_data
= val
->call_data
;
3034 cb_data
->help
= val
->help
;
3035 cb_data
->cl_data
= cl_data
;
3037 /* We assume the callback functions don't change. */
3038 if (val
->call_data
&& ! val
->contents
)
3040 /* This item shall have a select callback. */
3041 if (! cb_data
->select_id
)
3043 = g_signal_connect (G_OBJECT (w
), "activate",
3044 select_cb
, cb_data
);
3046 else if (cb_data
->select_id
)
3048 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3049 cb_data
->select_id
= 0;
3053 if (label_changed
) /* See comment in xg_update_menubar. */
3054 g_object_notify (G_OBJECT (w
), "label");
3057 /* Update the toggle menu item W so it corresponds to VAL. */
3060 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3062 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3065 /* Update the radio menu item W so it corresponds to VAL. */
3068 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3070 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3073 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3074 SUBMENU may be NULL, in that case a new menu is created.
3075 F is the frame the menu bar belongs to.
3076 VAL describes the contents of the menu bar.
3077 SELECT_CB is the callback to use when a menu item is selected.
3078 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3079 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3080 CL_DATA is the call back data to use for any newly created items.
3082 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3086 xg_update_submenu (GtkWidget
*submenu
,
3089 GCallback select_cb
,
3090 GCallback deactivate_cb
,
3091 GCallback highlight_cb
,
3092 xg_menu_cb_data
*cl_data
)
3094 GtkWidget
*newsub
= submenu
;
3098 GList
*first_radio
= 0;
3101 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3103 for (cur
= val
, iter
= list
;
3105 iter
= g_list_next (iter
), cur
= cur
->next
)
3107 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3109 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
3110 /* Skip tearoff items, they have no counterpart in val. */
3111 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
3113 iter
= g_list_next (iter
);
3114 if (iter
) w
= GTK_WIDGET (iter
->data
);
3119 /* Remember first radio button in a group. If we get a mismatch in
3120 a radio group we must rebuild the whole group so that the connections
3121 in GTK becomes correct. */
3122 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3124 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3125 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3128 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3130 if (! menu_separator_name_p (cur
->name
))
3133 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3135 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3137 xg_update_toggle_item (cur
, w
);
3138 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3140 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3142 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3144 xg_update_radio_item (cur
, w
);
3145 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3147 else if (GTK_IS_MENU_ITEM (w
))
3149 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3152 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3153 menu_separator_name_p (cur
->name
))
3156 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3158 sub
= gtk_menu_item_get_submenu (witem
);
3159 if (sub
&& ! cur
->contents
)
3161 /* Not a submenu anymore. */
3162 g_object_ref (G_OBJECT (sub
));
3163 remove_submenu (witem
);
3164 gtk_widget_destroy (sub
);
3166 else if (cur
->contents
)
3170 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3171 select_cb
, deactivate_cb
,
3172 highlight_cb
, cl_data
);
3174 /* If this item just became a submenu, we must set it. */
3176 gtk_menu_item_set_submenu (witem
, nsub
);
3181 /* Structural difference. Remove everything from here and down
3187 /* Remove widgets from first structural change. */
3190 /* If we are adding new menu items below, we must remove from
3191 first radio button so that radio groups become correct. */
3192 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3193 else xg_destroy_widgets (iter
);
3198 /* More items added. Create them. */
3199 newsub
= create_menus (cur
,
3212 if (list
) g_list_free (list
);
3217 /* Update the MENUBAR.
3218 F is the frame the menu bar belongs to.
3219 VAL describes the contents of the menu bar.
3220 If DEEP_P, rebuild all but the top level menu names in
3221 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3222 SELECT_CB is the callback to use when a menu item is selected.
3223 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3224 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3227 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3228 widget_value
*val
, bool deep_p
,
3229 GCallback select_cb
, GCallback deactivate_cb
,
3230 GCallback highlight_cb
)
3232 xg_menu_cb_data
*cl_data
;
3233 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3237 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3239 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3240 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3246 /* Update all sub menus.
3247 We must keep the submenus (GTK menu item widgets) since the
3248 X Window in the XEvent that activates the menu are those widgets. */
3250 /* Update cl_data, menu_item things in F may have changed. */
3251 update_cl_data (cl_data
, f
, highlight_cb
);
3253 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3258 GtkMenuItem
*witem
= 0;
3260 /* Find sub menu that corresponds to val and update it. */
3261 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3263 witem
= GTK_MENU_ITEM (iter
->data
);
3264 if (xg_item_label_same_p (witem
, cur
->name
))
3266 sub
= gtk_menu_item_get_submenu (witem
);
3271 newsub
= xg_update_submenu (sub
,
3278 /* sub may still be NULL. If we just updated non deep and added
3279 a new menu bar item, it has no sub menu yet. So we set the
3280 newly created sub menu under witem. */
3281 if (newsub
!= sub
&& witem
!= 0)
3283 xg_set_screen (newsub
, f
);
3284 gtk_menu_item_set_submenu (witem
, newsub
);
3290 gtk_widget_show_all (menubar
);
3293 /* Callback called when the menu bar W is mapped.
3294 Used to find the height of the menu bar if we didn't get it
3295 after showing the widget. */
3298 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3301 struct frame
*f
= user_data
;
3302 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3303 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3305 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3306 xg_height_or_width_changed (f
);
3310 /* Recompute all the widgets of frame F, when the menu bar has been
3314 xg_update_frame_menubar (struct frame
*f
)
3316 struct x_output
*x
= f
->output_data
.x
;
3319 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3322 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3323 return; /* Already done this, happens for frames created invisible. */
3327 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3329 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3331 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3332 gtk_widget_show_all (x
->menubar_widget
);
3333 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3335 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3337 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3338 xg_height_or_width_changed (f
);
3343 /* Get rid of the menu bar of frame F, and free its storage.
3344 This is used when deleting a frame, and when turning off the menu bar. */
3347 free_frame_menubar (struct frame
*f
)
3349 struct x_output
*x
= f
->output_data
.x
;
3351 if (x
->menubar_widget
)
3355 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3356 /* The menubar and its children shall be deleted when removed from
3358 x
->menubar_widget
= 0;
3359 FRAME_MENUBAR_HEIGHT (f
) = 0;
3360 xg_height_or_width_changed (f
);
3366 xg_event_is_for_menubar (struct frame
*f
, const XEvent
*event
)
3368 struct x_output
*x
= f
->output_data
.x
;
3377 if (! x
->menubar_widget
) return 0;
3379 if (! (event
->xbutton
.x
>= 0
3380 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3381 && event
->xbutton
.y
>= 0
3382 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
3383 && event
->xbutton
.same_screen
))
3386 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3387 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3389 gevent
.any
.window
= gw
;
3390 gevent
.any
.type
= GDK_NOTHING
;
3391 gwdesc
= gtk_get_event_widget (&gevent
);
3392 if (! gwdesc
) return 0;
3393 if (! GTK_IS_MENU_BAR (gwdesc
)
3394 && ! GTK_IS_MENU_ITEM (gwdesc
)
3395 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3398 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3399 if (! list
) return 0;
3400 rec
.x
= event
->xbutton
.x
;
3401 rec
.y
= event
->xbutton
.y
;
3405 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3407 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3408 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3417 /***********************************************************************
3418 Scroll bar functions
3419 ***********************************************************************/
3422 /* Setting scroll bar values invokes the callback. Use this variable
3423 to indicate that callback should do nothing. */
3425 bool xg_ignore_gtk_scrollbar
;
3427 /* Width and height of scroll bars for the current theme. */
3428 static int scroll_bar_width_for_theme
;
3429 static int scroll_bar_height_for_theme
;
3431 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3432 may be larger than 32 bits. Keep a mapping from integer index to widget
3433 pointers to get around the 32 bit limitation. */
3437 GtkWidget
**widgets
;
3442 /* Grow this much every time we need to allocate more */
3444 #define ID_TO_WIDGET_INCR 32
3446 /* Store the widget pointer W in id_to_widget and return the integer index. */
3449 xg_store_widget_in_map (GtkWidget
*w
)
3453 if (id_to_widget
.max_size
== id_to_widget
.used
)
3456 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3457 memory_full (SIZE_MAX
);
3459 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3460 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3461 new_size
, sizeof (GtkWidget
*));
3463 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3464 id_to_widget
.widgets
[i
] = 0;
3465 id_to_widget
.max_size
= new_size
;
3468 /* Just loop over the array and find a free place. After all,
3469 how many scroll bars are we creating? Should be a small number.
3470 The check above guarantees we will find a free place. */
3471 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3473 if (! id_to_widget
.widgets
[i
])
3475 id_to_widget
.widgets
[i
] = w
;
3476 ++id_to_widget
.used
;
3482 /* Should never end up here */
3486 /* Remove pointer at IDX from id_to_widget.
3487 Called when scroll bar is destroyed. */
3490 xg_remove_widget_from_map (ptrdiff_t idx
)
3492 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3494 id_to_widget
.widgets
[idx
] = 0;
3495 --id_to_widget
.used
;
3499 /* Get the widget pointer at IDX from id_to_widget. */
3502 xg_get_widget_from_map (ptrdiff_t idx
)
3504 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3505 return id_to_widget
.widgets
[idx
];
3511 update_theme_scrollbar_width (void)
3514 GtkAdjustment
*vadj
;
3521 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3522 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3523 g_object_ref_sink (G_OBJECT (wscroll
));
3524 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3525 gtk_widget_destroy (wscroll
);
3526 g_object_unref (G_OBJECT (wscroll
));
3529 scroll_bar_width_for_theme
= w
;
3533 update_theme_scrollbar_height (void)
3536 GtkAdjustment
*hadj
;
3543 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
, 0.1, 0.1, 0.1);
3544 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3545 g_object_ref_sink (G_OBJECT (wscroll
));
3546 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3547 gtk_widget_destroy (wscroll
);
3548 g_object_unref (G_OBJECT (wscroll
));
3551 scroll_bar_height_for_theme
= w
;
3555 xg_get_default_scrollbar_width (void)
3557 return scroll_bar_width_for_theme
;
3561 xg_get_default_scrollbar_height (void)
3563 /* Apparently there's no default height for themes. */
3564 return scroll_bar_width_for_theme
;
3567 /* Return the scrollbar id for X Window WID on display DPY.
3568 Return -1 if WID not in id_to_widget. */
3571 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3576 w
= xg_win_to_widget (dpy
, wid
);
3580 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3581 if (id_to_widget
.widgets
[idx
] == w
)
3588 /* Callback invoked when scroll bar WIDGET is destroyed.
3589 DATA is the index into id_to_widget for WIDGET.
3590 We free pointer to last scroll bar values here and remove the index. */
3593 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3595 intptr_t id
= (intptr_t) data
;
3596 xg_remove_widget_from_map (id
);
3599 /* Create a scroll bar widget for frame F. Store the scroll bar
3601 SCROLL_CALLBACK is the callback to invoke when the value of the
3603 END_CALLBACK is the callback to invoke when scrolling ends.
3604 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3605 to set resources for the widget. */
3608 xg_create_scroll_bar (struct frame
*f
,
3609 struct scroll_bar
*bar
,
3610 GCallback scroll_callback
,
3611 GCallback end_callback
,
3612 const char *scroll_bar_name
)
3618 GtkAdjustment
*vadj
;
3623 /* Page, step increment values are not so important here, they
3624 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3625 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3628 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3629 webox
= gtk_event_box_new ();
3630 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3632 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3634 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3636 scroll_id
= xg_store_widget_in_map (wscroll
);
3638 g_signal_connect (G_OBJECT (wscroll
),
3640 G_CALLBACK (xg_gtk_scroll_destroy
),
3641 (gpointer
) scroll_id
);
3642 g_signal_connect (G_OBJECT (wscroll
),
3646 g_signal_connect (G_OBJECT (wscroll
),
3647 "button-release-event",
3651 /* The scroll bar widget does not draw on a window of its own. Instead
3652 it draws on the parent window, in this case the edit widget. So
3653 whenever the edit widget is cleared, the scroll bar needs to redraw
3654 also, which causes flicker. Put an event box between the edit widget
3655 and the scroll bar, so the scroll bar instead draws itself on the
3656 event box window. */
3657 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3658 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3661 /* Set the cursor to an arrow. */
3662 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3664 bar
->x_window
= scroll_id
;
3665 bar
->horizontal
= 0;
3668 /* Create a horizontal scroll bar widget for frame F. Store the scroll
3669 bar in BAR. SCROLL_CALLBACK is the callback to invoke when the value
3670 of the bar changes. END_CALLBACK is the callback to invoke when
3671 scrolling ends. SCROLL_BAR_NAME is the name we use for the scroll
3672 bar. Can be used to set resources for the widget. */
3675 xg_create_horizontal_scroll_bar (struct frame
*f
,
3676 struct scroll_bar
*bar
,
3677 GCallback scroll_callback
,
3678 GCallback end_callback
,
3679 const char *scroll_bar_name
)
3685 GtkAdjustment
*hadj
;
3690 /* Page, step increment values are not so important here, they
3691 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3692 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
,
3695 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3696 webox
= gtk_event_box_new ();
3697 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3699 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3701 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3703 scroll_id
= xg_store_widget_in_map (wscroll
);
3705 g_signal_connect (G_OBJECT (wscroll
),
3707 G_CALLBACK (xg_gtk_scroll_destroy
),
3708 (gpointer
) scroll_id
);
3709 g_signal_connect (G_OBJECT (wscroll
),
3713 g_signal_connect (G_OBJECT (wscroll
),
3714 "button-release-event",
3718 /* The scroll bar widget does not draw on a window of its own. Instead
3719 it draws on the parent window, in this case the edit widget. So
3720 whenever the edit widget is cleared, the scroll bar needs to redraw
3721 also, which causes flicker. Put an event box between the edit widget
3722 and the scroll bar, so the scroll bar instead draws itself on the
3723 event box window. */
3724 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3725 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3728 /* Set the cursor to an arrow. */
3729 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3731 bar
->x_window
= scroll_id
;
3732 bar
->horizontal
= 1;
3735 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3738 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3740 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3743 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3744 gtk_widget_destroy (w
);
3745 gtk_widget_destroy (wparent
);
3746 SET_FRAME_GARBAGED (f
);
3750 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3752 TOP/LEFT are the new pixel positions where the bar shall appear.
3753 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3756 xg_update_scrollbar_pos (struct frame
*f
,
3757 ptrdiff_t scrollbar_id
,
3764 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3768 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3769 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3772 /* Clear out old position. */
3773 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3774 if (gtk_widget_get_parent (wparent
) == wfixed
)
3776 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3777 "x", &oldx
, "y", &oldy
, NULL
);
3778 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3781 /* Move and resize to new values. */
3782 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3783 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3786 /* No room. Hide scroll bar as some themes output a warning if
3787 the height is less than the min size. */
3788 gtk_widget_hide (wparent
);
3789 gtk_widget_hide (wscroll
);
3793 gtk_widget_show_all (wparent
);
3794 gtk_widget_set_size_request (wscroll
, width
, height
);
3796 gtk_widget_queue_draw (wfixed
);
3797 gdk_window_process_all_updates ();
3798 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3799 /* Clear under old scroll bar position. This must be done after
3800 the gtk_widget_queue_draw and gdk_window_process_all_updates
3802 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3803 oldx
, oldy
, oldw
, oldh
);
3805 /* GTK does not redraw until the main loop is entered again, but
3806 if there are no X events pending we will not enter it. So we sync
3807 here to get some events. */
3810 SET_FRAME_GARBAGED (f
);
3811 cancel_mouse_face (f
);
3816 /* Update the position of the horizontal scroll bar represented by SCROLLBAR_ID
3818 TOP/LEFT are the new pixel positions where the bar shall appear.
3819 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3822 xg_update_horizontal_scrollbar_pos (struct frame
*f
,
3823 ptrdiff_t scrollbar_id
,
3830 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3834 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3835 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3838 /* Clear out old position. */
3839 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3840 if (gtk_widget_get_parent (wparent
) == wfixed
)
3842 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3843 "x", &oldx
, "y", &oldy
, NULL
);
3844 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3847 /* Move and resize to new values. */
3848 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3849 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3852 /* No room. Hide scroll bar as some themes output a warning if
3853 the width is less than the min size. */
3854 gtk_widget_hide (wparent
);
3855 gtk_widget_hide (wscroll
);
3859 gtk_widget_show_all (wparent
);
3860 gtk_widget_set_size_request (wscroll
, width
, height
);
3862 gtk_widget_queue_draw (wfixed
);
3863 gdk_window_process_all_updates ();
3864 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3865 /* Clear under old scroll bar position. This must be done after
3866 the gtk_widget_queue_draw and gdk_window_process_all_updates
3868 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3869 oldx
, oldy
, oldw
, oldh
);
3871 /* GTK does not redraw until the main loop is entered again, but
3872 if there are no X events pending we will not enter it. So we sync
3873 here to get some events. */
3876 SET_FRAME_GARBAGED (f
);
3877 cancel_mouse_face (f
);
3882 /* Get the current value of the range, truncated to an integer. */
3885 int_gtk_range_get_value (GtkRange
*range
)
3887 return gtk_range_get_value (range
);
3891 /* Set the thumb size and position of scroll bar BAR. We are currently
3892 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3895 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3900 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3902 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3904 if (wscroll
&& bar
->dragging
== -1)
3914 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3916 if (scroll_bar_adjust_thumb_portion_p
)
3918 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3919 line rather than the real portion value. This makes the
3920 thumb less likely to resize and that looks better. */
3921 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3923 /* When the thumb is at the bottom, position == whole.
3924 So we need to increase `whole' to make space for the thumb. */
3932 top
= (gdouble
) position
/ whole
;
3933 shown
= (gdouble
) portion
/ whole
;
3936 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
3937 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
3939 /* Assume all lines are of equal size. */
3940 new_step
= size
/ max (1, FRAME_LINES (f
));
3942 old_size
= gtk_adjustment_get_page_size (adj
);
3943 if (old_size
!= size
)
3945 int old_step
= gtk_adjustment_get_step_increment (adj
);
3946 if (old_step
!= new_step
)
3948 gtk_adjustment_set_page_size (adj
, size
);
3949 gtk_adjustment_set_step_increment (adj
, new_step
);
3950 /* Assume a page increment is about 95% of the page size */
3951 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3956 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3960 /* gtk_range_set_value invokes the callback. Set
3961 ignore_gtk_scrollbar to make the callback do nothing */
3962 xg_ignore_gtk_scrollbar
= 1;
3964 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3965 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3967 gtk_adjustment_changed (adj
);
3969 xg_ignore_gtk_scrollbar
= 0;
3976 /* Set the thumb size and position of horizontal scroll bar BAR. We are
3977 currently displaying PORTION out of a whole WHOLE, and our position
3980 xg_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
3985 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3987 if (wscroll
&& bar
->dragging
== -1)
3991 int upper
= max (whole
- 1, 0);
3992 int pagesize
= min (upper
, max (portion
, 0));
3993 int value
= max (0, min (position
, upper
- pagesize
));
3994 /* These should be set to something more <portion, whole>
3996 int page_increment
= 4;
3997 int step_increment
= 1;
4000 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
4001 #if GTK_CHECK_VERSION (2, 3, 16)
4002 gtk_adjustment_configure (adj
, (gdouble
) value
, (gdouble
) lower
,
4003 (gdouble
) upper
, (gdouble
) step_increment
,
4004 (gdouble
) page_increment
, (gdouble
) pagesize
);
4006 gtk_adjustment_set_lower (adj
, (gdouble
) lower
);
4007 gtk_adjustment_set_upper (adj
, (gdouble
) upper
);
4008 gtk_adjustment_set_page_size (adj
, (gdouble
) pagesize
);
4009 gtk_adjustment_set_value (adj
, (gdouble
) value
);
4010 gtk_adjustment_set_page_increment (adj
, (gdouble
) page_increment
);
4011 gtk_adjustment_set_step_increment (adj
, (gdouble
) step_increment
);
4013 gtk_adjustment_changed (adj
);
4018 /* Return true if EVENT is for a scroll bar in frame F.
4019 When the same X window is used for several Gtk+ widgets, we cannot
4020 say for sure based on the X window alone if an event is for the
4021 frame. This function does additional checks. */
4024 xg_event_is_for_scrollbar (struct frame
*f
, const XEvent
*event
)
4028 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
4030 /* Check if press occurred outside the edit widget. */
4031 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
4034 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
4035 (gdk_display_get_device_manager (gdpy
));
4036 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
4038 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
4040 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
4043 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
4044 || event
->type
== MotionNotify
))
4046 /* If we are releasing or moving the scroll bar, it has the grab. */
4047 GtkWidget
*w
= gtk_grab_get_current ();
4048 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
4056 /***********************************************************************
4058 ***********************************************************************/
4059 /* The key for the data we put in the GtkImage widgets. The data is
4060 the image used by Emacs. We use this to see if we need to update
4061 the GtkImage with a new image. */
4062 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
4064 /* The key for storing the latest modifiers so the activate callback can
4066 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
4068 /* The key for storing the button widget in its proxy menu item. */
4069 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
4071 /* The key for the data we put in the GtkImage widgets. The data is
4072 the stock name used by Emacs. We use this to see if we need to update
4073 the GtkImage with a new image. */
4074 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
4076 /* As above, but this is used for named theme widgets, as opposed to
4078 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
4080 /* Callback function invoked when a tool bar item is pressed.
4081 W is the button widget in the tool bar that got pressed,
4082 CLIENT_DATA is an integer that is the index of the button in the
4083 tool bar. 0 is the first button. */
4086 xg_tool_bar_button_cb (GtkWidget
*widget
,
4087 GdkEventButton
*event
,
4090 intptr_t state
= event
->state
;
4091 gpointer ptr
= (gpointer
) state
;
4092 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
4097 /* Callback function invoked when a tool bar item is pressed.
4098 W is the button widget in the tool bar that got pressed,
4099 CLIENT_DATA is an integer that is the index of the button in the
4100 tool bar. 0 is the first button. */
4103 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
4105 intptr_t idx
= (intptr_t) client_data
;
4106 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
4107 intptr_t mod
= (intptr_t) gmod
;
4109 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4110 Lisp_Object key
, frame
;
4111 struct input_event event
;
4114 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4117 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4119 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
4120 XSETFRAME (frame
, f
);
4122 /* We generate two events here. The first one is to set the prefix
4123 to `(tool_bar)', see keyboard.c. */
4124 event
.kind
= TOOL_BAR_EVENT
;
4125 event
.frame_or_window
= frame
;
4127 kbd_buffer_store_event (&event
);
4129 event
.kind
= TOOL_BAR_EVENT
;
4130 event
.frame_or_window
= frame
;
4132 /* Convert between the modifier bits GDK uses and the modifier bits
4133 Emacs uses. This assumes GDK and X masks are the same, which they are when
4135 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), mod
);
4136 kbd_buffer_store_event (&event
);
4138 /* Return focus to the frame after we have clicked on a detached
4143 /* Callback function invoked when a tool bar item is pressed in a detached
4144 tool bar or the overflow drop down menu.
4145 We just call xg_tool_bar_callback.
4146 W is the menu item widget that got pressed,
4147 CLIENT_DATA is an integer that is the index of the button in the
4148 tool bar. 0 is the first button. */
4151 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
4153 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
4154 XG_TOOL_BAR_PROXY_BUTTON
));
4155 xg_tool_bar_callback (wbutton
, client_data
);
4160 xg_tool_bar_help_callback (GtkWidget
*w
,
4161 GdkEventCrossing
*event
,
4162 gpointer client_data
);
4164 /* This callback is called when a help is to be shown for an item in
4165 the detached tool bar when the detached tool bar it is not expanded. */
4168 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
4169 GdkEventCrossing
*event
,
4170 gpointer client_data
)
4172 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
4173 XG_TOOL_BAR_PROXY_BUTTON
));
4175 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
4179 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
4181 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
4182 GtkWidget
*c1
= clist
->data
;
4183 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
4185 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4186 g_list_free (clist
);
4187 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4191 /* This callback is called when a tool item should create a proxy item,
4192 such as for the overflow menu. Also called when the tool bar is detached.
4193 If we don't create a proxy menu item, the detached tool bar will be
4197 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
4199 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
4200 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4202 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
4203 GtkImage
*wimage
= GTK_IMAGE (c1
);
4204 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
4205 (wlbl
? gtk_label_get_text (wlbl
) : "");
4206 GtkWidget
*wmenuimage
;
4209 if (gtk_button_get_use_stock (wbutton
))
4210 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
4211 GTK_ICON_SIZE_MENU
);
4214 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
4215 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
4217 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
4219 if (store_type
== GTK_IMAGE_STOCK
)
4222 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
4223 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
4225 else if (store_type
== GTK_IMAGE_ICON_SET
)
4227 GtkIconSet
*icon_set
;
4228 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
4229 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
4230 GTK_ICON_SIZE_MENU
);
4232 else if (store_type
== GTK_IMAGE_PIXBUF
)
4237 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
4240 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
4242 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
4243 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
4244 GDK_INTERP_BILINEAR
);
4246 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
4250 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
4254 else if (store_type
== GTK_IMAGE_ICON_NAME
)
4256 const gchar
*icon_name
;
4257 GtkIconSize icon_size
;
4259 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
4260 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
4261 GTK_ICON_SIZE_MENU
);
4265 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
4270 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
4272 g_signal_connect (G_OBJECT (wmenuitem
),
4274 G_CALLBACK (xg_tool_bar_proxy_callback
),
4278 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
4279 (gpointer
) wbutton
);
4280 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
4281 gtk_widget_set_sensitive (wmenuitem
,
4282 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
4284 /* Use enter/leave notify to show help. We use the events
4285 rather than the GtkButton specific signals "enter" and
4286 "leave", so we can have only one callback. The event
4287 will tell us what kind of event it is. */
4288 g_signal_connect (G_OBJECT (wmenuitem
),
4289 "enter-notify-event",
4290 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4292 g_signal_connect (G_OBJECT (wmenuitem
),
4293 "leave-notify-event",
4294 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4300 /* This callback is called when a tool bar is detached. We must set
4301 the height of the tool bar to zero when this happens so frame sizes
4302 are correctly calculated.
4303 WBOX is the handle box widget that enables detach/attach of the tool bar.
4304 W is the tool bar widget.
4305 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4308 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
4310 gpointer client_data
)
4312 struct frame
*f
= client_data
;
4314 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
4319 GtkRequisition req
, req2
;
4321 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4322 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4323 req
.width
-= req2
.width
;
4324 req
.height
-= req2
.height
;
4325 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4326 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4327 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4328 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4329 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4330 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4331 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4332 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4333 xg_height_or_width_changed (f
);
4337 /* This callback is called when a tool bar is reattached. We must set
4338 the height of the tool bar when this happens so frame sizes
4339 are correctly calculated.
4340 WBOX is the handle box widget that enables detach/attach of the tool bar.
4341 W is the tool bar widget.
4342 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4345 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
4347 gpointer client_data
)
4349 struct frame
*f
= client_data
;
4350 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4354 GtkRequisition req
, req2
;
4356 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4357 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4358 req
.width
+= req2
.width
;
4359 req
.height
+= req2
.height
;
4360 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4361 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4362 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4363 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4364 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4365 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4366 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4367 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4368 xg_height_or_width_changed (f
);
4372 /* This callback is called when the mouse enters or leaves a tool bar item.
4373 It is used for displaying and hiding the help text.
4374 W is the tool bar item, a button.
4375 EVENT is either an enter event or leave event.
4376 CLIENT_DATA is an integer that is the index of the button in the
4377 tool bar. 0 is the first button.
4379 Returns FALSE to tell GTK to keep processing this event. */
4382 xg_tool_bar_help_callback (GtkWidget
*w
,
4383 GdkEventCrossing
*event
,
4384 gpointer client_data
)
4386 intptr_t idx
= (intptr_t) client_data
;
4387 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4388 Lisp_Object help
, frame
;
4390 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4393 if (event
->type
== GDK_ENTER_NOTIFY
)
4395 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4396 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4399 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4404 XSETFRAME (frame
, f
);
4405 kbd_buffer_store_help_event (frame
, help
);
4411 /* This callback is called when a tool bar item shall be redrawn.
4412 It modifies the expose event so that the GtkImage widget redraws the
4413 whole image. This to overcome a bug that makes GtkImage draw the image
4414 in the wrong place when it tries to redraw just a part of the image.
4415 W is the GtkImage to be redrawn.
4416 EVENT is the expose event for W.
4417 CLIENT_DATA is unused.
4419 Returns FALSE to tell GTK to keep processing this event. */
4423 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4424 GdkEventExpose
*event
,
4425 gpointer client_data
)
4429 gdk_drawable_get_size (event
->window
, &width
, &height
);
4430 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4431 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4433 event
->area
.x
= max (0, event
->area
.x
);
4434 event
->area
.y
= max (0, event
->area
.y
);
4436 event
->area
.width
= max (width
, event
->area
.width
);
4437 event
->area
.height
= max (height
, event
->area
.height
);
4443 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4444 #define toolbar_set_orientation(w, o) \
4445 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4447 #define toolbar_set_orientation(w, o) \
4448 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4451 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4452 #define TOOLBAR_TOP_WIDGET(x) ((x)->handlebox_widget)
4454 #define TOOLBAR_TOP_WIDGET(x) ((x)->toolbar_widget)
4457 /* Attach a tool bar to frame F. */
4460 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4462 struct x_output
*x
= f
->output_data
.x
;
4463 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4464 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4466 toolbar_set_orientation (x
->toolbar_widget
,
4468 ? GTK_ORIENTATION_VERTICAL
4469 : GTK_ORIENTATION_HORIZONTAL
);
4470 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4471 if (!x
->handlebox_widget
)
4473 top_widget
= x
->handlebox_widget
= gtk_handle_box_new ();
4474 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4475 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4476 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4477 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4478 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4485 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4486 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4489 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4492 if (EQ (pos
, Qleft
))
4493 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4496 x
->toolbar_in_hbox
= true;
4500 bool vbox_pos
= x
->menubar_widget
!= 0;
4501 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4502 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4505 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4509 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4512 x
->toolbar_in_hbox
= false;
4514 x
->toolbar_is_packed
= true;
4517 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4520 tb_size_cb (GtkWidget
*widget
,
4521 GdkRectangle
*allocation
,
4524 /* When tool bar is created it has one preferred size. But when size is
4525 allocated between widgets, it may get another. So we must update
4526 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4527 struct frame
*f
= user_data
;
4528 if (xg_update_tool_bar_sizes (f
))
4529 xg_height_or_width_changed (f
);
4532 /* Create a tool bar for frame F. */
4535 xg_create_tool_bar (struct frame
*f
)
4537 struct x_output
*x
= f
->output_data
.x
;
4538 #if GTK_CHECK_VERSION (3, 3, 6)
4539 GtkStyleContext
*gsty
;
4541 struct xg_frame_tb_info
*tbinfo
4542 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4546 tbinfo
= xmalloc (sizeof (*tbinfo
));
4547 tbinfo
->last_tool_bar
= Qnil
;
4548 tbinfo
->style
= Qnil
;
4549 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4550 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4551 tbinfo
->n_last_items
= 0;
4552 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4557 x
->toolbar_widget
= gtk_toolbar_new ();
4559 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4561 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4562 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4563 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4564 G_CALLBACK (tb_size_cb
), f
);
4565 #if GTK_CHECK_VERSION (3, 3, 6)
4566 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4567 gtk_style_context_add_class (gsty
, "primary-toolbar");
4572 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4574 /* Find the right-to-left image named by RTL in the tool bar images for F.
4575 Returns IMAGE if RTL is not found. */
4578 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4581 Lisp_Object file
, rtl_name
;
4582 struct gcpro gcpro1
, gcpro2
;
4583 GCPRO2 (file
, rtl_name
);
4585 rtl_name
= Ffile_name_nondirectory (rtl
);
4587 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4589 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4590 if (!NILP (file
= file_for_image (rtl_image
)))
4592 file
= call1 (intern ("file-name-sans-extension"),
4593 Ffile_name_nondirectory (file
));
4594 if (! NILP (Fequal (file
, rtl_name
)))
4605 static GtkToolItem
*
4606 xg_make_tool_item (struct frame
*f
,
4608 GtkWidget
**wbutton
,
4610 int i
, bool horiz
, bool text_image
)
4612 GtkToolItem
*ti
= gtk_tool_item_new ();
4613 GtkWidget
*vb
= gtk_box_new (horiz
4614 ? GTK_ORIENTATION_HORIZONTAL
4615 : GTK_ORIENTATION_VERTICAL
,
4617 GtkWidget
*wb
= gtk_button_new ();
4618 /* The eventbox is here so we can have tooltips on disabled items. */
4619 GtkWidget
*weventbox
= gtk_event_box_new ();
4620 #if GTK_CHECK_VERSION (3, 3, 6)
4621 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4622 GtkStyleContext
*gsty
;
4624 gtk_css_provider_load_from_data (css_prov
,
4626 " background-color: transparent;"
4630 gsty
= gtk_widget_get_style_context (weventbox
);
4631 gtk_style_context_add_provider (gsty
,
4632 GTK_STYLE_PROVIDER (css_prov
),
4633 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4634 g_object_unref (css_prov
);
4637 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4639 if (wimage
&& !text_image
)
4640 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4642 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4643 if (wimage
&& text_image
)
4644 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4646 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4647 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4648 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4649 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4650 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4652 if (wimage
|| label
)
4655 gpointer gi
= (gpointer
) ii
;
4657 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4658 G_CALLBACK (xg_tool_bar_menu_proxy
),
4661 g_signal_connect (G_OBJECT (wb
), "clicked",
4662 G_CALLBACK (xg_tool_bar_callback
),
4665 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4668 /* Catch expose events to overcome an annoying redraw bug, see
4669 comment for xg_tool_bar_item_expose_callback. */
4670 g_signal_connect (G_OBJECT (ti
),
4672 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4675 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4677 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4678 no distinction based on modifiers in the activate callback,
4679 so we have to do it ourselves. */
4680 g_signal_connect (wb
, "button-release-event",
4681 G_CALLBACK (xg_tool_bar_button_cb
),
4684 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4686 /* Use enter/leave notify to show help. We use the events
4687 rather than the GtkButton specific signals "enter" and
4688 "leave", so we can have only one callback. The event
4689 will tell us what kind of event it is. */
4690 g_signal_connect (G_OBJECT (weventbox
),
4691 "enter-notify-event",
4692 G_CALLBACK (xg_tool_bar_help_callback
),
4694 g_signal_connect (G_OBJECT (weventbox
),
4695 "leave-notify-event",
4696 G_CALLBACK (xg_tool_bar_help_callback
),
4700 if (wbutton
) *wbutton
= wb
;
4706 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4710 if (GTK_IS_BOX (vb
))
4712 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4713 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4714 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4718 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4724 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4725 const char *icon_name
, const struct image
*img
,
4726 const char *label
, bool horiz
)
4730 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4731 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4733 /* Check if the tool icon matches. */
4734 if (stock_name
&& wimage
)
4736 old
= g_object_get_data (G_OBJECT (wimage
),
4737 XG_TOOL_BAR_STOCK_NAME
);
4738 if (!old
|| strcmp (old
, stock_name
))
4741 else if (icon_name
&& wimage
)
4743 old
= g_object_get_data (G_OBJECT (wimage
),
4744 XG_TOOL_BAR_ICON_NAME
);
4745 if (!old
|| strcmp (old
, icon_name
))
4750 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4751 XG_TOOL_BAR_IMAGE_DATA
);
4752 Pixmap old_img
= (Pixmap
) gold_img
;
4753 if (old_img
!= img
->pixmap
)
4757 /* Check button configuration and label. */
4758 if (is_box_type (vb
, horiz
)
4759 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4762 /* Ensure label is correct. */
4764 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4769 xg_update_tool_bar_sizes (struct frame
*f
)
4771 struct x_output
*x
= f
->output_data
.x
;
4773 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4774 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4776 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4777 if (x
->toolbar_in_hbox
)
4780 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4782 "position", &pos
, NULL
);
4783 if (pos
== 0) nl
= req
.width
;
4784 else nr
= req
.width
;
4789 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4791 "position", &pos
, NULL
);
4792 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4793 else nb
= req
.height
;
4796 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4797 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4798 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4799 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4801 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4802 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4803 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4804 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4805 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4806 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4814 /* Update the tool bar for frame F. Add new buttons and remove old. */
4817 update_frame_tool_bar (struct frame
*f
)
4820 struct x_output
*x
= f
->output_data
.x
;
4821 int hmargin
= 0, vmargin
= 0;
4822 GtkToolbar
*wtoolbar
;
4824 GtkTextDirection dir
;
4826 bool text_image
, horiz
;
4827 struct xg_frame_tb_info
*tbinfo
;
4829 if (! FRAME_GTK_WIDGET (f
))
4834 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4836 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4837 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4839 else if (CONSP (Vtool_bar_button_margin
))
4841 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4842 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4844 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4845 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4848 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4849 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4850 i.e. zero. This means that margins less than
4851 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4852 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4853 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4855 if (! x
->toolbar_widget
)
4856 xg_create_tool_bar (f
);
4858 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4859 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4861 style
= Ftool_bar_get_system_style ();
4863 /* Are we up to date? */
4864 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4867 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4868 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4869 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4870 && tbinfo
->dir
== dir
4871 && ! NILP (Fequal (tbinfo
->style
, style
))
4872 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4878 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4879 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4880 tbinfo
->style
= style
;
4881 tbinfo
->hmargin
= hmargin
;
4882 tbinfo
->vmargin
= vmargin
;
4885 text_image
= EQ (style
, Qtext_image_horiz
);
4886 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4888 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4890 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4891 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4895 struct image
*img
= NULL
;
4897 Lisp_Object stock
= Qnil
;
4898 GtkStockItem stock_item
;
4899 char *stock_name
= NULL
;
4900 char *icon_name
= NULL
;
4902 GtkWidget
*wbutton
= NULL
;
4903 Lisp_Object specified_file
;
4904 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4906 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4907 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4908 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4911 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4913 /* If this is a separator, use a gtk separator item. */
4914 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4916 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4919 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4921 ti
= gtk_separator_tool_item_new ();
4922 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4928 /* Otherwise, the tool-bar item is an ordinary button. */
4930 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4932 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4936 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4938 /* Ignore invalid image specifications. */
4939 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4940 if (!valid_image_p (image
))
4943 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4948 specified_file
= file_for_image (image
);
4949 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4950 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4952 if (STRINGP (stock
))
4954 stock_name
= SSDATA (stock
);
4955 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4957 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4958 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4960 icon_name
= stock_name
+ 2;
4964 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4967 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4969 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4970 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4978 if (stock_name
== NULL
&& icon_name
== NULL
)
4980 /* No stock image, or stock item not known. Try regular
4981 image. If image is a vector, choose it according to the
4983 if (dir
== GTK_TEXT_DIR_RTL
4984 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4986 image
= find_rtl_image (f
, image
, rtl
);
4988 if (VECTORP (image
))
4992 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4993 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4996 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4997 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4999 eassert (ASIZE (image
) >= idx
);
5000 image
= AREF (image
, idx
);
5005 img_id
= lookup_image (f
, image
);
5006 img
= IMAGE_FROM_ID (f
, img_id
);
5007 prepare_image_for_display (f
, img
);
5009 if (img
->load_failed_p
|| img
->pixmap
== None
)
5012 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
5018 /* If there is an existing widget, check if it's stale; if so,
5019 remove it and make a new tool item from scratch. */
5020 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
5023 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
5032 /* Save the image so we can see if an update is needed the
5033 next time we call xg_tool_item_match_p. */
5034 if (EQ (style
, Qtext
))
5036 else if (stock_name
)
5038 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
5039 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
5040 (gpointer
) xstrdup (stock_name
),
5041 (GDestroyNotify
) xfree
);
5045 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
5046 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
5047 (gpointer
) xstrdup (icon_name
),
5048 (GDestroyNotify
) xfree
);
5052 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
5053 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
5054 (gpointer
)img
->pixmap
);
5057 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
5058 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
5059 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
5064 gtk_widget_set_sensitive (wbutton
, enabled_p
);
5068 /* Remove buttons not longer needed. */
5071 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
5073 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
5074 } while (ti
!= NULL
);
5076 if (f
->n_tool_bar_items
!= 0)
5078 if (! x
->toolbar_is_packed
)
5079 xg_pack_tool_bar (f
, FRAME_TOOL_BAR_POSITION (f
));
5080 gtk_widget_show_all (TOOLBAR_TOP_WIDGET (x
));
5081 if (xg_update_tool_bar_sizes (f
))
5082 xg_height_or_width_changed (f
);
5088 /* Deallocate all resources for the tool bar on frame F.
5089 Remove the tool bar. */
5092 free_frame_tool_bar (struct frame
*f
)
5094 struct x_output
*x
= f
->output_data
.x
;
5096 if (x
->toolbar_widget
)
5098 struct xg_frame_tb_info
*tbinfo
;
5099 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
5102 /* We may have created the toolbar_widget in xg_create_tool_bar, but
5103 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
5104 if (x
->toolbar_is_packed
)
5106 if (x
->toolbar_in_hbox
)
5107 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5110 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5114 gtk_widget_destroy (x
->toolbar_widget
);
5116 x
->toolbar_widget
= 0;
5117 TOOLBAR_TOP_WIDGET (x
) = 0;
5118 x
->toolbar_is_packed
= false;
5119 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
5120 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
5122 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5127 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5132 xg_height_or_width_changed (f
);
5139 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
5141 struct x_output
*x
= f
->output_data
.x
;
5142 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
5144 if (! x
->toolbar_widget
|| ! top_widget
)
5148 g_object_ref (top_widget
);
5149 if (x
->toolbar_is_packed
)
5151 if (x
->toolbar_in_hbox
)
5152 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5155 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5159 xg_pack_tool_bar (f
, pos
);
5160 g_object_unref (top_widget
);
5161 if (xg_update_tool_bar_sizes (f
))
5162 xg_height_or_width_changed (f
);
5169 /***********************************************************************
5171 ***********************************************************************/
5173 xg_initialize (void)
5175 GtkBindingSet
*binding_set
;
5176 GtkSettings
*settings
;
5179 /* Work around a bug with corrupted data if libXft gets unloaded. This way
5180 we keep it permanently linked in. */
5185 xg_ignore_gtk_scrollbar
= 0;
5186 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
5187 xg_detached_menus
= 0;
5189 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
5190 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
5192 id_to_widget
.max_size
= id_to_widget
.used
= 0;
5193 id_to_widget
.widgets
= 0;
5195 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
5196 (gdk_display_get_default ()));
5197 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5198 bindings. It doesn't seem to be any way to remove properties,
5199 so we set it to "" which in means "no key". */
5200 gtk_settings_set_string_property (settings
,
5201 "gtk-menu-bar-accel",
5205 /* Make GTK text input widgets use Emacs style keybindings. This is
5207 gtk_settings_set_string_property (settings
,
5208 "gtk-key-theme-name",
5212 /* Make dialogs close on C-g. Since file dialog inherits from
5213 dialog, this works for them also. */
5214 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
5215 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5218 /* Make menus close on C-g. */
5219 binding_set
= gtk_binding_set_by_class (g_type_class_ref
5220 (GTK_TYPE_MENU_SHELL
));
5221 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5223 update_theme_scrollbar_width ();
5224 update_theme_scrollbar_height ();
5226 #ifdef HAVE_FREETYPE
5227 x_last_font_name
= NULL
;
5231 #endif /* USE_GTK */