1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2012 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/>. */
29 #include "blockinput.h"
30 #include "syssignal.h"
33 #include "termhooks.h"
37 #include <gdk/gdkkeysyms.h>
38 #include "xsettings.h"
41 #include <X11/Xft/Xft.h>
46 #include "emacsgtkfixed.h"
49 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
50 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
52 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
53 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
55 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
56 #define gtk_widget_set_has_window(w, b) \
57 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
59 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
60 #define gtk_dialog_get_action_area(w) ((w)->action_area)
61 #define gtk_dialog_get_content_area(w) ((w)->vbox)
63 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
64 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
66 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
67 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
68 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
69 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
70 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
72 #if GTK_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 11
73 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
75 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
78 #if GTK_MAJOR_VERSION < 3 || \
79 (GTK_MAJOR_VERSION == 3 && GTK_MINOR_VERSION < 2)
80 #define gtk_font_chooser_dialog_new(x, y) \
81 gtk_font_selection_dialog_new (x)
82 #undef GTK_FONT_CHOOSER
83 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
84 #define gtk_font_chooser_set_font(x, y) \
85 gtk_font_selection_dialog_set_font_name (x, y)
86 #define gtk_font_chooser_get_font(x) \
87 gtk_font_selection_dialog_get_font_name (x)
91 #ifdef USE_GTK_TOOLTIP
92 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
94 #define gdk_window_get_geometry(w, a, b, c, d) \
95 gdk_window_get_geometry (w, a, b, c, d, 0)
96 #define gdk_x11_window_lookup_for_display(d, w) \
97 gdk_xid_table_lookup_for_display (d, w)
98 #define gtk_box_new(ori, spacing) \
99 ((ori) == GTK_ORIENTATION_HORIZONTAL \
100 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
101 #define gtk_scrollbar_new(ori, spacing) \
102 ((ori) == GTK_ORIENTATION_HORIZONTAL \
103 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
105 #define GDK_KEY_g GDK_g
107 #endif /* HAVE_GTK3 */
109 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
111 static void update_theme_scrollbar_width (void);
114 /***********************************************************************
115 Display handling functions
116 ***********************************************************************/
118 /* Keep track of the default display, or NULL if there is none. Emacs
119 may close all its displays. */
121 static GdkDisplay
*gdpy_def
;
123 /* When the GTK widget W is to be created on a display for F that
124 is not the default display, set the display for W.
125 W can be a GtkMenu or a GtkWindow widget. */
128 xg_set_screen (GtkWidget
*w
, FRAME_PTR f
)
130 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
132 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
133 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
136 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
138 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
143 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
144 *DPY is set to NULL if the display can't be opened.
146 Returns non-zero if display could be opened, zero if display could not
147 be opened, and less than zero if the GTK version doesn't support
148 multiple displays. */
151 xg_display_open (char *display_name
, Display
**dpy
)
155 gdpy
= gdk_display_open (display_name
);
156 if (!gdpy_def
&& gdpy
)
159 gdk_display_manager_set_default_display (gdk_display_manager_get (),
163 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
167 /* Close display DPY. */
170 xg_display_close (Display
*dpy
)
172 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
174 /* If this is the default display, try to change it before closing.
175 If there is no other display to use, gdpy_def is set to NULL, and
176 the next call to xg_display_open resets the default display. */
177 if (gdk_display_get_default () == gdpy
)
179 struct x_display_info
*dpyinfo
;
180 GdkDisplay
*gdpy_new
= NULL
;
182 /* Find another display. */
183 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
184 if (dpyinfo
->display
!= dpy
)
186 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
187 gdk_display_manager_set_default_display (gdk_display_manager_get (),
194 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
195 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
196 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
197 can continue running, but there will be memory leaks. */
198 g_object_run_dispose (G_OBJECT (gdpy
));
200 /* This seems to be fixed in GTK 2.10. */
201 gdk_display_close (gdpy
);
206 /***********************************************************************
208 ***********************************************************************/
209 /* The next two variables and functions are taken from lwlib. */
210 static widget_value
*widget_value_free_list
;
211 static int malloc_cpt
;
213 /* Allocate a widget_value structure, either by taking one from the
214 widget_value_free_list or by malloc:ing a new one.
216 Return a pointer to the allocated structure. */
219 malloc_widget_value (void)
222 if (widget_value_free_list
)
224 wv
= widget_value_free_list
;
225 widget_value_free_list
= wv
->free_list
;
230 wv
= xmalloc (sizeof *wv
);
233 memset (wv
, 0, sizeof (widget_value
));
237 /* This is analogous to free. It frees only what was allocated
238 by malloc_widget_value, and no substructures. */
241 free_widget_value (widget_value
*wv
)
248 /* When the number of already allocated cells is too big,
255 wv
->free_list
= widget_value_free_list
;
256 widget_value_free_list
= wv
;
261 /* Create and return the cursor to be used for popup menus and
262 scroll bars on display DPY. */
265 xg_create_default_cursor (Display
*dpy
)
267 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
268 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
272 xg_get_pixbuf_from_pixmap (FRAME_PTR f
, Pixmap pix
)
277 unsigned int width
, height
, uunused
;
280 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
281 &width
, &height
, &uunused
, &uunused
);
283 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
287 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
300 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
303 xg_get_pixbuf_from_pix_and_mask (FRAME_PTR f
,
308 GdkPixbuf
*icon_buf
, *tmp_buf
;
310 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
311 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
312 g_object_unref (G_OBJECT (tmp_buf
));
314 width
= gdk_pixbuf_get_width (icon_buf
);
315 height
= gdk_pixbuf_get_height (icon_buf
);
319 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
320 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
321 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
322 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
323 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
326 for (y
= 0; y
< height
; ++y
)
328 guchar
*iconptr
, *maskptr
;
331 iconptr
= pixels
+ y
* rowstride
;
332 maskptr
= mask_pixels
+ y
* mask_rowstride
;
334 for (x
= 0; x
< width
; ++x
)
336 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
337 just R is sufficient. */
339 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
341 iconptr
+= rowstride
/width
;
342 maskptr
+= mask_rowstride
/width
;
346 g_object_unref (G_OBJECT (mask_buf
));
353 file_for_image (Lisp_Object image
)
355 Lisp_Object specified_file
= Qnil
;
358 for (tail
= XCDR (image
);
359 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
360 tail
= XCDR (XCDR (tail
)))
361 if (EQ (XCAR (tail
), QCfile
))
362 specified_file
= XCAR (XCDR (tail
));
364 return specified_file
;
367 /* For the image defined in IMG, make and return a GtkImage. For displays with
368 8 planes or less we must make a GdkPixbuf and apply the mask manually.
369 Otherwise the highlighting and dimming the tool bar code in GTK does
370 will look bad. For display with more than 8 planes we just use the
371 pixmap and mask directly. For monochrome displays, GTK doesn't seem
372 able to use external pixmaps, it looks bad whatever we do.
373 The image is defined on the display where frame F is.
374 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
375 If OLD_WIDGET is NULL, a new widget is constructed and returned.
376 If OLD_WIDGET is not NULL, that widget is modified. */
379 xg_get_image_for_pixmap (FRAME_PTR f
,
382 GtkImage
*old_widget
)
386 /* If we have a file, let GTK do all the image handling.
387 This seems to be the only way to make insensitive and activated icons
388 look good in all cases. */
389 Lisp_Object specified_file
= file_for_image (img
->spec
);
392 /* We already loaded the image once before calling this
393 function, so this only fails if the image file has been removed.
394 In that case, use the pixmap already loaded. */
396 if (STRINGP (specified_file
)
397 && STRINGP (file
= x_find_image_file (specified_file
)))
400 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
402 gtk_image_set_from_file (old_widget
, SSDATA (file
));
404 return GTK_WIDGET (old_widget
);
407 /* No file, do the image handling ourselves. This will look very bad
408 on a monochrome display, and sometimes bad on all displays with
411 /* This is a workaround to make icons look good on pseudo color
412 displays. Apparently GTK expects the images to have an alpha
413 channel. If they don't, insensitive and activated icons will
414 look bad. This workaround does not work on monochrome displays,
415 and is strictly not needed on true color/static color displays (i.e.
416 16 bits and higher). But we do it anyway so we get a pixbuf that is
417 not associated with the img->pixmap. The img->pixmap may be removed
418 by clearing the image cache and then the tool bar redraw fails, since
419 Gtk+ assumes the pixmap is always there. */
420 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
425 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
427 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
429 g_object_unref (G_OBJECT (icon_buf
));
432 return GTK_WIDGET (old_widget
);
436 /* Set CURSOR on W and all widgets W contain. We must do like this
437 for scroll bars and menu because they create widgets internally,
438 and it is those widgets that are visible. */
441 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
443 GdkWindow
*window
= gtk_widget_get_window (w
);
444 GList
*children
= gdk_window_peek_children (window
);
446 gdk_window_set_cursor (window
, cursor
);
448 /* The scroll bar widget has more than one GDK window (had to look at
449 the source to figure this out), and there is no way to set cursor
450 on widgets in GTK. So we must set the cursor for all GDK windows.
453 for ( ; children
; children
= g_list_next (children
))
454 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
457 /* Insert NODE into linked LIST. */
460 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
462 xg_list_node
*list_start
= list
->next
;
464 if (list_start
) list_start
->prev
= node
;
465 node
->next
= list_start
;
470 /* Remove NODE from linked LIST. */
473 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
475 xg_list_node
*list_start
= list
->next
;
476 if (node
== list_start
)
478 list
->next
= node
->next
;
479 if (list
->next
) list
->next
->prev
= 0;
483 node
->prev
->next
= node
->next
;
484 if (node
->next
) node
->next
->prev
= node
->prev
;
488 /* Allocate and return a utf8 version of STR. If STR is already
489 utf8 or NULL, just return a copy of STR.
490 A new string is allocated and the caller must free the result
494 get_utf8_string (const char *str
)
498 if (!str
) return NULL
;
500 /* If not UTF-8, try current locale. */
501 if (!g_utf8_validate (str
, -1, NULL
))
502 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
504 return g_strdup (str
);
508 /* Probably some control characters in str. Escape them. */
510 ptrdiff_t nr_bad
= 0;
513 unsigned char *p
= (unsigned char *)str
;
517 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
518 &bytes_written
, &err
))
519 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
522 p
+= bytes_written
+1;
535 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
536 memory_full (SIZE_MAX
);
537 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
538 p
= (unsigned char *)str
;
540 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
541 &bytes_written
, &err
))
542 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
544 memcpy (up
, p
, bytes_written
);
545 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
546 up
+= bytes_written
+4;
547 p
+= bytes_written
+1;
554 strcat (utf8_str
, cp
);
566 /* Check for special colors used in face spec for region face.
567 The colors are fetched from the Gtk+ theme.
568 Return 1 if color was found, 0 if not. */
571 xg_check_special_colors (struct frame
*f
,
572 const char *color_name
,
576 int get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
577 int get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
579 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
585 GtkStyleContext
*gsty
586 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
588 char buf
[sizeof "rgbi://" + 3 * (DBL_MAX_10_EXP
+ sizeof "-1.000000" - 1)];
589 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
591 gtk_style_context_get_color (gsty
, state
, &col
);
593 gtk_style_context_get_background_color (gsty
, state
, &col
);
595 sprintf (buf
, "rgbi:%lf/%lf/%lf", col
.red
, col
.green
, col
.blue
);
596 success_p
= XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
599 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
600 GdkColor
*grgb
= get_bg
601 ? &gsty
->bg
[GTK_STATE_SELECTED
]
602 : &gsty
->fg
[GTK_STATE_SELECTED
];
604 color
->red
= grgb
->red
;
605 color
->green
= grgb
->green
;
606 color
->blue
= grgb
->blue
;
607 color
->pixel
= grgb
->pixel
;
618 /***********************************************************************
620 ***********************************************************************/
621 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
622 We use that to pop down the tooltip. This happens if Gtk+ for some
623 reason wants to change or hide the tooltip. */
625 #ifdef USE_GTK_TOOLTIP
628 hierarchy_ch_cb (GtkWidget
*widget
,
629 GtkWidget
*previous_toplevel
,
632 FRAME_PTR f
= (FRAME_PTR
) user_data
;
633 struct x_output
*x
= f
->output_data
.x
;
634 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
636 if (! top
|| ! GTK_IS_WINDOW (top
))
637 gtk_widget_hide (previous_toplevel
);
640 /* Callback called when Gtk+ thinks a tooltip should be displayed.
641 We use it to get the tooltip window and the tooltip widget so
642 we can manipulate the ourselves.
644 Return FALSE ensures that the tooltip is not shown. */
647 qttip_cb (GtkWidget
*widget
,
650 gboolean keyboard_mode
,
654 FRAME_PTR f
= (FRAME_PTR
) user_data
;
655 struct x_output
*x
= f
->output_data
.x
;
656 if (x
->ttip_widget
== NULL
)
661 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
662 x
->ttip_widget
= tooltip
;
663 g_object_ref (G_OBJECT (tooltip
));
664 x
->ttip_lbl
= gtk_label_new ("");
665 g_object_ref (G_OBJECT (x
->ttip_lbl
));
666 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
667 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
669 /* Change stupid Gtk+ default line wrapping. */
670 p
= gtk_widget_get_parent (x
->ttip_lbl
);
671 list
= gtk_container_get_children (GTK_CONTAINER (p
));
672 for (iter
= list
; iter
; iter
= g_list_next (iter
))
674 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
675 if (GTK_IS_LABEL (w
))
676 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
680 /* ATK needs an empty title for some reason. */
681 gtk_window_set_title (x
->ttip_window
, "");
682 /* Realize so we can safely get screen later on. */
683 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
684 gtk_widget_realize (x
->ttip_lbl
);
686 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
687 G_CALLBACK (hierarchy_ch_cb
), f
);
692 #endif /* USE_GTK_TOOLTIP */
694 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
695 Return zero if no system tooltip available, non-zero otherwise. */
698 xg_prepare_tooltip (FRAME_PTR f
,
703 #ifndef USE_GTK_TOOLTIP
706 struct x_output
*x
= f
->output_data
.x
;
710 GtkSettings
*settings
;
711 gboolean tt_enabled
= TRUE
;
713 Lisp_Object encoded_string
;
715 if (!x
->ttip_lbl
) return 0;
718 encoded_string
= ENCODE_UTF_8 (string
);
719 widget
= GTK_WIDGET (x
->ttip_lbl
);
720 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
721 screen
= gdk_window_get_screen (gwin
);
722 settings
= gtk_settings_get_for_screen (screen
);
723 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
726 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
727 /* Record that we disabled it so it can be enabled again. */
728 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
732 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
733 g_object_set_data (G_OBJECT
734 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
735 "gdk-display-current-tooltip", NULL
);
737 /* Put our dummy widget in so we can get callbacks for unrealize and
738 hierarchy-changed. */
739 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
740 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
741 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
742 if (width
) *width
= req
.width
;
743 if (height
) *height
= req
.height
;
748 #endif /* USE_GTK_TOOLTIP */
751 /* Show the tooltip at ROOT_X and ROOT_Y.
752 xg_prepare_tooltip must have been called before this function. */
755 xg_show_tooltip (FRAME_PTR f
, int root_x
, int root_y
)
757 #ifdef USE_GTK_TOOLTIP
758 struct x_output
*x
= f
->output_data
.x
;
762 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
763 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
769 /* Hide tooltip if shown. Do nothing if not shown.
770 Return non-zero if tip was hidden, non-zero if not (i.e. not using
774 xg_hide_tooltip (FRAME_PTR f
)
777 #ifdef USE_GTK_TOOLTIP
778 if (f
->output_data
.x
->ttip_window
)
780 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
782 gtk_widget_hide (GTK_WIDGET (win
));
784 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
786 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
787 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
788 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
789 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
800 /***********************************************************************
801 General functions for creating widgets, resizing, events, e.t.c.
802 ***********************************************************************/
804 /* Make a geometry string and pass that to GTK. It seems this is the
805 only way to get geometry position right if the user explicitly
806 asked for a position when starting Emacs.
807 F is the frame we shall set geometry for. */
810 xg_set_geometry (FRAME_PTR f
)
812 if (f
->size_hint_flags
& (USPosition
| PPosition
))
814 int left
= f
->left_pos
;
815 int xneg
= f
->size_hint_flags
& XNegative
;
816 int top
= f
->top_pos
;
817 int yneg
= f
->size_hint_flags
& YNegative
;
818 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
825 sprintf (geom_str
, "=%dx%d%c%d%c%d",
826 FRAME_PIXEL_WIDTH (f
),
827 FRAME_PIXEL_HEIGHT (f
),
828 (xneg
? '-' : '+'), left
,
829 (yneg
? '-' : '+'), top
);
831 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
833 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
837 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
838 and use a GtkFixed widget, this doesn't happen automatically. */
841 xg_clear_under_internal_border (FRAME_PTR f
)
843 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
845 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
846 gtk_widget_queue_draw (wfixed
);
847 gdk_window_process_all_updates ();
848 x_clear_area (FRAME_X_DISPLAY (f
),
851 FRAME_PIXEL_WIDTH (f
),
852 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
853 x_clear_area (FRAME_X_DISPLAY (f
),
856 FRAME_INTERNAL_BORDER_WIDTH (f
),
857 FRAME_PIXEL_HEIGHT (f
), 0);
858 x_clear_area (FRAME_X_DISPLAY (f
),
860 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
861 FRAME_PIXEL_WIDTH (f
),
862 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
863 x_clear_area (FRAME_X_DISPLAY (f
),
865 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
867 FRAME_INTERNAL_BORDER_WIDTH (f
),
868 FRAME_PIXEL_HEIGHT (f
), 0);
872 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
873 and a Gtk+ menu bar, we get resize events for the edit part of the
874 frame only. We let Gtk+ deal with the Gtk+ parts.
875 F is the frame to resize.
876 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
879 xg_frame_resized (FRAME_PTR f
, int pixelwidth
, int pixelheight
)
883 if (pixelwidth
== -1 && pixelheight
== -1)
885 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
886 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
888 &pixelwidth
, &pixelheight
);
893 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
894 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
896 if (columns
!= FRAME_COLS (f
)
897 || rows
!= FRAME_LINES (f
)
898 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
899 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
901 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
902 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
904 xg_clear_under_internal_border (f
);
905 change_frame_size (f
, rows
, columns
, 0, 1, 0);
906 SET_FRAME_GARBAGED (f
);
907 cancel_mouse_face (f
);
911 /* Resize the outer window of frame F after changing the height.
912 COLUMNS/ROWS is the size the edit area shall have after the resize. */
915 xg_frame_set_char_size (FRAME_PTR f
, int cols
, int rows
)
917 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
918 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
921 if (FRAME_PIXEL_HEIGHT (f
) == 0)
924 /* Take into account the size of the scroll bar. Always use the
925 number of columns occupied by the scroll bar here otherwise we
926 might end up with a frame width that is not a multiple of the
927 frame's character width which is bad for vertically split
929 f
->scroll_bar_actual_width
930 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
932 compute_fringe_widths (f
, 0);
934 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
935 after calculating that value. */
936 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
937 + FRAME_TOOLBAR_WIDTH (f
);
940 /* Do this before resize, as we don't know yet if we will be resized. */
941 xg_clear_under_internal_border (f
);
943 /* Must resize our top level widget. Font size may have changed,
944 but not rows/cols. */
945 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
946 pixelwidth
, pixelheight
);
947 x_wm_set_size_hint (f
, 0, 0);
949 SET_FRAME_GARBAGED (f
);
950 cancel_mouse_face (f
);
952 /* We can not call change_frame_size for a mapped frame,
953 we can not set pixel width/height either. The window manager may
954 override our resize request, XMonad does this all the time.
955 The best we can do is try to sync, so lisp code sees the updated
956 size as fast as possible.
957 For unmapped windows, we can set rows/cols. When
958 the frame is mapped again we will (hopefully) get the correct size. */
959 if (f
->async_visible
)
961 /* Must call this to flush out events */
962 (void)gtk_events_pending ();
964 x_wait_for_event (f
, ConfigureNotify
);
968 change_frame_size (f
, rows
, cols
, 0, 1, 0);
969 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
970 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
974 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
975 The policy is to keep the number of editable lines. */
978 xg_height_or_width_changed (FRAME_PTR f
)
980 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
981 FRAME_TOTAL_PIXEL_WIDTH (f
),
982 FRAME_TOTAL_PIXEL_HEIGHT (f
));
983 f
->output_data
.x
->hint_flags
= 0;
984 x_wm_set_size_hint (f
, 0, 0);
987 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
988 Must be done like this, because GtkWidget:s can have "hidden"
989 X Window that aren't accessible.
991 Return 0 if no widget match WDESC. */
994 xg_win_to_widget (Display
*dpy
, Window wdesc
)
997 GtkWidget
*gwdesc
= 0;
1001 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
1006 event
.any
.window
= gdkwin
;
1007 event
.any
.type
= GDK_NOTHING
;
1008 gwdesc
= gtk_get_event_widget (&event
);
1015 /* Set the background of widget W to PIXEL. */
1018 xg_set_widget_bg (FRAME_PTR f
, GtkWidget
*w
, long unsigned int pixel
)
1024 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1026 bg
.red
= (double)xbg
.red
/65536.0;
1027 bg
.green
= (double)xbg
.green
/65536.0;
1028 bg
.blue
= (double)xbg
.blue
/65536.0;
1030 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1034 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1035 gdk_colormap_query_color (map
, pixel
, &bg
);
1036 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1040 /* Callback called when the gtk theme changes.
1041 We notify lisp code so it can fix faces used for region for example. */
1044 style_changed_cb (GObject
*go
,
1048 struct input_event event
;
1049 GdkDisplay
*gdpy
= (GdkDisplay
*) user_data
;
1050 const char *display_name
= gdk_display_get_name (gdpy
);
1051 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1054 event
.kind
= CONFIG_CHANGED_EVENT
;
1055 event
.frame_or_window
= build_string (display_name
);
1056 /* Theme doesn't change often, so intern is called seldom. */
1057 event
.arg
= intern ("theme-name");
1058 kbd_buffer_store_event (&event
);
1060 update_theme_scrollbar_width ();
1062 /* If scroll bar width changed, we need set the new size on all frames
1066 Lisp_Object rest
, frame
;
1067 FOR_EACH_FRAME (rest
, frame
)
1069 FRAME_PTR f
= XFRAME (frame
);
1070 if (FRAME_X_DISPLAY (f
) == dpy
)
1072 x_set_scroll_bar_default_width (f
);
1073 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
1079 /* Called when a delete-event occurs on WIDGET. */
1082 delete_cb (GtkWidget
*widget
,
1087 /* The event doesn't arrive in the normal event loop. Send event
1089 FRAME_PTR f
= (FRAME_PTR
) user_data
;
1090 struct input_event ie
;
1093 ie
.kind
= DELETE_WINDOW_EVENT
;
1094 XSETFRAME (ie
.frame_or_window
, f
);
1095 kbd_buffer_store_event (&ie
);
1101 /* Create and set up the GTK widgets for frame F.
1102 Return 0 if creation failed, non-zero otherwise. */
1105 xg_create_frame_widgets (FRAME_PTR f
)
1108 GtkWidget
*wvbox
, *whbox
;
1117 if (FRAME_X_EMBEDDED_P (f
))
1119 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1120 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1123 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1125 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1126 has backported it to Gtk+ 2.0 and they add the resize grip for
1127 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1128 forever, so disable the grip. */
1129 #if GTK_MAJOR_VERSION < 3 && defined (HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1130 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1133 xg_set_screen (wtop
, f
);
1135 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1136 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1137 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1138 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1141 wfixed
= emacs_fixed_new (f
);
1143 wfixed
= gtk_fixed_new ();
1146 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1148 if (wtop
) gtk_widget_destroy (wtop
);
1149 if (wvbox
) gtk_widget_destroy (wvbox
);
1150 if (whbox
) gtk_widget_destroy (whbox
);
1151 if (wfixed
) gtk_widget_destroy (wfixed
);
1157 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1158 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1159 gtk_widget_set_name (wvbox
, "pane");
1160 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1162 /* If this frame has a title or name, set it in the title bar. */
1163 if (! NILP (f
->title
))
1164 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1165 else if (! NILP (f
->name
))
1166 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1168 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1170 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1171 FRAME_GTK_WIDGET (f
) = wfixed
;
1172 f
->output_data
.x
->vbox_widget
= wvbox
;
1173 f
->output_data
.x
->hbox_widget
= whbox
;
1175 gtk_widget_set_has_window (wfixed
, TRUE
);
1177 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1178 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1179 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1181 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1182 update_frame_tool_bar (f
);
1184 /* We don't want this widget double buffered, because we draw on it
1185 with regular X drawing primitives, so from a GTK/GDK point of
1186 view, the widget is totally blank. When an expose comes, this
1187 will make the widget blank, and then Emacs redraws it. This flickers
1188 a lot, so we turn off double buffering. */
1189 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1191 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1192 SSDATA (Vx_resource_name
),
1193 SSDATA (Vx_resource_class
));
1195 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1196 GTK is to destroy the widget. We want Emacs to do that instead. */
1197 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1198 G_CALLBACK (delete_cb
), f
);
1200 /* Convert our geometry parameters into a geometry string
1202 GTK will itself handle calculating the real position this way. */
1203 xg_set_geometry (f
);
1205 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1207 gtk_widget_add_events (wfixed
,
1208 GDK_POINTER_MOTION_MASK
1210 | GDK_BUTTON_PRESS_MASK
1211 | GDK_BUTTON_RELEASE_MASK
1212 | GDK_KEY_PRESS_MASK
1213 | GDK_ENTER_NOTIFY_MASK
1214 | GDK_LEAVE_NOTIFY_MASK
1215 | GDK_FOCUS_CHANGE_MASK
1216 | GDK_STRUCTURE_MASK
1217 | GDK_VISIBILITY_NOTIFY_MASK
);
1219 /* Must realize the windows so the X window gets created. It is used
1220 by callers of this function. */
1221 gtk_widget_realize (wfixed
);
1222 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1224 /* Since GTK clears its window by filling with the background color,
1225 we must keep X and GTK background in sync. */
1226 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1229 /* Also, do not let any background pixmap to be set, this looks very
1230 bad as Emacs overwrites the background pixmap with its own idea
1231 of background color. */
1232 style
= gtk_widget_get_modifier_style (wfixed
);
1234 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1235 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1236 gtk_widget_modify_style (wfixed
, style
);
1238 gtk_widget_set_can_focus (wfixed
, TRUE
);
1239 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1242 #ifdef USE_GTK_TOOLTIP
1243 /* Steal a tool tip window we can move ourselves. */
1244 f
->output_data
.x
->ttip_widget
= 0;
1245 f
->output_data
.x
->ttip_lbl
= 0;
1246 f
->output_data
.x
->ttip_window
= 0;
1247 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1248 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1252 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1253 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1254 /* Only connect this signal once per screen. */
1255 if (! g_signal_handler_find (G_OBJECT (gs
),
1256 G_SIGNAL_MATCH_FUNC
,
1258 G_CALLBACK (style_changed_cb
),
1261 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1262 G_CALLBACK (style_changed_cb
),
1263 gdk_screen_get_display (screen
));
1273 xg_free_frame_widgets (FRAME_PTR f
)
1275 if (FRAME_GTK_OUTER_WIDGET (f
))
1277 #ifdef USE_GTK_TOOLTIP
1278 struct x_output
*x
= f
->output_data
.x
;
1280 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1281 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1282 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1283 #ifdef USE_GTK_TOOLTIP
1285 gtk_widget_destroy (x
->ttip_lbl
);
1287 g_object_unref (G_OBJECT (x
->ttip_widget
));
1292 /* Set the normal size hints for the window manager, for frame F.
1293 FLAGS is the flags word to use--or 0 meaning preserve the flags
1294 that the window now has.
1295 If USER_POSITION is nonzero, we set the User Position
1296 flag (this is useful when FLAGS is 0). */
1299 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
1301 /* Must use GTK routines here, otherwise GTK resets the size hints
1302 to its own defaults. */
1303 GdkGeometry size_hints
;
1304 gint hint_flags
= 0;
1305 int base_width
, base_height
;
1306 int min_rows
= 0, min_cols
= 0;
1307 int win_gravity
= f
->win_gravity
;
1309 /* Don't set size hints during initialization; that apparently leads
1310 to a race condition. See the thread at
1311 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1312 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1317 memset (&size_hints
, 0, sizeof (size_hints
));
1318 f
->output_data
.x
->size_hints
= size_hints
;
1319 f
->output_data
.x
->hint_flags
= hint_flags
;
1322 flags
= f
->size_hint_flags
;
1324 size_hints
= f
->output_data
.x
->size_hints
;
1325 hint_flags
= f
->output_data
.x
->hint_flags
;
1327 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1328 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1329 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1331 hint_flags
|= GDK_HINT_BASE_SIZE
;
1332 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0) + FRAME_TOOLBAR_WIDTH (f
);
1333 /* Use one row here so base_height does not become zero.
1334 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1335 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1336 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1338 check_frame_size (f
, &min_rows
, &min_cols
);
1339 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1341 size_hints
.base_width
= base_width
;
1342 size_hints
.base_height
= base_height
;
1343 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1344 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1346 /* These currently have a one to one mapping with the X values, but I
1347 don't think we should rely on that. */
1348 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1349 size_hints
.win_gravity
= 0;
1350 if (win_gravity
== NorthWestGravity
)
1351 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1352 else if (win_gravity
== NorthGravity
)
1353 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1354 else if (win_gravity
== NorthEastGravity
)
1355 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1356 else if (win_gravity
== WestGravity
)
1357 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1358 else if (win_gravity
== CenterGravity
)
1359 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1360 else if (win_gravity
== EastGravity
)
1361 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1362 else if (win_gravity
== SouthWestGravity
)
1363 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1364 else if (win_gravity
== SouthGravity
)
1365 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1366 else if (win_gravity
== SouthEastGravity
)
1367 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1368 else if (win_gravity
== StaticGravity
)
1369 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1373 hint_flags
&= ~GDK_HINT_POS
;
1374 hint_flags
|= GDK_HINT_USER_POS
;
1377 if (hint_flags
!= f
->output_data
.x
->hint_flags
1378 || memcmp (&size_hints
,
1379 &f
->output_data
.x
->size_hints
,
1380 sizeof (size_hints
)) != 0)
1383 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1384 NULL
, &size_hints
, hint_flags
);
1385 f
->output_data
.x
->size_hints
= size_hints
;
1386 f
->output_data
.x
->hint_flags
= hint_flags
;
1391 /* Change background color of a frame.
1392 Since GTK uses the background color to clear the window, we must
1393 keep the GTK and X colors in sync.
1394 F is the frame to change,
1395 BG is the pixel value to change to. */
1398 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
1400 if (FRAME_GTK_WIDGET (f
))
1403 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1409 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1410 functions so GTK does not overwrite the icon. */
1413 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1415 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1419 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1424 /***********************************************************************
1426 ***********************************************************************/
1427 /* Return the dialog title to use for a dialog of type KEY.
1428 This is the encoding used by lwlib. We use the same for GTK. */
1431 get_dialog_title (char key
)
1433 const char *title
= "";
1441 title
= "Information";
1460 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1461 the dialog, but return TRUE so the event does not propagate further
1462 in GTK. This prevents GTK from destroying the dialog widget automatically
1463 and we can always destroy the widget manually, regardless of how
1464 it was popped down (button press or WM_DELETE_WINDOW).
1465 W is the dialog widget.
1466 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1467 user_data is NULL (not used).
1469 Returns TRUE to end propagation of event. */
1472 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1474 gtk_widget_unmap (w
);
1478 /* Create a popup dialog window. See also xg_create_widget below.
1479 WV is a widget_value describing the dialog.
1480 SELECT_CB is the callback to use when a button has been pressed.
1481 DEACTIVATE_CB is the callback to use when the dialog pops down.
1483 Returns the GTK dialog widget. */
1486 create_dialog (widget_value
*wv
,
1487 GCallback select_cb
,
1488 GCallback deactivate_cb
)
1490 const char *title
= get_dialog_title (wv
->name
[0]);
1491 int total_buttons
= wv
->name
[1] - '0';
1492 int right_buttons
= wv
->name
[4] - '0';
1495 int button_spacing
= 10;
1496 GtkWidget
*wdialog
= gtk_dialog_new ();
1497 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1498 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1500 GtkWidget
*whbox_down
;
1502 /* If the number of buttons is greater than 4, make two rows of buttons
1503 instead. This looks better. */
1504 int make_two_rows
= total_buttons
> 4;
1506 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1507 left_buttons
= total_buttons
- right_buttons
;
1509 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1510 gtk_widget_set_name (wdialog
, "emacs-dialog");
1515 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1516 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1517 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1518 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1519 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1520 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1522 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1523 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1524 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1526 cur_box
= GTK_BOX (whbox_up
);
1529 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1530 G_CALLBACK (dialog_delete_callback
), 0);
1534 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1535 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1538 for (item
= wv
->contents
; item
; item
= item
->next
)
1540 char *utf8_label
= get_utf8_string (item
->value
);
1544 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1546 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1547 /* This is the text part of the dialog. */
1548 w
= gtk_label_new (utf8_label
);
1549 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1550 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1551 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1553 /* Try to make dialog look better. Must realize first so
1554 the widget can calculate the size it needs. */
1555 gtk_widget_realize (w
);
1556 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1557 gtk_box_set_spacing (wvbox
, req
.height
);
1558 if (item
->value
&& strlen (item
->value
) > 0)
1559 button_spacing
= 2*req
.width
/strlen (item
->value
);
1563 /* This is one button to add to the dialog. */
1564 w
= gtk_button_new_with_label (utf8_label
);
1565 if (! item
->enabled
)
1566 gtk_widget_set_sensitive (w
, FALSE
);
1568 g_signal_connect (G_OBJECT (w
), "clicked",
1569 select_cb
, item
->call_data
);
1571 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1572 if (++button_nr
== left_buttons
)
1575 cur_box
= GTK_BOX (whbox_down
);
1577 gtk_box_pack_start (cur_box
,
1585 g_free (utf8_label
);
1591 struct xg_dialog_data
1599 /* Function that is called when the file or font dialogs pop down.
1600 W is the dialog widget, RESPONSE is the response code.
1601 USER_DATA is what we passed in to g_signal_connect. */
1604 xg_dialog_response_cb (GtkDialog
*w
,
1608 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1609 dd
->response
= response
;
1610 g_main_loop_quit (dd
->loop
);
1614 /* Destroy the dialog. This makes it pop down. */
1617 pop_down_dialog (Lisp_Object arg
)
1619 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1620 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1623 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1624 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1626 g_main_loop_quit (dd
->loop
);
1627 g_main_loop_unref (dd
->loop
);
1634 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1635 We pass in DATA as gpointer* so we can use this as a callback. */
1638 xg_maybe_add_timer (gpointer data
)
1640 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1641 EMACS_TIME next_time
= timer_check ();
1645 if (EMACS_TIME_VALID_P (next_time
))
1647 time_t s
= EMACS_SECS (next_time
);
1648 int per_ms
= EMACS_TIME_RESOLUTION
/ 1000;
1649 int ms
= (EMACS_NSECS (next_time
) + per_ms
- 1) / per_ms
;
1650 if (s
<= ((guint
) -1 - ms
) / 1000)
1651 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1657 /* Pops up a modal dialog W and waits for response.
1658 We don't use gtk_dialog_run because we want to process emacs timers.
1659 The dialog W is not destroyed when this function returns. */
1662 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1664 ptrdiff_t count
= SPECPDL_INDEX ();
1665 struct xg_dialog_data dd
;
1667 xg_set_screen (w
, f
);
1668 gtk_window_set_transient_for (GTK_WINDOW (w
),
1669 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1670 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1671 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1673 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1674 dd
.response
= GTK_RESPONSE_CANCEL
;
1678 g_signal_connect (G_OBJECT (w
),
1680 G_CALLBACK (xg_dialog_response_cb
),
1682 /* Don't destroy the widget if closed by the window manager close button. */
1683 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1684 gtk_widget_show (w
);
1686 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1688 (void) xg_maybe_add_timer (&dd
);
1689 g_main_loop_run (dd
.loop
);
1692 unbind_to (count
, Qnil
);
1698 /***********************************************************************
1699 File dialog functions
1700 ***********************************************************************/
1701 /* Return non-zero if the old file selection dialog is being used.
1702 Return zero if not. */
1705 xg_uses_old_file_dialog (void)
1707 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1708 return x_gtk_use_old_file_dialog
;
1715 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1717 /* Return the selected file for file chooser dialog W.
1718 The returned string must be free:d. */
1721 xg_get_file_name_from_chooser (GtkWidget
*w
)
1723 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1726 /* Callback called when the "Show hidden files" toggle is pressed.
1727 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1730 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1732 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1734 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1735 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1739 /* Callback called when a property changes in a file chooser.
1740 GOBJECT is the file chooser dialog, ARG1 describes the property.
1741 USER_DATA is the toggle widget in the file chooser dialog.
1742 We use this to update the "Show hidden files" toggle when the user
1743 changes that property by right clicking in the file list. */
1746 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1748 if (strcmp (arg1
->name
, "show-hidden") == 0)
1750 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1751 gboolean visible
, toggle_on
;
1753 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1754 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1756 if (!!visible
!= !!toggle_on
)
1758 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1759 G_CALLBACK (xg_toggle_visibility_cb
),
1761 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1762 g_signal_handlers_unblock_by_func
1763 (G_OBJECT (wtoggle
),
1764 G_CALLBACK (xg_toggle_visibility_cb
),
1767 x_gtk_show_hidden_files
= visible
;
1771 /* Read a file name from the user using a file chooser dialog.
1772 F is the current frame.
1773 PROMPT is a prompt to show to the user. May not be NULL.
1774 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1775 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1776 file. (Actually, this only has cosmetic effects, the user can
1777 still enter a non-existing file.) *FUNC is set to a function that
1778 can be used to retrieve the selected file name from the returned widget.
1780 Returns the created widget. */
1783 xg_get_file_with_chooser (FRAME_PTR f
,
1785 char *default_filename
,
1786 int mustmatch_p
, int only_dir_p
,
1787 xg_get_file_func
*func
)
1791 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1792 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1793 GtkFileChooserAction action
= (mustmatch_p
?
1794 GTK_FILE_CHOOSER_ACTION_OPEN
:
1795 GTK_FILE_CHOOSER_ACTION_SAVE
);
1798 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1800 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1801 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1802 (mustmatch_p
|| only_dir_p
?
1803 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1806 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1808 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1809 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1810 gtk_widget_show (wbox
);
1811 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1813 if (x_gtk_show_hidden_files
)
1815 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1816 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1818 gtk_widget_show (wtoggle
);
1819 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1820 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1821 g_signal_connect (G_OBJECT (filewin
), "notify",
1822 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1824 if (x_gtk_file_dialog_help_text
)
1827 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1828 Show the C-l help text only for versions < 2.10. */
1829 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1830 strcat (msgbuf
, "\nType C-l to display a file name text entry box.\n");
1831 strcat (msgbuf
, "\nIf you don't like this file selector, use the "
1832 "corresponding\nkey binding or customize "
1833 "use-file-dialog to turn it off.");
1835 wmessage
= gtk_label_new (msgbuf
);
1836 gtk_widget_show (wmessage
);
1839 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1840 if (x_gtk_file_dialog_help_text
)
1841 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1842 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1844 if (default_filename
)
1847 struct gcpro gcpro1
;
1848 char *utf8_filename
;
1851 file
= build_string (default_filename
);
1853 /* File chooser does not understand ~/... in the file name. It must be
1854 an absolute name starting with /. */
1855 if (default_filename
[0] != '/')
1856 file
= Fexpand_file_name (file
, Qnil
);
1858 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1859 if (! NILP (Ffile_directory_p (file
)))
1860 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1864 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1866 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1868 char *cp
= strrchr (utf8_filename
, '/');
1870 else cp
= utf8_filename
;
1871 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1878 *func
= xg_get_file_name_from_chooser
;
1882 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1884 /* Return the selected file for file selector dialog W.
1885 The returned string must be free:d. */
1888 xg_get_file_name_from_selector (GtkWidget
*w
)
1890 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1891 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1894 /* Create a file selection dialog.
1895 F is the current frame.
1896 PROMPT is a prompt to show to the user. May not be NULL.
1897 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1898 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1899 file. *FUNC is set to a function that can be used to retrieve the
1900 selected file name from the returned widget.
1902 Returns the created widget. */
1905 xg_get_file_with_selection (FRAME_PTR f
,
1907 char *default_filename
,
1908 int mustmatch_p
, int only_dir_p
,
1909 xg_get_file_func
*func
)
1912 GtkFileSelection
*filesel
;
1914 filewin
= gtk_file_selection_new (prompt
);
1915 filesel
= GTK_FILE_SELECTION (filewin
);
1917 if (default_filename
)
1918 gtk_file_selection_set_filename (filesel
, default_filename
);
1922 /* The selection_entry part of filesel is not documented. */
1923 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1924 gtk_file_selection_hide_fileop_buttons (filesel
);
1927 *func
= xg_get_file_name_from_selector
;
1931 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1933 /* Read a file name from the user using a file dialog, either the old
1934 file selection dialog, or the new file chooser dialog. Which to use
1935 depends on what the GTK version used has, and what the value of
1936 gtk-use-old-file-dialog.
1937 F is the current frame.
1938 PROMPT is a prompt to show to the user. May not be NULL.
1939 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1940 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1943 Returns a file name or NULL if no file was selected.
1944 The returned string must be freed by the caller. */
1947 xg_get_file_name (FRAME_PTR f
,
1949 char *default_filename
,
1955 int filesel_done
= 0;
1956 xg_get_file_func func
;
1958 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
1959 /* I really don't know why this is needed, but without this the GLIBC add on
1960 library linuxthreads hangs when the Gnome file chooser backend creates
1962 sigblock (sigmask (__SIGRTMIN
));
1963 #endif /* HAVE_PTHREAD */
1965 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1967 if (xg_uses_old_file_dialog ())
1968 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1969 mustmatch_p
, only_dir_p
, &func
);
1971 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1972 mustmatch_p
, only_dir_p
, &func
);
1974 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1975 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1976 mustmatch_p
, only_dir_p
, &func
);
1977 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1979 gtk_widget_set_name (w
, "emacs-filedialog");
1981 filesel_done
= xg_dialog_run (f
, w
);
1983 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
1984 sigunblock (sigmask (__SIGRTMIN
));
1987 if (filesel_done
== GTK_RESPONSE_OK
)
1990 gtk_widget_destroy (w
);
1994 #ifdef HAVE_FREETYPE
1995 /* Pop up a GTK font selector and return the name of the font the user
1996 selects, as a C string. The returned font name follows GTK's own
1999 `FAMILY [VALUE1 VALUE2] SIZE'
2001 This can be parsed using font_parse_fcname in font.c.
2002 DEFAULT_NAME, if non-zero, is the default font name. */
2005 xg_get_font_name (FRAME_PTR f
, const char *default_name
)
2008 char *fontname
= NULL
;
2011 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
2012 sigblock (sigmask (__SIGRTMIN
));
2013 #endif /* HAVE_PTHREAD */
2015 w
= gtk_font_chooser_dialog_new
2016 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2019 default_name
= "Monospace 10";
2021 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2022 gtk_widget_set_name (w
, "emacs-fontdialog");
2024 done
= xg_dialog_run (f
, w
);
2026 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
2027 sigunblock (sigmask (__SIGRTMIN
));
2030 if (done
== GTK_RESPONSE_OK
)
2031 fontname
= gtk_font_chooser_get_font (GTK_FONT_CHOOSER (w
));
2033 gtk_widget_destroy (w
);
2036 #endif /* HAVE_FREETYPE */
2040 /***********************************************************************
2042 ***********************************************************************/
2044 /* The name of menu items that can be used for customization. Since GTK
2045 RC files are very crude and primitive, we have to set this on all
2046 menu item names so a user can easily customize menu items. */
2048 #define MENU_ITEM_NAME "emacs-menuitem"
2051 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2052 during GC. The next member points to the items. */
2053 static xg_list_node xg_menu_cb_list
;
2055 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2056 during GC. The next member points to the items. */
2057 static xg_list_node xg_menu_item_cb_list
;
2059 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2060 F is the frame CL_DATA will be initialized for.
2061 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2063 The menu bar and all sub menus under the menu bar in a frame
2064 share the same structure, hence the reference count.
2066 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2067 allocated xg_menu_cb_data if CL_DATA is NULL. */
2069 static xg_menu_cb_data
*
2070 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
2074 cl_data
= xmalloc (sizeof *cl_data
);
2076 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2077 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2078 cl_data
->highlight_cb
= highlight_cb
;
2079 cl_data
->ref_count
= 0;
2081 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2084 cl_data
->ref_count
++;
2089 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2090 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2092 When the menu bar is updated, menu items may have been added and/or
2093 removed, so menu_bar_vector and menu_bar_items_used change. We must
2094 then update CL_DATA since it is used to determine which menu
2095 item that is invoked in the menu.
2096 HIGHLIGHT_CB could change, there is no check that the same
2097 function is given when modifying a menu bar as was given when
2098 creating the menu bar. */
2101 update_cl_data (xg_menu_cb_data
*cl_data
,
2103 GCallback highlight_cb
)
2108 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2109 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2110 cl_data
->highlight_cb
= highlight_cb
;
2114 /* Decrease reference count for CL_DATA.
2115 If reference count is zero, free CL_DATA. */
2118 unref_cl_data (xg_menu_cb_data
*cl_data
)
2120 if (cl_data
&& cl_data
->ref_count
> 0)
2122 cl_data
->ref_count
--;
2123 if (cl_data
->ref_count
== 0)
2125 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2131 /* Function that marks all lisp data during GC. */
2138 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2139 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2141 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2143 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2145 if (! NILP (cb_data
->help
))
2146 mark_object (cb_data
->help
);
2151 /* Callback called when a menu item is destroyed. Used to free data.
2152 W is the widget that is being destroyed (not used).
2153 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2156 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2160 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
2161 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2166 /* Callback called when the pointer enters/leaves a menu item.
2167 W is the parent of the menu item.
2168 EVENT is either an enter event or leave event.
2169 CLIENT_DATA is not used.
2171 Returns FALSE to tell GTK to keep processing this event. */
2174 menuitem_highlight_callback (GtkWidget
*w
,
2175 GdkEventCrossing
*event
,
2176 gpointer client_data
)
2179 GtkWidget
*subwidget
;
2180 xg_menu_item_cb_data
*data
;
2182 ev
.crossing
= *event
;
2183 subwidget
= gtk_get_event_widget (&ev
);
2184 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
2188 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2190 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2191 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2192 (*func
) (subwidget
, call_data
);
2199 /* Callback called when a menu is destroyed. Used to free data.
2200 W is the widget that is being destroyed (not used).
2201 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2204 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2206 unref_cl_data ((xg_menu_cb_data
*) client_data
);
2209 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2210 must be non-NULL) and can be inserted into a menu item.
2212 Returns the GtkHBox. */
2215 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2221 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2222 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2223 wlbl
= gtk_label_new (utf8_label
);
2224 wkey
= gtk_label_new (utf8_key
);
2226 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2227 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2229 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2230 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2232 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2233 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2234 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2239 /* Make and return a menu item widget with the key to the right.
2240 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2241 UTF8_KEY is the text representing the key binding.
2242 ITEM is the widget_value describing the menu item.
2244 GROUP is an in/out parameter. If the menu item to be created is not
2245 part of any radio menu group, *GROUP contains NULL on entry and exit.
2246 If the menu item to be created is part of a radio menu group, on entry
2247 *GROUP contains the group to use, or NULL if this is the first item
2248 in the group. On exit, *GROUP contains the radio item group.
2250 Unfortunately, keys don't line up as nicely as in Motif,
2251 but the MacOS X version doesn't either, so I guess that is OK. */
2254 make_menu_item (const char *utf8_label
,
2255 const char *utf8_key
,
2260 GtkWidget
*wtoadd
= 0;
2262 /* It has been observed that some menu items have a NULL name field.
2263 This will lead to this function being called with a NULL utf8_label.
2264 GTK crashes on that so we set a blank label. Why there is a NULL
2265 name remains to be investigated. */
2266 if (! utf8_label
) utf8_label
= " ";
2269 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2271 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2274 if (utf8_key
) w
= gtk_check_menu_item_new ();
2275 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2276 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2278 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2280 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2281 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2282 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2284 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2289 if (utf8_key
) w
= gtk_menu_item_new ();
2290 else w
= gtk_menu_item_new_with_label (utf8_label
);
2293 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2294 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2299 static int xg_detached_menus
;
2301 /* Returns non-zero if there are detached menus. */
2304 xg_have_tear_offs (void)
2306 return xg_detached_menus
> 0;
2309 /* Callback invoked when a detached menu window is removed. Here we
2310 decrease the xg_detached_menus count.
2311 WIDGET is the top level window that is removed (the parent of the menu).
2312 CLIENT_DATA is not used. */
2315 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2317 if (xg_detached_menus
> 0) --xg_detached_menus
;
2320 /* Callback invoked when a menu is detached. It increases the
2321 xg_detached_menus count.
2322 WIDGET is the GtkTearoffMenuItem.
2323 CLIENT_DATA is not used. */
2326 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2328 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2329 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2331 ++xg_detached_menus
;
2332 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2334 G_CALLBACK (tearoff_remove
), 0);
2339 /* Create a menu item widget, and connect the callbacks.
2340 ITEM describes the menu item.
2341 F is the frame the created menu belongs to.
2342 SELECT_CB is the callback to use when a menu item is selected.
2343 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2344 CL_DATA points to the callback data to be used for this menu.
2345 GROUP is an in/out parameter. If the menu item to be created is not
2346 part of any radio menu group, *GROUP contains NULL on entry and exit.
2347 If the menu item to be created is part of a radio menu group, on entry
2348 *GROUP contains the group to use, or NULL if this is the first item
2349 in the group. On exit, *GROUP contains the radio item group.
2351 Returns the created GtkWidget. */
2354 xg_create_one_menuitem (widget_value
*item
,
2356 GCallback select_cb
,
2357 GCallback highlight_cb
,
2358 xg_menu_cb_data
*cl_data
,
2364 xg_menu_item_cb_data
*cb_data
;
2366 utf8_label
= get_utf8_string (item
->name
);
2367 utf8_key
= get_utf8_string (item
->key
);
2369 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2371 if (utf8_label
) g_free (utf8_label
);
2372 if (utf8_key
) g_free (utf8_key
);
2374 cb_data
= xmalloc (sizeof *cb_data
);
2376 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2378 cb_data
->select_id
= 0;
2379 cb_data
->help
= item
->help
;
2380 cb_data
->cl_data
= cl_data
;
2381 cb_data
->call_data
= item
->call_data
;
2383 g_signal_connect (G_OBJECT (w
),
2385 G_CALLBACK (menuitem_destroy_callback
),
2388 /* Put cb_data in widget, so we can get at it when modifying menubar */
2389 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2391 /* final item, not a submenu */
2392 if (item
->call_data
&& ! item
->contents
)
2396 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2402 /* Create a full menu tree specified by DATA.
2403 F is the frame the created menu belongs to.
2404 SELECT_CB is the callback to use when a menu item is selected.
2405 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2406 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2407 POP_UP_P is non-zero if we shall create a popup menu.
2408 MENU_BAR_P is non-zero if we shall create a menu bar.
2409 ADD_TEAROFF_P is non-zero if we shall add a tearoff menu item. Ignored
2410 if MENU_BAR_P is non-zero.
2411 TOPMENU is the topmost GtkWidget that others shall be placed under.
2412 It may be NULL, in that case we create the appropriate widget
2413 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2414 CL_DATA is the callback data we shall use for this menu, or NULL
2415 if we haven't set the first callback yet.
2416 NAME is the name to give to the top level menu if this function
2417 creates it. May be NULL to not set any name.
2419 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2422 This function calls itself to create submenus. */
2425 create_menus (widget_value
*data
,
2427 GCallback select_cb
,
2428 GCallback deactivate_cb
,
2429 GCallback highlight_cb
,
2434 xg_menu_cb_data
*cl_data
,
2438 GtkWidget
*wmenu
= topmenu
;
2439 GSList
*group
= NULL
;
2445 wmenu
= gtk_menu_new ();
2446 xg_set_screen (wmenu
, f
);
2447 /* Connect this to the menu instead of items so we get enter/leave for
2448 disabled items also. TODO: Still does not get enter/leave for
2449 disabled items in detached menus. */
2450 g_signal_connect (G_OBJECT (wmenu
),
2451 "enter-notify-event",
2452 G_CALLBACK (menuitem_highlight_callback
),
2454 g_signal_connect (G_OBJECT (wmenu
),
2455 "leave-notify-event",
2456 G_CALLBACK (menuitem_highlight_callback
),
2461 wmenu
= gtk_menu_bar_new ();
2462 /* Set width of menu bar to a small value so it doesn't enlarge
2463 a small initial frame size. The width will be set to the
2464 width of the frame later on when it is added to a container.
2465 height -1: Natural height. */
2466 gtk_widget_set_size_request (wmenu
, 1, -1);
2469 /* Put cl_data on the top menu for easier access. */
2470 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2471 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2472 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2473 G_CALLBACK (menu_destroy_callback
), cl_data
);
2476 gtk_widget_set_name (wmenu
, name
);
2479 g_signal_connect (G_OBJECT (wmenu
),
2480 "selection-done", deactivate_cb
, 0);
2483 if (! menu_bar_p
&& add_tearoff_p
)
2485 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2486 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2488 g_signal_connect (G_OBJECT (tearoff
), "activate",
2489 G_CALLBACK (tearoff_activate
), 0);
2492 for (item
= data
; item
; item
= item
->next
)
2496 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2497 && !menu_separator_name_p (item
->name
))
2500 /* A title for a popup. We do the same as GTK does when
2501 creating titles, but it does not look good. */
2503 utf8_label
= get_utf8_string (item
->name
);
2505 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2506 w
= gtk_menu_item_new_with_label (utf8_label
);
2507 gtk_widget_set_sensitive (w
, FALSE
);
2508 if (utf8_label
) g_free (utf8_label
);
2510 else if (menu_separator_name_p (item
->name
))
2513 /* GTK only have one separator type. */
2514 w
= gtk_separator_menu_item_new ();
2518 w
= xg_create_one_menuitem (item
,
2520 item
->contents
? 0 : select_cb
,
2525 /* Create a possibly empty submenu for menu bar items, since some
2526 themes don't highlight items correctly without it. */
2527 if (item
->contents
|| menu_bar_p
)
2529 GtkWidget
*submenu
= create_menus (item
->contents
,
2540 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2544 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2545 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2551 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2552 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2553 with some text and buttons.
2554 F is the frame the created item belongs to.
2555 NAME is the name to use for the top widget.
2556 VAL is a widget_value structure describing items to be created.
2557 SELECT_CB is the callback to use when a menu item is selected or
2558 a dialog button is pressed.
2559 DEACTIVATE_CB is the callback to use when an item is deactivated.
2560 For a menu, when a sub menu is not shown anymore, for a dialog it is
2561 called when the dialog is popped down.
2562 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2564 Returns the widget created. */
2567 xg_create_widget (const char *type
, const char *name
, FRAME_PTR f
, widget_value
*val
,
2568 GCallback select_cb
, GCallback deactivate_cb
,
2569 GCallback highlight_cb
)
2572 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2573 int pop_up_p
= strcmp (type
, "popup") == 0;
2575 if (strcmp (type
, "dialog") == 0)
2577 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2578 xg_set_screen (w
, f
);
2579 gtk_window_set_transient_for (GTK_WINDOW (w
),
2580 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2581 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2582 gtk_widget_set_name (w
, "emacs-dialog");
2583 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2585 else if (menu_bar_p
|| pop_up_p
)
2587 w
= create_menus (val
->contents
,
2599 /* Set the cursor to an arrow for popup menus when they are mapped.
2600 This is done by default for menu bar menus. */
2603 /* Must realize so the GdkWindow inside the widget is created. */
2604 gtk_widget_realize (w
);
2605 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2610 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2617 /* Return the label for menu item WITEM. */
2620 xg_get_menu_item_label (GtkMenuItem
*witem
)
2622 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2623 return gtk_label_get_label (wlabel
);
2626 /* Return non-zero if the menu item WITEM has the text LABEL. */
2629 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2632 char *utf8_label
= get_utf8_string (label
);
2633 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2635 if (! old_label
&& ! utf8_label
)
2637 else if (old_label
&& utf8_label
)
2638 is_same
= strcmp (utf8_label
, old_label
) == 0;
2640 if (utf8_label
) g_free (utf8_label
);
2645 /* Destroy widgets in LIST. */
2648 xg_destroy_widgets (GList
*list
)
2652 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2654 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2656 /* Destroying the widget will remove it from the container it is in. */
2657 gtk_widget_destroy (w
);
2661 /* Update the top level names in MENUBAR (i.e. not submenus).
2662 F is the frame the menu bar belongs to.
2663 *LIST is a list with the current menu bar names (menu item widgets).
2664 ITER is the item within *LIST that shall be updated.
2665 POS is the numerical position, starting at 0, of ITER in *LIST.
2666 VAL describes what the menu bar shall look like after the update.
2667 SELECT_CB is the callback to use when a menu item is selected.
2668 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2669 CL_DATA points to the callback data to be used for this menu bar.
2671 This function calls itself to walk through the menu bar names. */
2674 xg_update_menubar (GtkWidget
*menubar
,
2680 GCallback select_cb
,
2681 GCallback deactivate_cb
,
2682 GCallback highlight_cb
,
2683 xg_menu_cb_data
*cl_data
)
2685 if (! iter
&& ! val
)
2687 else if (iter
&& ! val
)
2689 /* Item(s) have been removed. Remove all remaining items. */
2690 xg_destroy_widgets (iter
);
2692 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2693 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2694 gtk_menu_item_new_with_label (""),
2700 else if (! iter
&& val
)
2702 /* Item(s) added. Add all new items in one call. */
2703 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2704 0, 1, 0, menubar
, cl_data
, 0);
2710 /* Below this neither iter or val is NULL */
2711 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2713 /* This item is still the same, check next item. */
2715 iter
= g_list_next (iter
);
2718 else /* This item is changed. */
2720 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2721 GtkMenuItem
*witem2
= 0;
2722 int val_in_menubar
= 0;
2723 int iter_in_new_menubar
= 0;
2727 /* See if the changed entry (val) is present later in the menu bar */
2729 iter2
&& ! val_in_menubar
;
2730 iter2
= g_list_next (iter2
))
2732 witem2
= GTK_MENU_ITEM (iter2
->data
);
2733 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2736 /* See if the current entry (iter) is present later in the
2737 specification for the new menu bar. */
2738 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2739 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2741 if (val_in_menubar
&& ! iter_in_new_menubar
)
2745 /* This corresponds to:
2750 g_object_ref (G_OBJECT (witem
));
2751 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2752 gtk_widget_destroy (GTK_WIDGET (witem
));
2754 /* Must get new list since the old changed. */
2755 g_list_free (*list
);
2756 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2757 while (nr
-- > 0) iter
= g_list_next (iter
);
2759 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2761 /* This corresponds to:
2764 Rename B to X. This might seem to be a strange thing to do,
2765 since if there is a menu under B it will be totally wrong for X.
2766 But consider editing a C file. Then there is a C-mode menu
2767 (corresponds to B above).
2768 If then doing C-x C-f the minibuf menu (X above) replaces the
2769 C-mode menu. When returning from the minibuffer, we get
2770 back the C-mode menu. Thus we do:
2771 Rename B to X (C-mode to minibuf menu)
2772 Rename X to B (minibuf to C-mode menu).
2773 If the X menu hasn't been invoked, the menu under B
2774 is up to date when leaving the minibuffer. */
2775 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2776 char *utf8_label
= get_utf8_string (val
->name
);
2777 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2779 gtk_label_set_text (wlabel
, utf8_label
);
2781 /* If this item has a submenu that has been detached, change
2782 the title in the WM decorations also. */
2783 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2784 /* Set the title of the detached window. */
2785 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2787 if (utf8_label
) g_free (utf8_label
);
2788 iter
= g_list_next (iter
);
2792 else if (! val_in_menubar
&& iter_in_new_menubar
)
2794 /* This corresponds to:
2801 GtkWidget
*w
= xg_create_one_menuitem (val
,
2808 /* Create a possibly empty submenu for menu bar items, since some
2809 themes don't highlight items correctly without it. */
2810 GtkWidget
*submenu
= create_menus (NULL
, f
,
2811 select_cb
, deactivate_cb
,
2813 0, 0, 0, 0, cl_data
, 0);
2814 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2815 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2816 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2818 g_list_free (*list
);
2819 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2820 while (nr
-- > 0) iter
= g_list_next (iter
);
2821 iter
= g_list_next (iter
);
2825 else /* if (val_in_menubar && iter_in_new_menubar) */
2828 /* This corresponds to:
2833 g_object_ref (G_OBJECT (witem2
));
2834 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2835 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2836 GTK_WIDGET (witem2
), pos
);
2837 g_object_unref (G_OBJECT (witem2
));
2839 g_list_free (*list
);
2840 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2841 while (nr
-- > 0) iter
= g_list_next (iter
);
2842 if (iter
) iter
= g_list_next (iter
);
2848 /* Update the rest of the menu bar. */
2849 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2850 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2853 /* Update the menu item W so it corresponds to VAL.
2854 SELECT_CB is the callback to use when a menu item is selected.
2855 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2856 CL_DATA is the data to set in the widget for menu invocation. */
2859 xg_update_menu_item (widget_value
*val
,
2861 GCallback select_cb
,
2862 GCallback highlight_cb
,
2863 xg_menu_cb_data
*cl_data
)
2870 const char *old_label
= 0;
2871 const char *old_key
= 0;
2872 xg_menu_item_cb_data
*cb_data
;
2874 wchild
= XG_BIN_CHILD (w
);
2875 utf8_label
= get_utf8_string (val
->name
);
2876 utf8_key
= get_utf8_string (val
->key
);
2878 /* See if W is a menu item with a key. See make_menu_item above. */
2879 if (GTK_IS_BOX (wchild
))
2881 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2883 wlbl
= GTK_LABEL (list
->data
);
2884 wkey
= GTK_LABEL (list
->next
->data
);
2889 /* Remove the key and keep just the label. */
2890 g_object_ref (G_OBJECT (wlbl
));
2891 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2892 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2893 g_object_unref (G_OBJECT (wlbl
));
2898 else /* Just a label. */
2900 wlbl
= GTK_LABEL (wchild
);
2902 /* Check if there is now a key. */
2905 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2906 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2908 wlbl
= GTK_LABEL (list
->data
);
2909 wkey
= GTK_LABEL (list
->next
->data
);
2912 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2913 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2918 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2919 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2921 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2922 gtk_label_set_text (wkey
, utf8_key
);
2924 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2925 gtk_label_set_text (wlbl
, utf8_label
);
2927 if (utf8_key
) g_free (utf8_key
);
2928 if (utf8_label
) g_free (utf8_label
);
2930 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2931 gtk_widget_set_sensitive (w
, FALSE
);
2932 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2933 gtk_widget_set_sensitive (w
, TRUE
);
2935 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2939 cb_data
->call_data
= val
->call_data
;
2940 cb_data
->help
= val
->help
;
2941 cb_data
->cl_data
= cl_data
;
2943 /* We assume the callback functions don't change. */
2944 if (val
->call_data
&& ! val
->contents
)
2946 /* This item shall have a select callback. */
2947 if (! cb_data
->select_id
)
2949 = g_signal_connect (G_OBJECT (w
), "activate",
2950 select_cb
, cb_data
);
2952 else if (cb_data
->select_id
)
2954 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2955 cb_data
->select_id
= 0;
2960 /* Update the toggle menu item W so it corresponds to VAL. */
2963 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
2965 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2968 /* Update the radio menu item W so it corresponds to VAL. */
2971 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
2973 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2976 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2977 SUBMENU may be NULL, in that case a new menu is created.
2978 F is the frame the menu bar belongs to.
2979 VAL describes the contents of the menu bar.
2980 SELECT_CB is the callback to use when a menu item is selected.
2981 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2982 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2983 CL_DATA is the call back data to use for any newly created items.
2985 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2989 xg_update_submenu (GtkWidget
*submenu
,
2992 GCallback select_cb
,
2993 GCallback deactivate_cb
,
2994 GCallback highlight_cb
,
2995 xg_menu_cb_data
*cl_data
)
2997 GtkWidget
*newsub
= submenu
;
3001 int has_tearoff_p
= 0;
3002 GList
*first_radio
= 0;
3005 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3007 for (cur
= val
, iter
= list
;
3009 iter
= g_list_next (iter
), cur
= cur
->next
)
3011 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3013 /* Skip tearoff items, they have no counterpart in val. */
3014 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
3017 iter
= g_list_next (iter
);
3018 if (iter
) w
= GTK_WIDGET (iter
->data
);
3022 /* Remember first radio button in a group. If we get a mismatch in
3023 a radio group we must rebuild the whole group so that the connections
3024 in GTK becomes correct. */
3025 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3027 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3028 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3031 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3033 if (! menu_separator_name_p (cur
->name
))
3036 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3038 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3040 xg_update_toggle_item (cur
, w
);
3041 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3043 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3045 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3047 xg_update_radio_item (cur
, w
);
3048 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3050 else if (GTK_IS_MENU_ITEM (w
))
3052 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3055 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3056 menu_separator_name_p (cur
->name
))
3059 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3061 sub
= gtk_menu_item_get_submenu (witem
);
3062 if (sub
&& ! cur
->contents
)
3064 /* Not a submenu anymore. */
3065 g_object_ref (G_OBJECT (sub
));
3066 remove_submenu (witem
);
3067 gtk_widget_destroy (sub
);
3069 else if (cur
->contents
)
3073 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3074 select_cb
, deactivate_cb
,
3075 highlight_cb
, cl_data
);
3077 /* If this item just became a submenu, we must set it. */
3079 gtk_menu_item_set_submenu (witem
, nsub
);
3084 /* Structural difference. Remove everything from here and down
3090 /* Remove widgets from first structural change. */
3093 /* If we are adding new menu items below, we must remove from
3094 first radio button so that radio groups become correct. */
3095 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3096 else xg_destroy_widgets (iter
);
3101 /* More items added. Create them. */
3102 newsub
= create_menus (cur
,
3115 if (list
) g_list_free (list
);
3120 /* Update the MENUBAR.
3121 F is the frame the menu bar belongs to.
3122 VAL describes the contents of the menu bar.
3123 If DEEP_P is non-zero, rebuild all but the top level menu names in
3124 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3125 SELECT_CB is the callback to use when a menu item is selected.
3126 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3127 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3130 xg_modify_menubar_widgets (GtkWidget
*menubar
, FRAME_PTR f
, widget_value
*val
,
3132 GCallback select_cb
, GCallback deactivate_cb
,
3133 GCallback highlight_cb
)
3135 xg_menu_cb_data
*cl_data
;
3136 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3140 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
3143 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3144 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3150 /* Update all sub menus.
3151 We must keep the submenus (GTK menu item widgets) since the
3152 X Window in the XEvent that activates the menu are those widgets. */
3154 /* Update cl_data, menu_item things in F may have changed. */
3155 update_cl_data (cl_data
, f
, highlight_cb
);
3157 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3162 GtkMenuItem
*witem
= 0;
3164 /* Find sub menu that corresponds to val and update it. */
3165 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3167 witem
= GTK_MENU_ITEM (iter
->data
);
3168 if (xg_item_label_same_p (witem
, cur
->name
))
3170 sub
= gtk_menu_item_get_submenu (witem
);
3175 newsub
= xg_update_submenu (sub
,
3182 /* sub may still be NULL. If we just updated non deep and added
3183 a new menu bar item, it has no sub menu yet. So we set the
3184 newly created sub menu under witem. */
3185 if (newsub
!= sub
&& witem
!= 0)
3187 xg_set_screen (newsub
, f
);
3188 gtk_menu_item_set_submenu (witem
, newsub
);
3194 gtk_widget_show_all (menubar
);
3197 /* Callback called when the menu bar W is mapped.
3198 Used to find the height of the menu bar if we didn't get it
3199 after showing the widget. */
3202 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3205 FRAME_PTR f
= (FRAME_PTR
) user_data
;
3206 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3207 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3209 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3210 xg_height_or_width_changed (f
);
3214 /* Recompute all the widgets of frame F, when the menu bar has been
3215 changed. Value is non-zero if widgets were updated. */
3218 xg_update_frame_menubar (FRAME_PTR f
)
3220 struct x_output
*x
= f
->output_data
.x
;
3223 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3226 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3227 return 0; /* Already done this, happens for frames created invisible. */
3231 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3233 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3235 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3236 gtk_widget_show_all (x
->menubar_widget
);
3237 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3239 /* If menu bar doesn't know its height yet, cheat a little so the frame
3240 doesn't jump so much when resized later in menubar_map_cb. */
3241 if (req
.height
== 0)
3244 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3246 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3247 xg_height_or_width_changed (f
);
3254 /* Get rid of the menu bar of frame F, and free its storage.
3255 This is used when deleting a frame, and when turning off the menu bar. */
3258 free_frame_menubar (FRAME_PTR f
)
3260 struct x_output
*x
= f
->output_data
.x
;
3262 if (x
->menubar_widget
)
3266 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3267 /* The menubar and its children shall be deleted when removed from
3269 x
->menubar_widget
= 0;
3270 FRAME_MENUBAR_HEIGHT (f
) = 0;
3271 xg_height_or_width_changed (f
);
3277 xg_event_is_for_menubar (FRAME_PTR f
, XEvent
*event
)
3279 struct x_output
*x
= f
->output_data
.x
;
3288 if (! x
->menubar_widget
) return 0;
3290 if (! (event
->xbutton
.x
>= 0
3291 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3292 && event
->xbutton
.y
>= 0
3293 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3294 && event
->xbutton
.same_screen
))
3297 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3298 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3300 gevent
.any
.window
= gw
;
3301 gevent
.any
.type
= GDK_NOTHING
;
3302 gwdesc
= gtk_get_event_widget (&gevent
);
3303 if (! gwdesc
) return 0;
3304 if (! GTK_IS_MENU_BAR (gwdesc
)
3305 && ! GTK_IS_MENU_ITEM (gwdesc
)
3306 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3309 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3310 if (! list
) return 0;
3311 rec
.x
= event
->xbutton
.x
;
3312 rec
.y
= event
->xbutton
.y
;
3316 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3318 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3319 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3323 return iter
== 0 ? 0 : 1;
3328 /***********************************************************************
3329 Scroll bar functions
3330 ***********************************************************************/
3333 /* Setting scroll bar values invokes the callback. Use this variable
3334 to indicate that callback should do nothing. */
3336 int xg_ignore_gtk_scrollbar
;
3338 /* The width of the scroll bar for the current theme. */
3340 static int scroll_bar_width_for_theme
;
3342 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3343 may be larger than 32 bits. Keep a mapping from integer index to widget
3344 pointers to get around the 32 bit limitation. */
3348 GtkWidget
**widgets
;
3353 /* Grow this much every time we need to allocate more */
3355 #define ID_TO_WIDGET_INCR 32
3357 /* Store the widget pointer W in id_to_widget and return the integer index. */
3360 xg_store_widget_in_map (GtkWidget
*w
)
3364 if (id_to_widget
.max_size
== id_to_widget
.used
)
3367 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3368 memory_full (SIZE_MAX
);
3370 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3371 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3372 new_size
, sizeof (GtkWidget
*));
3374 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3375 id_to_widget
.widgets
[i
] = 0;
3376 id_to_widget
.max_size
= new_size
;
3379 /* Just loop over the array and find a free place. After all,
3380 how many scroll bars are we creating? Should be a small number.
3381 The check above guarantees we will find a free place. */
3382 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3384 if (! id_to_widget
.widgets
[i
])
3386 id_to_widget
.widgets
[i
] = w
;
3387 ++id_to_widget
.used
;
3393 /* Should never end up here */
3397 /* Remove pointer at IDX from id_to_widget.
3398 Called when scroll bar is destroyed. */
3401 xg_remove_widget_from_map (ptrdiff_t idx
)
3403 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3405 id_to_widget
.widgets
[idx
] = 0;
3406 --id_to_widget
.used
;
3410 /* Get the widget pointer at IDX from id_to_widget. */
3413 xg_get_widget_from_map (ptrdiff_t idx
)
3415 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3416 return id_to_widget
.widgets
[idx
];
3422 update_theme_scrollbar_width (void)
3425 GtkAdjustment
*vadj
;
3432 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3433 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3434 g_object_ref_sink (G_OBJECT (wscroll
));
3435 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3436 gtk_widget_destroy (wscroll
);
3437 g_object_unref (G_OBJECT (wscroll
));
3440 scroll_bar_width_for_theme
= w
;
3444 xg_get_default_scrollbar_width (void)
3446 return scroll_bar_width_for_theme
;
3449 /* Return the scrollbar id for X Window WID on display DPY.
3450 Return -1 if WID not in id_to_widget. */
3453 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3458 w
= xg_win_to_widget (dpy
, wid
);
3462 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3463 if (id_to_widget
.widgets
[idx
] == w
)
3470 /* Callback invoked when scroll bar WIDGET is destroyed.
3471 DATA is the index into id_to_widget for WIDGET.
3472 We free pointer to last scroll bar values here and remove the index. */
3475 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3477 intptr_t id
= (intptr_t) data
;
3478 xg_remove_widget_from_map (id
);
3481 /* Create a scroll bar widget for frame F. Store the scroll bar
3483 SCROLL_CALLBACK is the callback to invoke when the value of the
3485 END_CALLBACK is the callback to invoke when scrolling ends.
3486 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3487 to set resources for the widget. */
3490 xg_create_scroll_bar (FRAME_PTR f
,
3491 struct scroll_bar
*bar
,
3492 GCallback scroll_callback
,
3493 GCallback end_callback
,
3494 const char *scroll_bar_name
)
3500 GtkAdjustment
*vadj
;
3505 /* Page, step increment values are not so important here, they
3506 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3507 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3510 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3511 webox
= gtk_event_box_new ();
3512 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3514 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3516 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3518 scroll_id
= xg_store_widget_in_map (wscroll
);
3520 g_signal_connect (G_OBJECT (wscroll
),
3522 G_CALLBACK (xg_gtk_scroll_destroy
),
3523 (gpointer
) scroll_id
);
3524 g_signal_connect (G_OBJECT (wscroll
),
3528 g_signal_connect (G_OBJECT (wscroll
),
3529 "button-release-event",
3533 /* The scroll bar widget does not draw on a window of its own. Instead
3534 it draws on the parent window, in this case the edit widget. So
3535 whenever the edit widget is cleared, the scroll bar needs to redraw
3536 also, which causes flicker. Put an event box between the edit widget
3537 and the scroll bar, so the scroll bar instead draws itself on the
3538 event box window. */
3539 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3540 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3543 /* Set the cursor to an arrow. */
3544 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3546 bar
->x_window
= scroll_id
;
3549 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3552 xg_remove_scroll_bar (FRAME_PTR f
, ptrdiff_t scrollbar_id
)
3554 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3557 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3558 gtk_widget_destroy (w
);
3559 gtk_widget_destroy (wparent
);
3560 SET_FRAME_GARBAGED (f
);
3564 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3566 TOP/LEFT are the new pixel positions where the bar shall appear.
3567 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3570 xg_update_scrollbar_pos (FRAME_PTR f
,
3571 ptrdiff_t scrollbar_id
,
3578 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3582 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3583 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3586 /* Clear out old position. */
3587 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3588 if (gtk_widget_get_parent (wparent
) == wfixed
)
3590 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3591 "x", &oldx
, "y", &oldy
, NULL
);
3592 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3595 /* Move and resize to new values. */
3596 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3597 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3600 /* No room. Hide scroll bar as some themes output a warning if
3601 the height is less than the min size. */
3602 gtk_widget_hide (wparent
);
3603 gtk_widget_hide (wscroll
);
3607 gtk_widget_show_all (wparent
);
3608 gtk_widget_set_size_request (wscroll
, width
, height
);
3610 gtk_widget_queue_draw (wfixed
);
3611 gdk_window_process_all_updates ();
3612 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3614 /* Clear under old scroll bar position. This must be done after
3615 the gtk_widget_queue_draw and gdk_window_process_all_updates
3617 x_clear_area (FRAME_X_DISPLAY (f
),
3619 oldx
, oldy
, oldw
, oldh
, 0);
3622 /* GTK does not redraw until the main loop is entered again, but
3623 if there are no X events pending we will not enter it. So we sync
3624 here to get some events. */
3627 SET_FRAME_GARBAGED (f
);
3628 cancel_mouse_face (f
);
3632 /* Get the current value of the range, truncated to an integer. */
3635 int_gtk_range_get_value (GtkRange
*range
)
3637 return gtk_range_get_value (range
);
3641 /* Set the thumb size and position of scroll bar BAR. We are currently
3642 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3645 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3650 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3652 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3654 if (wscroll
&& NILP (bar
->dragging
))
3664 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3666 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3667 rather than the real portion value. This makes the thumb less likely
3668 to resize and that looks better. */
3669 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3670 /* When the thumb is at the bottom, position == whole.
3671 So we need to increase `whole' to make space for the thumb. */
3678 top
= (gdouble
) position
/ whole
;
3679 shown
= (gdouble
) portion
/ whole
;
3682 size
= shown
* XG_SB_RANGE
;
3683 size
= min (size
, XG_SB_RANGE
);
3684 size
= max (size
, 1);
3686 value
= top
* XG_SB_RANGE
;
3687 value
= min (value
, XG_SB_MAX
- size
);
3688 value
= max (value
, XG_SB_MIN
);
3690 /* Assume all lines are of equal size. */
3691 new_step
= size
/ max (1, FRAME_LINES (f
));
3693 old_size
= gtk_adjustment_get_page_size (adj
);
3694 if (old_size
!= size
)
3696 int old_step
= gtk_adjustment_get_step_increment (adj
);
3697 if (old_step
!= new_step
)
3699 gtk_adjustment_set_page_size (adj
, size
);
3700 gtk_adjustment_set_step_increment (adj
, new_step
);
3701 /* Assume a page increment is about 95% of the page size */
3702 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3707 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3711 /* gtk_range_set_value invokes the callback. Set
3712 ignore_gtk_scrollbar to make the callback do nothing */
3713 xg_ignore_gtk_scrollbar
= 1;
3715 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3716 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3718 gtk_adjustment_changed (adj
);
3720 xg_ignore_gtk_scrollbar
= 0;
3727 /* Return non-zero if EVENT is for a scroll bar in frame F.
3728 When the same X window is used for several Gtk+ widgets, we cannot
3729 say for sure based on the X window alone if an event is for the
3730 frame. This function does additional checks.
3732 Return non-zero if the event is for a scroll bar, zero otherwise. */
3735 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3739 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3741 /* Check if press occurred outside the edit widget. */
3742 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3745 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
3746 (gdk_display_get_device_manager (gdpy
));
3747 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
3749 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
3751 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3754 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3755 || event
->type
== MotionNotify
))
3757 /* If we are releasing or moving the scroll bar, it has the grab. */
3758 GtkWidget
*w
= gtk_grab_get_current ();
3759 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3767 /***********************************************************************
3769 ***********************************************************************/
3770 /* The key for the data we put in the GtkImage widgets. The data is
3771 the image used by Emacs. We use this to see if we need to update
3772 the GtkImage with a new image. */
3773 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3775 /* The key for storing the latest modifiers so the activate callback can
3777 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3779 /* The key for storing the button widget in its proxy menu item. */
3780 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3782 /* The key for the data we put in the GtkImage widgets. The data is
3783 the stock name used by Emacs. We use this to see if we need to update
3784 the GtkImage with a new image. */
3785 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3787 /* As above, but this is used for named theme widgets, as opposed to
3789 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3791 /* Callback function invoked when a tool bar item is pressed.
3792 W is the button widget in the tool bar that got pressed,
3793 CLIENT_DATA is an integer that is the index of the button in the
3794 tool bar. 0 is the first button. */
3797 xg_tool_bar_button_cb (GtkWidget
*widget
,
3798 GdkEventButton
*event
,
3801 intptr_t state
= event
->state
;
3802 gpointer ptr
= (gpointer
) state
;
3803 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3808 /* Callback function invoked when a tool bar item is pressed.
3809 W is the button widget in the tool bar that got pressed,
3810 CLIENT_DATA is an integer that is the index of the button in the
3811 tool bar. 0 is the first button. */
3814 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3816 intptr_t idx
= (intptr_t) client_data
;
3817 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3818 intptr_t mod
= (intptr_t) gmod
;
3820 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3821 Lisp_Object key
, frame
;
3822 struct input_event event
;
3825 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3828 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3830 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3831 XSETFRAME (frame
, f
);
3833 /* We generate two events here. The first one is to set the prefix
3834 to `(tool_bar)', see keyboard.c. */
3835 event
.kind
= TOOL_BAR_EVENT
;
3836 event
.frame_or_window
= frame
;
3838 kbd_buffer_store_event (&event
);
3840 event
.kind
= TOOL_BAR_EVENT
;
3841 event
.frame_or_window
= frame
;
3843 /* Convert between the modifier bits GDK uses and the modifier bits
3844 Emacs uses. This assumes GDK and X masks are the same, which they are when
3846 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3847 kbd_buffer_store_event (&event
);
3849 /* Return focus to the frame after we have clicked on a detached
3851 Fx_focus_frame (frame
);
3854 /* Callback function invoked when a tool bar item is pressed in a detached
3855 tool bar or the overflow drop down menu.
3856 We just call xg_tool_bar_callback.
3857 W is the menu item widget that got pressed,
3858 CLIENT_DATA is an integer that is the index of the button in the
3859 tool bar. 0 is the first button. */
3862 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3864 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3865 XG_TOOL_BAR_PROXY_BUTTON
));
3866 xg_tool_bar_callback (wbutton
, client_data
);
3871 xg_tool_bar_help_callback (GtkWidget
*w
,
3872 GdkEventCrossing
*event
,
3873 gpointer client_data
);
3875 /* This callback is called when a help is to be shown for an item in
3876 the detached tool bar when the detached tool bar it is not expanded. */
3879 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3880 GdkEventCrossing
*event
,
3881 gpointer client_data
)
3883 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3884 XG_TOOL_BAR_PROXY_BUTTON
));
3886 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3890 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3892 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3893 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3894 GtkWidget
*c2
= clist
->next
? (GtkWidget
*) clist
->next
->data
: NULL
;
3896 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3897 g_list_free (clist
);
3898 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3902 /* This callback is called when a tool item should create a proxy item,
3903 such as for the overflow menu. Also called when the tool bar is detached.
3904 If we don't create a proxy menu item, the detached tool bar will be
3908 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3910 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
3911 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
3913 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3914 GtkImage
*wimage
= GTK_IMAGE (c1
);
3915 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3916 (wlbl
? gtk_label_get_text (wlbl
) : "");
3917 GtkWidget
*wmenuimage
;
3920 if (gtk_button_get_use_stock (wbutton
))
3921 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3922 GTK_ICON_SIZE_MENU
);
3925 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3926 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3928 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
3930 if (store_type
== GTK_IMAGE_STOCK
)
3933 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3934 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3936 else if (store_type
== GTK_IMAGE_ICON_SET
)
3938 GtkIconSet
*icon_set
;
3939 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3940 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3941 GTK_ICON_SIZE_MENU
);
3943 else if (store_type
== GTK_IMAGE_PIXBUF
)
3948 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3951 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3953 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3954 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3955 GDK_INTERP_BILINEAR
);
3957 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3961 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3965 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3967 const gchar
*icon_name
;
3968 GtkIconSize icon_size
;
3970 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3971 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3972 GTK_ICON_SIZE_MENU
);
3976 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3981 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3983 g_signal_connect (G_OBJECT (wmenuitem
),
3985 G_CALLBACK (xg_tool_bar_proxy_callback
),
3989 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3990 (gpointer
) wbutton
);
3991 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3992 gtk_widget_set_sensitive (wmenuitem
,
3993 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
3995 /* Use enter/leave notify to show help. We use the events
3996 rather than the GtkButton specific signals "enter" and
3997 "leave", so we can have only one callback. The event
3998 will tell us what kind of event it is. */
3999 g_signal_connect (G_OBJECT (wmenuitem
),
4000 "enter-notify-event",
4001 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4003 g_signal_connect (G_OBJECT (wmenuitem
),
4004 "leave-notify-event",
4005 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4011 /* This callback is called when a tool bar is detached. We must set
4012 the height of the tool bar to zero when this happens so frame sizes
4013 are correctly calculated.
4014 WBOX is the handle box widget that enables detach/attach of the tool bar.
4015 W is the tool bar widget.
4016 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4019 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
4021 gpointer client_data
)
4023 FRAME_PTR f
= (FRAME_PTR
) client_data
;
4025 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
4030 GtkRequisition req
, req2
;
4031 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
4032 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4033 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4034 req
.width
-= req2
.width
;
4035 req
.height
-= req2
.height
;
4036 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4037 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4038 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4039 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4040 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4041 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4042 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4043 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4044 xg_height_or_width_changed (f
);
4048 /* This callback is called when a tool bar is reattached. We must set
4049 the height of the tool bar when this happens so frame sizes
4050 are correctly calculated.
4051 WBOX is the handle box widget that enables detach/attach of the tool bar.
4052 W is the tool bar widget.
4053 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4056 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
4058 gpointer client_data
)
4060 FRAME_PTR f
= (FRAME_PTR
) client_data
;
4061 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4065 GtkRequisition req
, req2
;
4066 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
4067 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4068 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4069 req
.width
+= req2
.width
;
4070 req
.height
+= req2
.height
;
4071 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4072 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4073 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4074 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4075 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4076 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4077 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4078 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4079 xg_height_or_width_changed (f
);
4083 /* This callback is called when the mouse enters or leaves a tool bar item.
4084 It is used for displaying and hiding the help text.
4085 W is the tool bar item, a button.
4086 EVENT is either an enter event or leave event.
4087 CLIENT_DATA is an integer that is the index of the button in the
4088 tool bar. 0 is the first button.
4090 Returns FALSE to tell GTK to keep processing this event. */
4093 xg_tool_bar_help_callback (GtkWidget
*w
,
4094 GdkEventCrossing
*event
,
4095 gpointer client_data
)
4097 intptr_t idx
= (intptr_t) client_data
;
4098 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4099 Lisp_Object help
, frame
;
4101 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4104 if (event
->type
== GDK_ENTER_NOTIFY
)
4106 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4107 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4110 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4115 XSETFRAME (frame
, f
);
4116 kbd_buffer_store_help_event (frame
, help
);
4122 /* This callback is called when a tool bar item shall be redrawn.
4123 It modifies the expose event so that the GtkImage widget redraws the
4124 whole image. This to overcome a bug that makes GtkImage draw the image
4125 in the wrong place when it tries to redraw just a part of the image.
4126 W is the GtkImage to be redrawn.
4127 EVENT is the expose event for W.
4128 CLIENT_DATA is unused.
4130 Returns FALSE to tell GTK to keep processing this event. */
4134 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4135 GdkEventExpose
*event
,
4136 gpointer client_data
)
4140 gdk_drawable_get_size (event
->window
, &width
, &height
);
4141 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4142 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4144 event
->area
.x
= max (0, event
->area
.x
);
4145 event
->area
.y
= max (0, event
->area
.y
);
4147 event
->area
.width
= max (width
, event
->area
.width
);
4148 event
->area
.height
= max (height
, event
->area
.height
);
4154 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4155 #define toolbar_set_orientation(w, o) \
4156 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4158 #define toolbar_set_orientation(w, o) \
4159 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4162 /* Attach a tool bar to frame F. */
4165 xg_pack_tool_bar (FRAME_PTR f
, Lisp_Object pos
)
4167 struct x_output
*x
= f
->output_data
.x
;
4168 int into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4170 toolbar_set_orientation (x
->toolbar_widget
,
4172 ? GTK_ORIENTATION_VERTICAL
4173 : GTK_ORIENTATION_HORIZONTAL
);
4174 if (!x
->handlebox_widget
)
4176 x
->handlebox_widget
= gtk_handle_box_new ();
4177 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4178 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4179 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4180 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4181 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4187 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4189 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), x
->handlebox_widget
,
4192 if (EQ (pos
, Qleft
))
4193 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4194 x
->handlebox_widget
,
4196 x
->toolbar_in_hbox
= 1;
4200 int vbox_pos
= x
->menubar_widget
? 1 : 0;
4201 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4203 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
4207 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4208 x
->handlebox_widget
,
4210 x
->toolbar_in_hbox
= 0;
4214 /* Create a tool bar for frame F. */
4217 xg_create_tool_bar (FRAME_PTR f
)
4219 struct x_output
*x
= f
->output_data
.x
;
4220 #if GTK_CHECK_VERSION (3, 3, 6)
4221 GtkStyleContext
*gsty
;
4224 x
->toolbar_widget
= gtk_toolbar_new ();
4225 x
->toolbar_detached
= 0;
4227 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4229 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4230 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4231 #if GTK_CHECK_VERSION (3, 3, 6)
4232 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4233 gtk_style_context_add_class (gsty
, "primary-toolbar");
4238 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4240 /* Find the right-to-left image named by RTL in the tool bar images for F.
4241 Returns IMAGE if RTL is not found. */
4244 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
4247 Lisp_Object file
, rtl_name
;
4248 struct gcpro gcpro1
, gcpro2
;
4249 GCPRO2 (file
, rtl_name
);
4251 rtl_name
= Ffile_name_nondirectory (rtl
);
4253 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4255 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4256 if (!NILP (file
= file_for_image (rtl_image
)))
4258 file
= call1 (intern ("file-name-sans-extension"),
4259 Ffile_name_nondirectory (file
));
4260 if (EQ (Fequal (file
, rtl_name
), Qt
))
4271 static GtkToolItem
*
4272 xg_make_tool_item (FRAME_PTR f
,
4274 GtkWidget
**wbutton
,
4276 int i
, int horiz
, int text_image
)
4278 GtkToolItem
*ti
= gtk_tool_item_new ();
4279 GtkWidget
*vb
= gtk_box_new (horiz
4280 ? GTK_ORIENTATION_HORIZONTAL
4281 : GTK_ORIENTATION_VERTICAL
,
4283 GtkWidget
*wb
= gtk_button_new ();
4284 /* The eventbox is here so we can have tooltips on disabled items. */
4285 GtkWidget
*weventbox
= gtk_event_box_new ();
4286 #if GTK_CHECK_VERSION (3, 3, 6)
4287 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4288 GtkStyleContext
*gsty
;
4290 gtk_css_provider_load_from_data (css_prov
,
4292 " background-color: transparent;"
4296 gsty
= gtk_widget_get_style_context (weventbox
);
4297 gtk_style_context_add_provider (gsty
,
4298 GTK_STYLE_PROVIDER (css_prov
),
4299 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4300 g_object_unref (css_prov
);
4303 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4305 if (wimage
&& !text_image
)
4306 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4308 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4309 if (wimage
&& text_image
)
4310 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4312 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4313 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4314 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4315 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4316 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4318 if (wimage
|| label
)
4321 gpointer gi
= (gpointer
) ii
;
4323 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4324 G_CALLBACK (xg_tool_bar_menu_proxy
),
4327 g_signal_connect (G_OBJECT (wb
), "clicked",
4328 G_CALLBACK (xg_tool_bar_callback
),
4331 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4334 /* Catch expose events to overcome an annoying redraw bug, see
4335 comment for xg_tool_bar_item_expose_callback. */
4336 g_signal_connect (G_OBJECT (ti
),
4338 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4341 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4343 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4344 no distinction based on modifiers in the activate callback,
4345 so we have to do it ourselves. */
4346 g_signal_connect (wb
, "button-release-event",
4347 G_CALLBACK (xg_tool_bar_button_cb
),
4350 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4352 /* Use enter/leave notify to show help. We use the events
4353 rather than the GtkButton specific signals "enter" and
4354 "leave", so we can have only one callback. The event
4355 will tell us what kind of event it is. */
4356 g_signal_connect (G_OBJECT (weventbox
),
4357 "enter-notify-event",
4358 G_CALLBACK (xg_tool_bar_help_callback
),
4360 g_signal_connect (G_OBJECT (weventbox
),
4361 "leave-notify-event",
4362 G_CALLBACK (xg_tool_bar_help_callback
),
4366 if (wbutton
) *wbutton
= wb
;
4372 is_box_type (GtkWidget
*vb
, int is_horizontal
)
4376 if (GTK_IS_BOX (vb
))
4378 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4379 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4380 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4384 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4390 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4391 const char *icon_name
, const struct image
*img
,
4392 const char *label
, int horiz
)
4396 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4397 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4399 /* Check if the tool icon matches. */
4400 if (stock_name
&& wimage
)
4402 old
= g_object_get_data (G_OBJECT (wimage
),
4403 XG_TOOL_BAR_STOCK_NAME
);
4404 if (!old
|| strcmp (old
, stock_name
))
4407 else if (icon_name
&& wimage
)
4409 old
= g_object_get_data (G_OBJECT (wimage
),
4410 XG_TOOL_BAR_ICON_NAME
);
4411 if (!old
|| strcmp (old
, icon_name
))
4416 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4417 XG_TOOL_BAR_IMAGE_DATA
);
4418 Pixmap old_img
= (Pixmap
) gold_img
;
4419 if (old_img
!= img
->pixmap
)
4423 /* Check button configuration and label. */
4424 if (is_box_type (vb
, horiz
)
4425 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4428 /* Ensure label is correct. */
4430 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4435 xg_update_tool_bar_sizes (FRAME_PTR f
)
4437 struct x_output
*x
= f
->output_data
.x
;
4439 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4441 gtk_widget_get_preferred_size (GTK_WIDGET (x
->handlebox_widget
), NULL
, &req
);
4442 if (x
->toolbar_in_hbox
)
4445 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4446 x
->handlebox_widget
,
4447 "position", &pos
, NULL
);
4448 if (pos
== 0) nl
= req
.width
;
4449 else nr
= req
.width
;
4454 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4455 x
->handlebox_widget
,
4456 "position", &pos
, NULL
);
4457 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4458 else nb
= req
.height
;
4461 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4462 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4463 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4464 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4466 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4467 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4468 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4469 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4470 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4471 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4479 /* Update the tool bar for frame F. Add new buttons and remove old. */
4482 update_frame_tool_bar (FRAME_PTR f
)
4485 struct x_output
*x
= f
->output_data
.x
;
4486 int hmargin
= 0, vmargin
= 0;
4487 GtkToolbar
*wtoolbar
;
4489 GtkTextDirection dir
;
4490 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
4492 int text_image
, horiz
;
4494 if (! FRAME_GTK_WIDGET (f
))
4499 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4501 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4502 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4504 else if (CONSP (Vtool_bar_button_margin
))
4506 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4507 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4509 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4510 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4513 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4514 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4515 i.e. zero. This means that margins less than
4516 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4517 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4518 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4520 if (! x
->toolbar_widget
)
4521 xg_create_tool_bar (f
);
4523 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4524 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4526 style
= Ftool_bar_get_system_style ();
4527 text_image
= EQ (style
, Qtext_image_horiz
);
4528 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4530 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4532 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4533 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4537 struct image
*img
= NULL
;
4539 Lisp_Object stock
= Qnil
;
4540 GtkStockItem stock_item
;
4541 char *stock_name
= NULL
;
4542 char *icon_name
= NULL
;
4544 GtkWidget
*wbutton
= NULL
;
4545 Lisp_Object specified_file
;
4546 int vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4548 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4549 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4550 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4553 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4555 /* If this is a separator, use a gtk separator item. */
4556 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4558 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4561 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4563 ti
= gtk_separator_tool_item_new ();
4564 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4570 /* Otherwise, the tool-bar item is an ordinary button. */
4572 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4574 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4578 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4580 /* Ignore invalid image specifications. */
4581 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4582 if (!valid_image_p (image
))
4585 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4590 specified_file
= file_for_image (image
);
4591 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4592 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4594 if (STRINGP (stock
))
4596 stock_name
= SSDATA (stock
);
4597 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4599 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4600 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4602 icon_name
= stock_name
+ 2;
4606 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4609 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4611 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4612 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4620 if (stock_name
== NULL
&& icon_name
== NULL
)
4622 /* No stock image, or stock item not known. Try regular
4623 image. If image is a vector, choose it according to the
4625 if (dir
== GTK_TEXT_DIR_RTL
4626 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4628 image
= find_rtl_image (f
, image
, rtl
);
4630 if (VECTORP (image
))
4634 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4635 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4638 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4639 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4641 eassert (ASIZE (image
) >= idx
);
4642 image
= AREF (image
, idx
);
4647 img_id
= lookup_image (f
, image
);
4648 img
= IMAGE_FROM_ID (f
, img_id
);
4649 prepare_image_for_display (f
, img
);
4651 if (img
->load_failed_p
|| img
->pixmap
== None
)
4654 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4660 /* If there is an existing widget, check if it's stale; if so,
4661 remove it and make a new tool item from scratch. */
4662 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4665 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4674 /* Save the image so we can see if an update is needed the
4675 next time we call xg_tool_item_match_p. */
4676 if (EQ (style
, Qtext
))
4678 else if (stock_name
)
4680 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4681 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4682 (gpointer
) xstrdup (stock_name
),
4683 (GDestroyNotify
) xfree
);
4687 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4688 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4689 (gpointer
) xstrdup (icon_name
),
4690 (GDestroyNotify
) xfree
);
4694 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4695 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4696 (gpointer
)img
->pixmap
);
4699 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4700 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4701 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4706 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4710 /* Remove buttons not longer needed. */
4713 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4715 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4716 } while (ti
!= NULL
);
4718 if (f
->n_tool_bar_items
!= 0)
4721 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4722 gtk_widget_show_all (GTK_WIDGET (x
->handlebox_widget
));
4723 if (xg_update_tool_bar_sizes (f
))
4724 xg_height_or_width_changed (f
);
4730 /* Deallocate all resources for the tool bar on frame F.
4731 Remove the tool bar. */
4734 free_frame_tool_bar (FRAME_PTR f
)
4736 struct x_output
*x
= f
->output_data
.x
;
4738 if (x
->toolbar_widget
)
4740 int is_packed
= x
->handlebox_widget
!= 0;
4742 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4743 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4746 if (x
->toolbar_in_hbox
)
4747 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4748 x
->handlebox_widget
);
4750 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4751 x
->handlebox_widget
);
4754 gtk_widget_destroy (x
->toolbar_widget
);
4756 x
->toolbar_widget
= 0;
4757 x
->handlebox_widget
= 0;
4758 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4759 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4761 xg_height_or_width_changed (f
);
4768 xg_change_toolbar_position (FRAME_PTR f
, Lisp_Object pos
)
4770 struct x_output
*x
= f
->output_data
.x
;
4772 if (! x
->toolbar_widget
|| ! x
->handlebox_widget
)
4776 g_object_ref (x
->handlebox_widget
);
4777 if (x
->toolbar_in_hbox
)
4778 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4779 x
->handlebox_widget
);
4781 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4782 x
->handlebox_widget
);
4783 xg_pack_tool_bar (f
, pos
);
4784 g_object_unref (x
->handlebox_widget
);
4785 if (xg_update_tool_bar_sizes (f
))
4786 xg_height_or_width_changed (f
);
4794 /***********************************************************************
4796 ***********************************************************************/
4798 xg_initialize (void)
4800 GtkBindingSet
*binding_set
;
4801 GtkSettings
*settings
;
4804 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4805 we keep it permanently linked in. */
4810 xg_ignore_gtk_scrollbar
= 0;
4811 xg_detached_menus
= 0;
4812 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4813 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4815 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4816 id_to_widget
.widgets
= 0;
4818 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
4819 (gdk_display_get_default ()));
4820 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4821 bindings. It doesn't seem to be any way to remove properties,
4822 so we set it to VoidSymbol which in X means "no key". */
4823 gtk_settings_set_string_property (settings
,
4824 "gtk-menu-bar-accel",
4828 /* Make GTK text input widgets use Emacs style keybindings. This is
4830 gtk_settings_set_string_property (settings
,
4831 "gtk-key-theme-name",
4835 /* Make dialogs close on C-g. Since file dialog inherits from
4836 dialog, this works for them also. */
4837 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4838 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4841 /* Make menus close on C-g. */
4842 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4843 (GTK_TYPE_MENU_SHELL
));
4844 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4846 update_theme_scrollbar_width ();
4849 #endif /* USE_GTK */