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/>. */
30 #include "blockinput.h"
31 #include "syssignal.h"
34 #include "termhooks.h"
38 #include <gdk/gdkkeysyms.h>
39 #include "xsettings.h"
42 #include <X11/Xft/Xft.h>
47 #include "emacsgtkfixed.h"
50 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
51 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
53 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
54 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
56 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
57 #define gtk_widget_set_has_window(w, b) \
58 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
60 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
61 #define gtk_dialog_get_action_area(w) ((w)->action_area)
62 #define gtk_dialog_get_content_area(w) ((w)->vbox)
64 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
65 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
67 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
68 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
69 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
70 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
71 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
73 #if GTK_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 11
74 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
76 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
79 #if GTK_MAJOR_VERSION > 3 || (GTK_MAJOR_VERSION == 3 && GTK_MINOR_VERSION >= 2)
80 #define USE_NEW_GTK_FONT_CHOOSER 1
82 #define USE_NEW_GTK_FONT_CHOOSER 0
83 #define gtk_font_chooser_dialog_new(x, y) \
84 gtk_font_selection_dialog_new (x)
85 #undef GTK_FONT_CHOOSER
86 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
87 #define gtk_font_chooser_set_font(x, y) \
88 gtk_font_selection_dialog_set_font_name (x, y)
92 #ifdef USE_GTK_TOOLTIP
93 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
95 #define gdk_window_get_geometry(w, a, b, c, d) \
96 gdk_window_get_geometry (w, a, b, c, d, 0)
97 #define gdk_x11_window_lookup_for_display(d, w) \
98 gdk_xid_table_lookup_for_display (d, w)
99 #define gtk_box_new(ori, spacing) \
100 ((ori) == GTK_ORIENTATION_HORIZONTAL \
101 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
102 #define gtk_scrollbar_new(ori, spacing) \
103 ((ori) == GTK_ORIENTATION_HORIZONTAL \
104 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
106 #define GDK_KEY_g GDK_g
108 #endif /* HAVE_GTK3 */
110 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
112 static void update_theme_scrollbar_width (void);
114 #define TB_INFO_KEY "xg_frame_tb_info"
115 struct xg_frame_tb_info
117 Lisp_Object last_tool_bar
;
120 int hmargin
, vmargin
;
121 GtkTextDirection dir
;
125 /***********************************************************************
126 Display handling functions
127 ***********************************************************************/
129 /* Keep track of the default display, or NULL if there is none. Emacs
130 may close all its displays. */
132 static GdkDisplay
*gdpy_def
;
134 /* When the GTK widget W is to be created on a display for F that
135 is not the default display, set the display for W.
136 W can be a GtkMenu or a GtkWindow widget. */
139 xg_set_screen (GtkWidget
*w
, FRAME_PTR f
)
141 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
143 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
144 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
147 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
149 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
154 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
155 *DPY is set to NULL if the display can't be opened.
157 Returns non-zero if display could be opened, zero if display could not
158 be opened, and less than zero if the GTK version doesn't support
159 multiple displays. */
162 xg_display_open (char *display_name
, Display
**dpy
)
166 gdpy
= gdk_display_open (display_name
);
167 if (!gdpy_def
&& gdpy
)
170 gdk_display_manager_set_default_display (gdk_display_manager_get (),
174 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
178 /* Close display DPY. */
181 xg_display_close (Display
*dpy
)
183 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
185 /* If this is the default display, try to change it before closing.
186 If there is no other display to use, gdpy_def is set to NULL, and
187 the next call to xg_display_open resets the default display. */
188 if (gdk_display_get_default () == gdpy
)
190 struct x_display_info
*dpyinfo
;
191 GdkDisplay
*gdpy_new
= NULL
;
193 /* Find another display. */
194 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
195 if (dpyinfo
->display
!= dpy
)
197 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
198 gdk_display_manager_set_default_display (gdk_display_manager_get (),
205 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
206 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
207 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
208 can continue running, but there will be memory leaks. */
209 g_object_run_dispose (G_OBJECT (gdpy
));
211 /* This seems to be fixed in GTK 2.10. */
212 gdk_display_close (gdpy
);
217 /***********************************************************************
219 ***********************************************************************/
220 /* The next two variables and functions are taken from lwlib. */
221 static widget_value
*widget_value_free_list
;
222 static int malloc_cpt
;
224 /* Allocate a widget_value structure, either by taking one from the
225 widget_value_free_list or by malloc:ing a new one.
227 Return a pointer to the allocated structure. */
230 malloc_widget_value (void)
233 if (widget_value_free_list
)
235 wv
= widget_value_free_list
;
236 widget_value_free_list
= wv
->free_list
;
241 wv
= xmalloc (sizeof *wv
);
244 memset (wv
, 0, sizeof (widget_value
));
248 /* This is analogous to free. It frees only what was allocated
249 by malloc_widget_value, and no substructures. */
252 free_widget_value (widget_value
*wv
)
259 /* When the number of already allocated cells is too big,
266 wv
->free_list
= widget_value_free_list
;
267 widget_value_free_list
= wv
;
272 /* Create and return the cursor to be used for popup menus and
273 scroll bars on display DPY. */
276 xg_create_default_cursor (Display
*dpy
)
278 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
279 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
283 xg_get_pixbuf_from_pixmap (FRAME_PTR f
, Pixmap pix
)
288 unsigned int width
, height
, uunused
;
291 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
292 &width
, &height
, &uunused
, &uunused
);
294 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
298 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
311 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
314 xg_get_pixbuf_from_pix_and_mask (FRAME_PTR f
,
319 GdkPixbuf
*icon_buf
, *tmp_buf
;
321 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
322 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
323 g_object_unref (G_OBJECT (tmp_buf
));
325 width
= gdk_pixbuf_get_width (icon_buf
);
326 height
= gdk_pixbuf_get_height (icon_buf
);
330 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
331 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
332 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
333 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
334 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
337 for (y
= 0; y
< height
; ++y
)
339 guchar
*iconptr
, *maskptr
;
342 iconptr
= pixels
+ y
* rowstride
;
343 maskptr
= mask_pixels
+ y
* mask_rowstride
;
345 for (x
= 0; x
< width
; ++x
)
347 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
348 just R is sufficient. */
350 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
352 iconptr
+= rowstride
/width
;
353 maskptr
+= mask_rowstride
/width
;
357 g_object_unref (G_OBJECT (mask_buf
));
364 file_for_image (Lisp_Object image
)
366 Lisp_Object specified_file
= Qnil
;
369 for (tail
= XCDR (image
);
370 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
371 tail
= XCDR (XCDR (tail
)))
372 if (EQ (XCAR (tail
), QCfile
))
373 specified_file
= XCAR (XCDR (tail
));
375 return specified_file
;
378 /* For the image defined in IMG, make and return a GtkImage. For displays with
379 8 planes or less we must make a GdkPixbuf and apply the mask manually.
380 Otherwise the highlighting and dimming the tool bar code in GTK does
381 will look bad. For display with more than 8 planes we just use the
382 pixmap and mask directly. For monochrome displays, GTK doesn't seem
383 able to use external pixmaps, it looks bad whatever we do.
384 The image is defined on the display where frame F is.
385 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
386 If OLD_WIDGET is NULL, a new widget is constructed and returned.
387 If OLD_WIDGET is not NULL, that widget is modified. */
390 xg_get_image_for_pixmap (FRAME_PTR f
,
393 GtkImage
*old_widget
)
397 /* If we have a file, let GTK do all the image handling.
398 This seems to be the only way to make insensitive and activated icons
399 look good in all cases. */
400 Lisp_Object specified_file
= file_for_image (img
->spec
);
403 /* We already loaded the image once before calling this
404 function, so this only fails if the image file has been removed.
405 In that case, use the pixmap already loaded. */
407 if (STRINGP (specified_file
)
408 && STRINGP (file
= x_find_image_file (specified_file
)))
411 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
413 gtk_image_set_from_file (old_widget
, SSDATA (file
));
415 return GTK_WIDGET (old_widget
);
418 /* No file, do the image handling ourselves. This will look very bad
419 on a monochrome display, and sometimes bad on all displays with
422 /* This is a workaround to make icons look good on pseudo color
423 displays. Apparently GTK expects the images to have an alpha
424 channel. If they don't, insensitive and activated icons will
425 look bad. This workaround does not work on monochrome displays,
426 and is strictly not needed on true color/static color displays (i.e.
427 16 bits and higher). But we do it anyway so we get a pixbuf that is
428 not associated with the img->pixmap. The img->pixmap may be removed
429 by clearing the image cache and then the tool bar redraw fails, since
430 Gtk+ assumes the pixmap is always there. */
431 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
436 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
438 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
440 g_object_unref (G_OBJECT (icon_buf
));
443 return GTK_WIDGET (old_widget
);
447 /* Set CURSOR on W and all widgets W contain. We must do like this
448 for scroll bars and menu because they create widgets internally,
449 and it is those widgets that are visible. */
452 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
454 GdkWindow
*window
= gtk_widget_get_window (w
);
455 GList
*children
= gdk_window_peek_children (window
);
457 gdk_window_set_cursor (window
, cursor
);
459 /* The scroll bar widget has more than one GDK window (had to look at
460 the source to figure this out), and there is no way to set cursor
461 on widgets in GTK. So we must set the cursor for all GDK windows.
464 for ( ; children
; children
= g_list_next (children
))
465 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
468 /* Insert NODE into linked LIST. */
471 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
473 xg_list_node
*list_start
= list
->next
;
475 if (list_start
) list_start
->prev
= node
;
476 node
->next
= list_start
;
481 /* Remove NODE from linked LIST. */
484 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
486 xg_list_node
*list_start
= list
->next
;
487 if (node
== list_start
)
489 list
->next
= node
->next
;
490 if (list
->next
) list
->next
->prev
= 0;
494 node
->prev
->next
= node
->next
;
495 if (node
->next
) node
->next
->prev
= node
->prev
;
499 /* Allocate and return a utf8 version of STR. If STR is already
500 utf8 or NULL, just return a copy of STR.
501 A new string is allocated and the caller must free the result
505 get_utf8_string (const char *str
)
509 if (!str
) return NULL
;
511 /* If not UTF-8, try current locale. */
512 if (!g_utf8_validate (str
, -1, NULL
))
513 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
515 return g_strdup (str
);
519 /* Probably some control characters in str. Escape them. */
521 ptrdiff_t nr_bad
= 0;
524 unsigned char *p
= (unsigned char *)str
;
528 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
529 &bytes_written
, &err
))
530 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
533 p
+= bytes_written
+1;
546 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
547 memory_full (SIZE_MAX
);
548 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
549 p
= (unsigned char *)str
;
551 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
552 &bytes_written
, &err
))
553 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
555 memcpy (up
, p
, bytes_written
);
556 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
557 up
+= bytes_written
+4;
558 p
+= bytes_written
+1;
565 strcat (utf8_str
, cp
);
577 /* Check for special colors used in face spec for region face.
578 The colors are fetched from the Gtk+ theme.
579 Return 1 if color was found, 0 if not. */
582 xg_check_special_colors (struct frame
*f
,
583 const char *color_name
,
587 int get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
588 int get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
590 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
596 GtkStyleContext
*gsty
597 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
599 char buf
[sizeof "rgbi://" + 3 * (DBL_MAX_10_EXP
+ sizeof "-1.000000" - 1)];
600 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
602 gtk_style_context_get_color (gsty
, state
, &col
);
604 gtk_style_context_get_background_color (gsty
, state
, &col
);
606 sprintf (buf
, "rgbi:%lf/%lf/%lf", col
.red
, col
.green
, col
.blue
);
607 success_p
= XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
610 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
611 GdkColor
*grgb
= get_bg
612 ? &gsty
->bg
[GTK_STATE_SELECTED
]
613 : &gsty
->fg
[GTK_STATE_SELECTED
];
615 color
->red
= grgb
->red
;
616 color
->green
= grgb
->green
;
617 color
->blue
= grgb
->blue
;
618 color
->pixel
= grgb
->pixel
;
629 /***********************************************************************
631 ***********************************************************************/
632 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
633 We use that to pop down the tooltip. This happens if Gtk+ for some
634 reason wants to change or hide the tooltip. */
636 #ifdef USE_GTK_TOOLTIP
639 hierarchy_ch_cb (GtkWidget
*widget
,
640 GtkWidget
*previous_toplevel
,
643 FRAME_PTR f
= (FRAME_PTR
) user_data
;
644 struct x_output
*x
= f
->output_data
.x
;
645 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
647 if (! top
|| ! GTK_IS_WINDOW (top
))
648 gtk_widget_hide (previous_toplevel
);
651 /* Callback called when Gtk+ thinks a tooltip should be displayed.
652 We use it to get the tooltip window and the tooltip widget so
653 we can manipulate the ourselves.
655 Return FALSE ensures that the tooltip is not shown. */
658 qttip_cb (GtkWidget
*widget
,
661 gboolean keyboard_mode
,
665 FRAME_PTR f
= (FRAME_PTR
) user_data
;
666 struct x_output
*x
= f
->output_data
.x
;
667 if (x
->ttip_widget
== NULL
)
672 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
673 x
->ttip_widget
= tooltip
;
674 g_object_ref (G_OBJECT (tooltip
));
675 x
->ttip_lbl
= gtk_label_new ("");
676 g_object_ref (G_OBJECT (x
->ttip_lbl
));
677 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
678 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
680 /* Change stupid Gtk+ default line wrapping. */
681 p
= gtk_widget_get_parent (x
->ttip_lbl
);
682 list
= gtk_container_get_children (GTK_CONTAINER (p
));
683 for (iter
= list
; iter
; iter
= g_list_next (iter
))
685 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
686 if (GTK_IS_LABEL (w
))
687 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
691 /* ATK needs an empty title for some reason. */
692 gtk_window_set_title (x
->ttip_window
, "");
693 /* Realize so we can safely get screen later on. */
694 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
695 gtk_widget_realize (x
->ttip_lbl
);
697 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
698 G_CALLBACK (hierarchy_ch_cb
), f
);
703 #endif /* USE_GTK_TOOLTIP */
705 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
706 Return zero if no system tooltip available, non-zero otherwise. */
709 xg_prepare_tooltip (FRAME_PTR f
,
714 #ifndef USE_GTK_TOOLTIP
717 struct x_output
*x
= f
->output_data
.x
;
721 GtkSettings
*settings
;
722 gboolean tt_enabled
= TRUE
;
724 Lisp_Object encoded_string
;
726 if (!x
->ttip_lbl
) return 0;
729 encoded_string
= ENCODE_UTF_8 (string
);
730 widget
= GTK_WIDGET (x
->ttip_lbl
);
731 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
732 screen
= gdk_window_get_screen (gwin
);
733 settings
= gtk_settings_get_for_screen (screen
);
734 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
737 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
738 /* Record that we disabled it so it can be enabled again. */
739 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
743 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
744 g_object_set_data (G_OBJECT
745 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
746 "gdk-display-current-tooltip", NULL
);
748 /* Put our dummy widget in so we can get callbacks for unrealize and
749 hierarchy-changed. */
750 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
751 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
752 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
753 if (width
) *width
= req
.width
;
754 if (height
) *height
= req
.height
;
759 #endif /* USE_GTK_TOOLTIP */
762 /* Show the tooltip at ROOT_X and ROOT_Y.
763 xg_prepare_tooltip must have been called before this function. */
766 xg_show_tooltip (FRAME_PTR f
, int root_x
, int root_y
)
768 #ifdef USE_GTK_TOOLTIP
769 struct x_output
*x
= f
->output_data
.x
;
773 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
774 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
780 /* Hide tooltip if shown. Do nothing if not shown.
781 Return non-zero if tip was hidden, non-zero if not (i.e. not using
785 xg_hide_tooltip (FRAME_PTR f
)
788 #ifdef USE_GTK_TOOLTIP
789 if (f
->output_data
.x
->ttip_window
)
791 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
793 gtk_widget_hide (GTK_WIDGET (win
));
795 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
797 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
798 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
799 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
800 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
811 /***********************************************************************
812 General functions for creating widgets, resizing, events, e.t.c.
813 ***********************************************************************/
815 /* Make a geometry string and pass that to GTK. It seems this is the
816 only way to get geometry position right if the user explicitly
817 asked for a position when starting Emacs.
818 F is the frame we shall set geometry for. */
821 xg_set_geometry (FRAME_PTR f
)
823 if (f
->size_hint_flags
& (USPosition
| PPosition
))
825 int left
= f
->left_pos
;
826 int xneg
= f
->size_hint_flags
& XNegative
;
827 int top
= f
->top_pos
;
828 int yneg
= f
->size_hint_flags
& YNegative
;
829 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
836 sprintf (geom_str
, "=%dx%d%c%d%c%d",
837 FRAME_PIXEL_WIDTH (f
),
838 FRAME_PIXEL_HEIGHT (f
),
839 (xneg
? '-' : '+'), left
,
840 (yneg
? '-' : '+'), top
);
842 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
844 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
848 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
849 and use a GtkFixed widget, this doesn't happen automatically. */
852 xg_clear_under_internal_border (FRAME_PTR f
)
854 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
856 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
857 gtk_widget_queue_draw (wfixed
);
858 gdk_window_process_all_updates ();
859 x_clear_area (FRAME_X_DISPLAY (f
),
862 FRAME_PIXEL_WIDTH (f
),
863 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
864 x_clear_area (FRAME_X_DISPLAY (f
),
867 FRAME_INTERNAL_BORDER_WIDTH (f
),
868 FRAME_PIXEL_HEIGHT (f
), 0);
869 x_clear_area (FRAME_X_DISPLAY (f
),
871 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
872 FRAME_PIXEL_WIDTH (f
),
873 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
874 x_clear_area (FRAME_X_DISPLAY (f
),
876 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
878 FRAME_INTERNAL_BORDER_WIDTH (f
),
879 FRAME_PIXEL_HEIGHT (f
), 0);
883 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
884 and a Gtk+ menu bar, we get resize events for the edit part of the
885 frame only. We let Gtk+ deal with the Gtk+ parts.
886 F is the frame to resize.
887 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
890 xg_frame_resized (FRAME_PTR f
, int pixelwidth
, int pixelheight
)
894 if (pixelwidth
== -1 && pixelheight
== -1)
896 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
897 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
899 &pixelwidth
, &pixelheight
);
904 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
905 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
907 if (columns
!= FRAME_COLS (f
)
908 || rows
!= FRAME_LINES (f
)
909 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
910 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
912 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
913 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
915 xg_clear_under_internal_border (f
);
916 change_frame_size (f
, rows
, columns
, 0, 1, 0);
917 SET_FRAME_GARBAGED (f
);
918 cancel_mouse_face (f
);
922 /* Resize the outer window of frame F after changing the height.
923 COLUMNS/ROWS is the size the edit area shall have after the resize. */
926 xg_frame_set_char_size (FRAME_PTR f
, int cols
, int rows
)
928 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
929 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
932 if (FRAME_PIXEL_HEIGHT (f
) == 0)
935 /* Take into account the size of the scroll bar. Always use the
936 number of columns occupied by the scroll bar here otherwise we
937 might end up with a frame width that is not a multiple of the
938 frame's character width which is bad for vertically split
940 f
->scroll_bar_actual_width
941 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
943 compute_fringe_widths (f
, 0);
945 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
946 after calculating that value. */
947 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
948 + FRAME_TOOLBAR_WIDTH (f
);
951 /* Do this before resize, as we don't know yet if we will be resized. */
952 xg_clear_under_internal_border (f
);
954 /* Must resize our top level widget. Font size may have changed,
955 but not rows/cols. */
956 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
957 pixelwidth
, pixelheight
);
958 x_wm_set_size_hint (f
, 0, 0);
960 SET_FRAME_GARBAGED (f
);
961 cancel_mouse_face (f
);
963 /* We can not call change_frame_size for a mapped frame,
964 we can not set pixel width/height either. The window manager may
965 override our resize request, XMonad does this all the time.
966 The best we can do is try to sync, so lisp code sees the updated
967 size as fast as possible.
968 For unmapped windows, we can set rows/cols. When
969 the frame is mapped again we will (hopefully) get the correct size. */
970 if (f
->async_visible
)
972 /* Must call this to flush out events */
973 (void)gtk_events_pending ();
975 x_wait_for_event (f
, ConfigureNotify
);
979 change_frame_size (f
, rows
, cols
, 0, 1, 0);
980 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
981 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
985 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
986 The policy is to keep the number of editable lines. */
989 xg_height_or_width_changed (FRAME_PTR f
)
991 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
992 FRAME_TOTAL_PIXEL_WIDTH (f
),
993 FRAME_TOTAL_PIXEL_HEIGHT (f
));
994 f
->output_data
.x
->hint_flags
= 0;
995 x_wm_set_size_hint (f
, 0, 0);
998 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
999 Must be done like this, because GtkWidget:s can have "hidden"
1000 X Window that aren't accessible.
1002 Return 0 if no widget match WDESC. */
1005 xg_win_to_widget (Display
*dpy
, Window wdesc
)
1008 GtkWidget
*gwdesc
= 0;
1012 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
1017 event
.any
.window
= gdkwin
;
1018 event
.any
.type
= GDK_NOTHING
;
1019 gwdesc
= gtk_get_event_widget (&event
);
1026 /* Set the background of widget W to PIXEL. */
1029 xg_set_widget_bg (FRAME_PTR f
, GtkWidget
*w
, long unsigned int pixel
)
1035 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1037 bg
.red
= (double)xbg
.red
/65536.0;
1038 bg
.green
= (double)xbg
.green
/65536.0;
1039 bg
.blue
= (double)xbg
.blue
/65536.0;
1041 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1045 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1046 gdk_colormap_query_color (map
, pixel
, &bg
);
1047 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1051 /* Callback called when the gtk theme changes.
1052 We notify lisp code so it can fix faces used for region for example. */
1055 style_changed_cb (GObject
*go
,
1059 struct input_event event
;
1060 GdkDisplay
*gdpy
= (GdkDisplay
*) user_data
;
1061 const char *display_name
= gdk_display_get_name (gdpy
);
1062 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1065 event
.kind
= CONFIG_CHANGED_EVENT
;
1066 event
.frame_or_window
= build_string (display_name
);
1067 /* Theme doesn't change often, so intern is called seldom. */
1068 event
.arg
= intern ("theme-name");
1069 kbd_buffer_store_event (&event
);
1071 update_theme_scrollbar_width ();
1073 /* If scroll bar width changed, we need set the new size on all frames
1077 Lisp_Object rest
, frame
;
1078 FOR_EACH_FRAME (rest
, frame
)
1080 FRAME_PTR f
= XFRAME (frame
);
1081 if (FRAME_X_DISPLAY (f
) == dpy
)
1083 x_set_scroll_bar_default_width (f
);
1084 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
1090 /* Called when a delete-event occurs on WIDGET. */
1093 delete_cb (GtkWidget
*widget
,
1098 /* The event doesn't arrive in the normal event loop. Send event
1100 FRAME_PTR f
= (FRAME_PTR
) user_data
;
1101 struct input_event ie
;
1104 ie
.kind
= DELETE_WINDOW_EVENT
;
1105 XSETFRAME (ie
.frame_or_window
, f
);
1106 kbd_buffer_store_event (&ie
);
1112 /* Create and set up the GTK widgets for frame F.
1113 Return 0 if creation failed, non-zero otherwise. */
1116 xg_create_frame_widgets (FRAME_PTR f
)
1119 GtkWidget
*wvbox
, *whbox
;
1128 if (FRAME_X_EMBEDDED_P (f
))
1130 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1131 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1134 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1136 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1137 has backported it to Gtk+ 2.0 and they add the resize grip for
1138 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1139 forever, so disable the grip. */
1140 #if GTK_MAJOR_VERSION < 3 && defined (HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1141 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1144 xg_set_screen (wtop
, f
);
1146 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1147 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1148 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1149 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1152 wfixed
= emacs_fixed_new (f
);
1154 wfixed
= gtk_fixed_new ();
1157 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1159 if (wtop
) gtk_widget_destroy (wtop
);
1160 if (wvbox
) gtk_widget_destroy (wvbox
);
1161 if (whbox
) gtk_widget_destroy (whbox
);
1162 if (wfixed
) gtk_widget_destroy (wfixed
);
1168 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1169 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1170 gtk_widget_set_name (wvbox
, "pane");
1171 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1173 /* If this frame has a title or name, set it in the title bar. */
1174 if (! NILP (f
->title
))
1175 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1176 else if (! NILP (f
->name
))
1177 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1179 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1181 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1182 FRAME_GTK_WIDGET (f
) = wfixed
;
1183 f
->output_data
.x
->vbox_widget
= wvbox
;
1184 f
->output_data
.x
->hbox_widget
= whbox
;
1186 gtk_widget_set_has_window (wfixed
, TRUE
);
1188 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1189 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1190 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1192 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1193 update_frame_tool_bar (f
);
1195 /* We don't want this widget double buffered, because we draw on it
1196 with regular X drawing primitives, so from a GTK/GDK point of
1197 view, the widget is totally blank. When an expose comes, this
1198 will make the widget blank, and then Emacs redraws it. This flickers
1199 a lot, so we turn off double buffering. */
1200 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1202 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1203 SSDATA (Vx_resource_name
),
1204 SSDATA (Vx_resource_class
));
1206 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1207 GTK is to destroy the widget. We want Emacs to do that instead. */
1208 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1209 G_CALLBACK (delete_cb
), f
);
1211 /* Convert our geometry parameters into a geometry string
1213 GTK will itself handle calculating the real position this way. */
1214 xg_set_geometry (f
);
1216 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1218 gtk_widget_add_events (wfixed
,
1219 GDK_POINTER_MOTION_MASK
1221 | GDK_BUTTON_PRESS_MASK
1222 | GDK_BUTTON_RELEASE_MASK
1223 | GDK_KEY_PRESS_MASK
1224 | GDK_ENTER_NOTIFY_MASK
1225 | GDK_LEAVE_NOTIFY_MASK
1226 | GDK_FOCUS_CHANGE_MASK
1227 | GDK_STRUCTURE_MASK
1228 | GDK_VISIBILITY_NOTIFY_MASK
);
1230 /* Must realize the windows so the X window gets created. It is used
1231 by callers of this function. */
1232 gtk_widget_realize (wfixed
);
1233 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1235 /* Since GTK clears its window by filling with the background color,
1236 we must keep X and GTK background in sync. */
1237 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1240 /* Also, do not let any background pixmap to be set, this looks very
1241 bad as Emacs overwrites the background pixmap with its own idea
1242 of background color. */
1243 style
= gtk_widget_get_modifier_style (wfixed
);
1245 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1246 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1247 gtk_widget_modify_style (wfixed
, style
);
1249 gtk_widget_set_can_focus (wfixed
, TRUE
);
1250 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1253 #ifdef USE_GTK_TOOLTIP
1254 /* Steal a tool tip window we can move ourselves. */
1255 f
->output_data
.x
->ttip_widget
= 0;
1256 f
->output_data
.x
->ttip_lbl
= 0;
1257 f
->output_data
.x
->ttip_window
= 0;
1258 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1259 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1263 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1264 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1265 /* Only connect this signal once per screen. */
1266 if (! g_signal_handler_find (G_OBJECT (gs
),
1267 G_SIGNAL_MATCH_FUNC
,
1269 G_CALLBACK (style_changed_cb
),
1272 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1273 G_CALLBACK (style_changed_cb
),
1274 gdk_screen_get_display (screen
));
1284 xg_free_frame_widgets (FRAME_PTR f
)
1286 if (FRAME_GTK_OUTER_WIDGET (f
))
1288 #ifdef USE_GTK_TOOLTIP
1289 struct x_output
*x
= f
->output_data
.x
;
1291 struct xg_frame_tb_info
*tbinfo
1292 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1297 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1298 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1299 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1300 #ifdef USE_GTK_TOOLTIP
1302 gtk_widget_destroy (x
->ttip_lbl
);
1304 g_object_unref (G_OBJECT (x
->ttip_widget
));
1309 /* Set the normal size hints for the window manager, for frame F.
1310 FLAGS is the flags word to use--or 0 meaning preserve the flags
1311 that the window now has.
1312 If USER_POSITION is nonzero, we set the User Position
1313 flag (this is useful when FLAGS is 0). */
1316 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
1318 /* Must use GTK routines here, otherwise GTK resets the size hints
1319 to its own defaults. */
1320 GdkGeometry size_hints
;
1321 gint hint_flags
= 0;
1322 int base_width
, base_height
;
1323 int min_rows
= 0, min_cols
= 0;
1324 int win_gravity
= f
->win_gravity
;
1326 /* Don't set size hints during initialization; that apparently leads
1327 to a race condition. See the thread at
1328 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1329 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1334 memset (&size_hints
, 0, sizeof (size_hints
));
1335 f
->output_data
.x
->size_hints
= size_hints
;
1336 f
->output_data
.x
->hint_flags
= hint_flags
;
1339 flags
= f
->size_hint_flags
;
1341 size_hints
= f
->output_data
.x
->size_hints
;
1342 hint_flags
= f
->output_data
.x
->hint_flags
;
1344 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1345 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1346 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1348 hint_flags
|= GDK_HINT_BASE_SIZE
;
1349 /* Use one row/col here so base_height/width does not become zero.
1350 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1351 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1352 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1353 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1355 check_frame_size (f
, &min_rows
, &min_cols
);
1356 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1357 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1359 size_hints
.base_width
= base_width
;
1360 size_hints
.base_height
= base_height
;
1361 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1362 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1364 /* These currently have a one to one mapping with the X values, but I
1365 don't think we should rely on that. */
1366 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1367 size_hints
.win_gravity
= 0;
1368 if (win_gravity
== NorthWestGravity
)
1369 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1370 else if (win_gravity
== NorthGravity
)
1371 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1372 else if (win_gravity
== NorthEastGravity
)
1373 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1374 else if (win_gravity
== WestGravity
)
1375 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1376 else if (win_gravity
== CenterGravity
)
1377 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1378 else if (win_gravity
== EastGravity
)
1379 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1380 else if (win_gravity
== SouthWestGravity
)
1381 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1382 else if (win_gravity
== SouthGravity
)
1383 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1384 else if (win_gravity
== SouthEastGravity
)
1385 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1386 else if (win_gravity
== StaticGravity
)
1387 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1391 hint_flags
&= ~GDK_HINT_POS
;
1392 hint_flags
|= GDK_HINT_USER_POS
;
1395 if (hint_flags
!= f
->output_data
.x
->hint_flags
1396 || memcmp (&size_hints
,
1397 &f
->output_data
.x
->size_hints
,
1398 sizeof (size_hints
)) != 0)
1401 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1402 NULL
, &size_hints
, hint_flags
);
1403 f
->output_data
.x
->size_hints
= size_hints
;
1404 f
->output_data
.x
->hint_flags
= hint_flags
;
1409 /* Change background color of a frame.
1410 Since GTK uses the background color to clear the window, we must
1411 keep the GTK and X colors in sync.
1412 F is the frame to change,
1413 BG is the pixel value to change to. */
1416 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
1418 if (FRAME_GTK_WIDGET (f
))
1421 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1427 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1428 functions so GTK does not overwrite the icon. */
1431 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1433 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1437 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1442 /***********************************************************************
1444 ***********************************************************************/
1445 /* Return the dialog title to use for a dialog of type KEY.
1446 This is the encoding used by lwlib. We use the same for GTK. */
1449 get_dialog_title (char key
)
1451 const char *title
= "";
1459 title
= "Information";
1478 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1479 the dialog, but return TRUE so the event does not propagate further
1480 in GTK. This prevents GTK from destroying the dialog widget automatically
1481 and we can always destroy the widget manually, regardless of how
1482 it was popped down (button press or WM_DELETE_WINDOW).
1483 W is the dialog widget.
1484 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1485 user_data is NULL (not used).
1487 Returns TRUE to end propagation of event. */
1490 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1492 gtk_widget_unmap (w
);
1496 /* Create a popup dialog window. See also xg_create_widget below.
1497 WV is a widget_value describing the dialog.
1498 SELECT_CB is the callback to use when a button has been pressed.
1499 DEACTIVATE_CB is the callback to use when the dialog pops down.
1501 Returns the GTK dialog widget. */
1504 create_dialog (widget_value
*wv
,
1505 GCallback select_cb
,
1506 GCallback deactivate_cb
)
1508 const char *title
= get_dialog_title (wv
->name
[0]);
1509 int total_buttons
= wv
->name
[1] - '0';
1510 int right_buttons
= wv
->name
[4] - '0';
1513 int button_spacing
= 10;
1514 GtkWidget
*wdialog
= gtk_dialog_new ();
1515 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1516 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1518 GtkWidget
*whbox_down
;
1520 /* If the number of buttons is greater than 4, make two rows of buttons
1521 instead. This looks better. */
1522 int make_two_rows
= total_buttons
> 4;
1524 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1525 left_buttons
= total_buttons
- right_buttons
;
1527 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1528 gtk_widget_set_name (wdialog
, "emacs-dialog");
1533 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1534 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1535 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1536 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1537 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1538 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1540 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1541 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1542 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1544 cur_box
= GTK_BOX (whbox_up
);
1547 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1548 G_CALLBACK (dialog_delete_callback
), 0);
1552 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1553 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1556 for (item
= wv
->contents
; item
; item
= item
->next
)
1558 char *utf8_label
= get_utf8_string (item
->value
);
1562 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1564 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1565 /* This is the text part of the dialog. */
1566 w
= gtk_label_new (utf8_label
);
1567 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1568 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1569 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1571 /* Try to make dialog look better. Must realize first so
1572 the widget can calculate the size it needs. */
1573 gtk_widget_realize (w
);
1574 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1575 gtk_box_set_spacing (wvbox
, req
.height
);
1576 if (item
->value
&& strlen (item
->value
) > 0)
1577 button_spacing
= 2*req
.width
/strlen (item
->value
);
1581 /* This is one button to add to the dialog. */
1582 w
= gtk_button_new_with_label (utf8_label
);
1583 if (! item
->enabled
)
1584 gtk_widget_set_sensitive (w
, FALSE
);
1586 g_signal_connect (G_OBJECT (w
), "clicked",
1587 select_cb
, item
->call_data
);
1589 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1590 if (++button_nr
== left_buttons
)
1593 cur_box
= GTK_BOX (whbox_down
);
1595 gtk_box_pack_start (cur_box
,
1603 g_free (utf8_label
);
1609 struct xg_dialog_data
1617 /* Function that is called when the file or font dialogs pop down.
1618 W is the dialog widget, RESPONSE is the response code.
1619 USER_DATA is what we passed in to g_signal_connect. */
1622 xg_dialog_response_cb (GtkDialog
*w
,
1626 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1627 dd
->response
= response
;
1628 g_main_loop_quit (dd
->loop
);
1632 /* Destroy the dialog. This makes it pop down. */
1635 pop_down_dialog (Lisp_Object arg
)
1637 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1638 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1641 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1642 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1644 g_main_loop_quit (dd
->loop
);
1645 g_main_loop_unref (dd
->loop
);
1652 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1653 We pass in DATA as gpointer* so we can use this as a callback. */
1656 xg_maybe_add_timer (gpointer data
)
1658 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1659 EMACS_TIME next_time
= timer_check ();
1663 if (EMACS_TIME_VALID_P (next_time
))
1665 time_t s
= EMACS_SECS (next_time
);
1666 int per_ms
= EMACS_TIME_RESOLUTION
/ 1000;
1667 int ms
= (EMACS_NSECS (next_time
) + per_ms
- 1) / per_ms
;
1668 if (s
<= ((guint
) -1 - ms
) / 1000)
1669 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1675 /* Pops up a modal dialog W and waits for response.
1676 We don't use gtk_dialog_run because we want to process emacs timers.
1677 The dialog W is not destroyed when this function returns. */
1680 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1682 ptrdiff_t count
= SPECPDL_INDEX ();
1683 struct xg_dialog_data dd
;
1685 xg_set_screen (w
, f
);
1686 gtk_window_set_transient_for (GTK_WINDOW (w
),
1687 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1688 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1689 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1691 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1692 dd
.response
= GTK_RESPONSE_CANCEL
;
1696 g_signal_connect (G_OBJECT (w
),
1698 G_CALLBACK (xg_dialog_response_cb
),
1700 /* Don't destroy the widget if closed by the window manager close button. */
1701 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1702 gtk_widget_show (w
);
1704 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1706 (void) xg_maybe_add_timer (&dd
);
1707 g_main_loop_run (dd
.loop
);
1710 unbind_to (count
, Qnil
);
1716 /***********************************************************************
1717 File dialog functions
1718 ***********************************************************************/
1719 /* Return non-zero if the old file selection dialog is being used.
1720 Return zero if not. */
1723 xg_uses_old_file_dialog (void)
1725 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1726 return x_gtk_use_old_file_dialog
;
1733 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1735 /* Return the selected file for file chooser dialog W.
1736 The returned string must be free:d. */
1739 xg_get_file_name_from_chooser (GtkWidget
*w
)
1741 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1744 /* Callback called when the "Show hidden files" toggle is pressed.
1745 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1748 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1750 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1752 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1753 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1757 /* Callback called when a property changes in a file chooser.
1758 GOBJECT is the file chooser dialog, ARG1 describes the property.
1759 USER_DATA is the toggle widget in the file chooser dialog.
1760 We use this to update the "Show hidden files" toggle when the user
1761 changes that property by right clicking in the file list. */
1764 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1766 if (strcmp (arg1
->name
, "show-hidden") == 0)
1768 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1769 gboolean visible
, toggle_on
;
1771 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1772 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1774 if (!!visible
!= !!toggle_on
)
1776 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1777 G_CALLBACK (xg_toggle_visibility_cb
),
1779 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1780 g_signal_handlers_unblock_by_func
1781 (G_OBJECT (wtoggle
),
1782 G_CALLBACK (xg_toggle_visibility_cb
),
1785 x_gtk_show_hidden_files
= visible
;
1789 /* Read a file name from the user using a file chooser dialog.
1790 F is the current frame.
1791 PROMPT is a prompt to show to the user. May not be NULL.
1792 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1793 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1794 file. (Actually, this only has cosmetic effects, the user can
1795 still enter a non-existing file.) *FUNC is set to a function that
1796 can be used to retrieve the selected file name from the returned widget.
1798 Returns the created widget. */
1801 xg_get_file_with_chooser (FRAME_PTR f
,
1803 char *default_filename
,
1804 int mustmatch_p
, int only_dir_p
,
1805 xg_get_file_func
*func
)
1809 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1810 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1811 GtkFileChooserAction action
= (mustmatch_p
?
1812 GTK_FILE_CHOOSER_ACTION_OPEN
:
1813 GTK_FILE_CHOOSER_ACTION_SAVE
);
1816 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1818 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1819 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1820 (mustmatch_p
|| only_dir_p
?
1821 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1824 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1826 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1827 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1828 gtk_widget_show (wbox
);
1829 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1831 if (x_gtk_show_hidden_files
)
1833 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1834 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1836 gtk_widget_show (wtoggle
);
1837 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1838 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1839 g_signal_connect (G_OBJECT (filewin
), "notify",
1840 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1842 if (x_gtk_file_dialog_help_text
)
1845 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1846 Show the C-l help text only for versions < 2.10. */
1847 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1848 strcat (msgbuf
, "\nType C-l to display a file name text entry box.\n");
1849 strcat (msgbuf
, "\nIf you don't like this file selector, use the "
1850 "corresponding\nkey binding or customize "
1851 "use-file-dialog to turn it off.");
1853 wmessage
= gtk_label_new (msgbuf
);
1854 gtk_widget_show (wmessage
);
1857 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1858 if (x_gtk_file_dialog_help_text
)
1859 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1860 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1862 if (default_filename
)
1865 struct gcpro gcpro1
;
1866 char *utf8_filename
;
1869 file
= build_string (default_filename
);
1871 /* File chooser does not understand ~/... in the file name. It must be
1872 an absolute name starting with /. */
1873 if (default_filename
[0] != '/')
1874 file
= Fexpand_file_name (file
, Qnil
);
1876 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1877 if (! NILP (Ffile_directory_p (file
)))
1878 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1882 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1884 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1886 char *cp
= strrchr (utf8_filename
, '/');
1888 else cp
= utf8_filename
;
1889 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1896 *func
= xg_get_file_name_from_chooser
;
1900 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1902 /* Return the selected file for file selector dialog W.
1903 The returned string must be free:d. */
1906 xg_get_file_name_from_selector (GtkWidget
*w
)
1908 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1909 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1912 /* Create a file selection dialog.
1913 F is the current frame.
1914 PROMPT is a prompt to show to the user. May not be NULL.
1915 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1916 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1917 file. *FUNC is set to a function that can be used to retrieve the
1918 selected file name from the returned widget.
1920 Returns the created widget. */
1923 xg_get_file_with_selection (FRAME_PTR f
,
1925 char *default_filename
,
1926 int mustmatch_p
, int only_dir_p
,
1927 xg_get_file_func
*func
)
1930 GtkFileSelection
*filesel
;
1932 filewin
= gtk_file_selection_new (prompt
);
1933 filesel
= GTK_FILE_SELECTION (filewin
);
1935 if (default_filename
)
1936 gtk_file_selection_set_filename (filesel
, default_filename
);
1940 /* The selection_entry part of filesel is not documented. */
1941 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1942 gtk_file_selection_hide_fileop_buttons (filesel
);
1945 *func
= xg_get_file_name_from_selector
;
1949 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1951 /* Read a file name from the user using a file dialog, either the old
1952 file selection dialog, or the new file chooser dialog. Which to use
1953 depends on what the GTK version used has, and what the value of
1954 gtk-use-old-file-dialog.
1955 F is the current frame.
1956 PROMPT is a prompt to show to the user. May not be NULL.
1957 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1958 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1961 Returns a file name or NULL if no file was selected.
1962 The returned string must be freed by the caller. */
1965 xg_get_file_name (FRAME_PTR f
,
1967 char *default_filename
,
1973 int filesel_done
= 0;
1974 xg_get_file_func func
;
1976 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1978 if (xg_uses_old_file_dialog ())
1979 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1980 mustmatch_p
, only_dir_p
, &func
);
1982 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1983 mustmatch_p
, only_dir_p
, &func
);
1985 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1986 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1987 mustmatch_p
, only_dir_p
, &func
);
1988 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1990 gtk_widget_set_name (w
, "emacs-filedialog");
1992 filesel_done
= xg_dialog_run (f
, w
);
1993 if (filesel_done
== GTK_RESPONSE_OK
)
1996 gtk_widget_destroy (w
);
2000 /***********************************************************************
2002 ***********************************************************************/
2004 #ifdef HAVE_FREETYPE
2006 #if USE_NEW_GTK_FONT_CHOOSER
2008 #define XG_WEIGHT_TO_SYMBOL(w) \
2009 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
2010 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
2011 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
2012 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
2013 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
2014 : w <= PANGO_WEIGHT_BOLD ? Qbold \
2015 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
2018 #define XG_STYLE_TO_SYMBOL(s) \
2019 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
2020 : s == PANGO_STYLE_ITALIC ? Qitalic \
2023 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2026 static char *x_last_font_name
;
2027 extern Lisp_Object Qxft
;
2029 /* Pop up a GTK font selector and return the name of the font the user
2030 selects, as a C string. The returned font name follows GTK's own
2033 `FAMILY [VALUE1 VALUE2] SIZE'
2035 This can be parsed using font_parse_fcname in font.c.
2036 DEFAULT_NAME, if non-zero, is the default font name. */
2039 xg_get_font (FRAME_PTR f
, const char *default_name
)
2043 Lisp_Object font
= Qnil
;
2045 w
= gtk_font_chooser_dialog_new
2046 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2050 /* Convert fontconfig names to Gtk names, i.e. remove - before
2052 char *p
= strrchr (default_name
, '-');
2056 while (c_isdigit (*ep
))
2058 if (*ep
== '\0') *p
= ' ';
2061 else if (x_last_font_name
)
2062 default_name
= x_last_font_name
;
2065 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2067 gtk_widget_set_name (w
, "emacs-fontdialog");
2068 done
= xg_dialog_run (f
, w
);
2069 if (done
== GTK_RESPONSE_OK
)
2071 #if USE_NEW_GTK_FONT_CHOOSER
2072 /* Use the GTK3 font chooser. */
2073 PangoFontDescription
*desc
2074 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2078 Lisp_Object args
[10];
2079 const char *name
= pango_font_description_get_family (desc
);
2080 gint size
= pango_font_description_get_size (desc
);
2081 PangoWeight weight
= pango_font_description_get_weight (desc
);
2082 PangoStyle style
= pango_font_description_get_style (desc
);
2085 args
[1] = build_string (name
);
2088 args
[3] = make_float (pango_units_to_double (size
));
2091 args
[5] = XG_WEIGHT_TO_SYMBOL (weight
);
2094 args
[7] = XG_STYLE_TO_SYMBOL (style
);
2099 font
= Ffont_spec (8, args
);
2101 pango_font_description_free (desc
);
2102 xfree (x_last_font_name
);
2103 x_last_font_name
= xstrdup (name
);
2106 #else /* Use old font selector, which just returns the font name. */
2109 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2113 font
= build_string (font_name
);
2114 g_free (x_last_font_name
);
2115 x_last_font_name
= font_name
;
2117 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2120 gtk_widget_destroy (w
);
2123 #endif /* HAVE_FREETYPE */
2127 /***********************************************************************
2129 ***********************************************************************/
2131 /* The name of menu items that can be used for customization. Since GTK
2132 RC files are very crude and primitive, we have to set this on all
2133 menu item names so a user can easily customize menu items. */
2135 #define MENU_ITEM_NAME "emacs-menuitem"
2138 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2139 during GC. The next member points to the items. */
2140 static xg_list_node xg_menu_cb_list
;
2142 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2143 during GC. The next member points to the items. */
2144 static xg_list_node xg_menu_item_cb_list
;
2146 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2147 F is the frame CL_DATA will be initialized for.
2148 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2150 The menu bar and all sub menus under the menu bar in a frame
2151 share the same structure, hence the reference count.
2153 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2154 allocated xg_menu_cb_data if CL_DATA is NULL. */
2156 static xg_menu_cb_data
*
2157 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
2161 cl_data
= xmalloc (sizeof *cl_data
);
2163 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2164 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2165 cl_data
->highlight_cb
= highlight_cb
;
2166 cl_data
->ref_count
= 0;
2168 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2171 cl_data
->ref_count
++;
2176 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2177 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2179 When the menu bar is updated, menu items may have been added and/or
2180 removed, so menu_bar_vector and menu_bar_items_used change. We must
2181 then update CL_DATA since it is used to determine which menu
2182 item that is invoked in the menu.
2183 HIGHLIGHT_CB could change, there is no check that the same
2184 function is given when modifying a menu bar as was given when
2185 creating the menu bar. */
2188 update_cl_data (xg_menu_cb_data
*cl_data
,
2190 GCallback highlight_cb
)
2195 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2196 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2197 cl_data
->highlight_cb
= highlight_cb
;
2201 /* Decrease reference count for CL_DATA.
2202 If reference count is zero, free CL_DATA. */
2205 unref_cl_data (xg_menu_cb_data
*cl_data
)
2207 if (cl_data
&& cl_data
->ref_count
> 0)
2209 cl_data
->ref_count
--;
2210 if (cl_data
->ref_count
== 0)
2212 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2218 /* Function that marks all lisp data during GC. */
2224 Lisp_Object rest
, frame
;
2226 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2227 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2229 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2231 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2233 if (! NILP (cb_data
->help
))
2234 mark_object (cb_data
->help
);
2237 FOR_EACH_FRAME (rest
, frame
)
2239 FRAME_PTR f
= XFRAME (frame
);
2241 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2243 struct xg_frame_tb_info
*tbinfo
2244 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2248 mark_object (tbinfo
->last_tool_bar
);
2249 mark_object (tbinfo
->style
);
2256 /* Callback called when a menu item is destroyed. Used to free data.
2257 W is the widget that is being destroyed (not used).
2258 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2261 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2265 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
2266 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2271 /* Callback called when the pointer enters/leaves a menu item.
2272 W is the parent of the menu item.
2273 EVENT is either an enter event or leave event.
2274 CLIENT_DATA is not used.
2276 Returns FALSE to tell GTK to keep processing this event. */
2279 menuitem_highlight_callback (GtkWidget
*w
,
2280 GdkEventCrossing
*event
,
2281 gpointer client_data
)
2284 GtkWidget
*subwidget
;
2285 xg_menu_item_cb_data
*data
;
2287 ev
.crossing
= *event
;
2288 subwidget
= gtk_get_event_widget (&ev
);
2289 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
2293 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2295 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2296 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2297 (*func
) (subwidget
, call_data
);
2304 /* Callback called when a menu is destroyed. Used to free data.
2305 W is the widget that is being destroyed (not used).
2306 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2309 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2311 unref_cl_data ((xg_menu_cb_data
*) client_data
);
2314 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2315 must be non-NULL) and can be inserted into a menu item.
2317 Returns the GtkHBox. */
2320 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2326 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2327 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2328 wlbl
= gtk_label_new (utf8_label
);
2329 wkey
= gtk_label_new (utf8_key
);
2331 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2332 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2334 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2335 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2337 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2338 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2339 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2344 /* Make and return a menu item widget with the key to the right.
2345 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2346 UTF8_KEY is the text representing the key binding.
2347 ITEM is the widget_value describing the menu item.
2349 GROUP is an in/out parameter. If the menu item to be created is not
2350 part of any radio menu group, *GROUP contains NULL on entry and exit.
2351 If the menu item to be created is part of a radio menu group, on entry
2352 *GROUP contains the group to use, or NULL if this is the first item
2353 in the group. On exit, *GROUP contains the radio item group.
2355 Unfortunately, keys don't line up as nicely as in Motif,
2356 but the MacOS X version doesn't either, so I guess that is OK. */
2359 make_menu_item (const char *utf8_label
,
2360 const char *utf8_key
,
2365 GtkWidget
*wtoadd
= 0;
2367 /* It has been observed that some menu items have a NULL name field.
2368 This will lead to this function being called with a NULL utf8_label.
2369 GTK crashes on that so we set a blank label. Why there is a NULL
2370 name remains to be investigated. */
2371 if (! utf8_label
) utf8_label
= " ";
2374 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2376 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2379 if (utf8_key
) w
= gtk_check_menu_item_new ();
2380 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2381 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2383 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2385 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2386 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2387 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2389 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2394 if (utf8_key
) w
= gtk_menu_item_new ();
2395 else w
= gtk_menu_item_new_with_label (utf8_label
);
2398 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2399 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2404 static int xg_detached_menus
;
2406 /* Returns non-zero if there are detached menus. */
2409 xg_have_tear_offs (void)
2411 return xg_detached_menus
> 0;
2414 /* Callback invoked when a detached menu window is removed. Here we
2415 decrease the xg_detached_menus count.
2416 WIDGET is the top level window that is removed (the parent of the menu).
2417 CLIENT_DATA is not used. */
2420 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2422 if (xg_detached_menus
> 0) --xg_detached_menus
;
2425 /* Callback invoked when a menu is detached. It increases the
2426 xg_detached_menus count.
2427 WIDGET is the GtkTearoffMenuItem.
2428 CLIENT_DATA is not used. */
2431 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2433 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2434 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2436 ++xg_detached_menus
;
2437 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2439 G_CALLBACK (tearoff_remove
), 0);
2444 /* Create a menu item widget, and connect the callbacks.
2445 ITEM describes the menu item.
2446 F is the frame the created menu belongs to.
2447 SELECT_CB is the callback to use when a menu item is selected.
2448 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2449 CL_DATA points to the callback data to be used for this menu.
2450 GROUP is an in/out parameter. If the menu item to be created is not
2451 part of any radio menu group, *GROUP contains NULL on entry and exit.
2452 If the menu item to be created is part of a radio menu group, on entry
2453 *GROUP contains the group to use, or NULL if this is the first item
2454 in the group. On exit, *GROUP contains the radio item group.
2456 Returns the created GtkWidget. */
2459 xg_create_one_menuitem (widget_value
*item
,
2461 GCallback select_cb
,
2462 GCallback highlight_cb
,
2463 xg_menu_cb_data
*cl_data
,
2469 xg_menu_item_cb_data
*cb_data
;
2471 utf8_label
= get_utf8_string (item
->name
);
2472 utf8_key
= get_utf8_string (item
->key
);
2474 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2476 if (utf8_label
) g_free (utf8_label
);
2477 if (utf8_key
) g_free (utf8_key
);
2479 cb_data
= xmalloc (sizeof *cb_data
);
2481 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2483 cb_data
->select_id
= 0;
2484 cb_data
->help
= item
->help
;
2485 cb_data
->cl_data
= cl_data
;
2486 cb_data
->call_data
= item
->call_data
;
2488 g_signal_connect (G_OBJECT (w
),
2490 G_CALLBACK (menuitem_destroy_callback
),
2493 /* Put cb_data in widget, so we can get at it when modifying menubar */
2494 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2496 /* final item, not a submenu */
2497 if (item
->call_data
&& ! item
->contents
)
2501 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2507 /* Create a full menu tree specified by DATA.
2508 F is the frame the created menu belongs to.
2509 SELECT_CB is the callback to use when a menu item is selected.
2510 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2511 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2512 POP_UP_P is non-zero if we shall create a popup menu.
2513 MENU_BAR_P is non-zero if we shall create a menu bar.
2514 ADD_TEAROFF_P is non-zero if we shall add a tearoff menu item. Ignored
2515 if MENU_BAR_P is non-zero.
2516 TOPMENU is the topmost GtkWidget that others shall be placed under.
2517 It may be NULL, in that case we create the appropriate widget
2518 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2519 CL_DATA is the callback data we shall use for this menu, or NULL
2520 if we haven't set the first callback yet.
2521 NAME is the name to give to the top level menu if this function
2522 creates it. May be NULL to not set any name.
2524 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2527 This function calls itself to create submenus. */
2530 create_menus (widget_value
*data
,
2532 GCallback select_cb
,
2533 GCallback deactivate_cb
,
2534 GCallback highlight_cb
,
2539 xg_menu_cb_data
*cl_data
,
2543 GtkWidget
*wmenu
= topmenu
;
2544 GSList
*group
= NULL
;
2550 wmenu
= gtk_menu_new ();
2551 xg_set_screen (wmenu
, f
);
2552 /* Connect this to the menu instead of items so we get enter/leave for
2553 disabled items also. TODO: Still does not get enter/leave for
2554 disabled items in detached menus. */
2555 g_signal_connect (G_OBJECT (wmenu
),
2556 "enter-notify-event",
2557 G_CALLBACK (menuitem_highlight_callback
),
2559 g_signal_connect (G_OBJECT (wmenu
),
2560 "leave-notify-event",
2561 G_CALLBACK (menuitem_highlight_callback
),
2566 wmenu
= gtk_menu_bar_new ();
2567 /* Set width of menu bar to a small value so it doesn't enlarge
2568 a small initial frame size. The width will be set to the
2569 width of the frame later on when it is added to a container.
2570 height -1: Natural height. */
2571 gtk_widget_set_size_request (wmenu
, 1, -1);
2574 /* Put cl_data on the top menu for easier access. */
2575 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2576 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2577 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2578 G_CALLBACK (menu_destroy_callback
), cl_data
);
2581 gtk_widget_set_name (wmenu
, name
);
2584 g_signal_connect (G_OBJECT (wmenu
),
2585 "selection-done", deactivate_cb
, 0);
2588 if (! menu_bar_p
&& add_tearoff_p
)
2590 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2591 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2593 g_signal_connect (G_OBJECT (tearoff
), "activate",
2594 G_CALLBACK (tearoff_activate
), 0);
2597 for (item
= data
; item
; item
= item
->next
)
2601 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2602 && !menu_separator_name_p (item
->name
))
2605 /* A title for a popup. We do the same as GTK does when
2606 creating titles, but it does not look good. */
2608 utf8_label
= get_utf8_string (item
->name
);
2610 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2611 w
= gtk_menu_item_new_with_label (utf8_label
);
2612 gtk_widget_set_sensitive (w
, FALSE
);
2613 if (utf8_label
) g_free (utf8_label
);
2615 else if (menu_separator_name_p (item
->name
))
2618 /* GTK only have one separator type. */
2619 w
= gtk_separator_menu_item_new ();
2623 w
= xg_create_one_menuitem (item
,
2625 item
->contents
? 0 : select_cb
,
2630 /* Create a possibly empty submenu for menu bar items, since some
2631 themes don't highlight items correctly without it. */
2632 if (item
->contents
|| menu_bar_p
)
2634 GtkWidget
*submenu
= create_menus (item
->contents
,
2645 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2649 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2650 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2656 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2657 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2658 with some text and buttons.
2659 F is the frame the created item belongs to.
2660 NAME is the name to use for the top widget.
2661 VAL is a widget_value structure describing items to be created.
2662 SELECT_CB is the callback to use when a menu item is selected or
2663 a dialog button is pressed.
2664 DEACTIVATE_CB is the callback to use when an item is deactivated.
2665 For a menu, when a sub menu is not shown anymore, for a dialog it is
2666 called when the dialog is popped down.
2667 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2669 Returns the widget created. */
2672 xg_create_widget (const char *type
, const char *name
, FRAME_PTR f
, widget_value
*val
,
2673 GCallback select_cb
, GCallback deactivate_cb
,
2674 GCallback highlight_cb
)
2677 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2678 int pop_up_p
= strcmp (type
, "popup") == 0;
2680 if (strcmp (type
, "dialog") == 0)
2682 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2683 xg_set_screen (w
, f
);
2684 gtk_window_set_transient_for (GTK_WINDOW (w
),
2685 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2686 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2687 gtk_widget_set_name (w
, "emacs-dialog");
2688 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2690 else if (menu_bar_p
|| pop_up_p
)
2692 w
= create_menus (val
->contents
,
2704 /* Set the cursor to an arrow for popup menus when they are mapped.
2705 This is done by default for menu bar menus. */
2708 /* Must realize so the GdkWindow inside the widget is created. */
2709 gtk_widget_realize (w
);
2710 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2715 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2722 /* Return the label for menu item WITEM. */
2725 xg_get_menu_item_label (GtkMenuItem
*witem
)
2727 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2728 return gtk_label_get_label (wlabel
);
2731 /* Return non-zero if the menu item WITEM has the text LABEL. */
2734 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2737 char *utf8_label
= get_utf8_string (label
);
2738 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2740 if (! old_label
&& ! utf8_label
)
2742 else if (old_label
&& utf8_label
)
2743 is_same
= strcmp (utf8_label
, old_label
) == 0;
2745 if (utf8_label
) g_free (utf8_label
);
2750 /* Destroy widgets in LIST. */
2753 xg_destroy_widgets (GList
*list
)
2757 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2759 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2761 /* Destroying the widget will remove it from the container it is in. */
2762 gtk_widget_destroy (w
);
2766 /* Update the top level names in MENUBAR (i.e. not submenus).
2767 F is the frame the menu bar belongs to.
2768 *LIST is a list with the current menu bar names (menu item widgets).
2769 ITER is the item within *LIST that shall be updated.
2770 POS is the numerical position, starting at 0, of ITER in *LIST.
2771 VAL describes what the menu bar shall look like after the update.
2772 SELECT_CB is the callback to use when a menu item is selected.
2773 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2774 CL_DATA points to the callback data to be used for this menu bar.
2776 This function calls itself to walk through the menu bar names. */
2779 xg_update_menubar (GtkWidget
*menubar
,
2785 GCallback select_cb
,
2786 GCallback deactivate_cb
,
2787 GCallback highlight_cb
,
2788 xg_menu_cb_data
*cl_data
)
2790 if (! iter
&& ! val
)
2792 else if (iter
&& ! val
)
2794 /* Item(s) have been removed. Remove all remaining items. */
2795 xg_destroy_widgets (iter
);
2797 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2798 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2799 gtk_menu_item_new_with_label (""),
2805 else if (! iter
&& val
)
2807 /* Item(s) added. Add all new items in one call. */
2808 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2809 0, 1, 0, menubar
, cl_data
, 0);
2815 /* Below this neither iter or val is NULL */
2816 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2818 /* This item is still the same, check next item. */
2820 iter
= g_list_next (iter
);
2823 else /* This item is changed. */
2825 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2826 GtkMenuItem
*witem2
= 0;
2827 int val_in_menubar
= 0;
2828 int iter_in_new_menubar
= 0;
2832 /* See if the changed entry (val) is present later in the menu bar */
2834 iter2
&& ! val_in_menubar
;
2835 iter2
= g_list_next (iter2
))
2837 witem2
= GTK_MENU_ITEM (iter2
->data
);
2838 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2841 /* See if the current entry (iter) is present later in the
2842 specification for the new menu bar. */
2843 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2844 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2846 if (val_in_menubar
&& ! iter_in_new_menubar
)
2850 /* This corresponds to:
2855 g_object_ref (G_OBJECT (witem
));
2856 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2857 gtk_widget_destroy (GTK_WIDGET (witem
));
2859 /* Must get new list since the old changed. */
2860 g_list_free (*list
);
2861 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2862 while (nr
-- > 0) iter
= g_list_next (iter
);
2864 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2866 /* This corresponds to:
2869 Rename B to X. This might seem to be a strange thing to do,
2870 since if there is a menu under B it will be totally wrong for X.
2871 But consider editing a C file. Then there is a C-mode menu
2872 (corresponds to B above).
2873 If then doing C-x C-f the minibuf menu (X above) replaces the
2874 C-mode menu. When returning from the minibuffer, we get
2875 back the C-mode menu. Thus we do:
2876 Rename B to X (C-mode to minibuf menu)
2877 Rename X to B (minibuf to C-mode menu).
2878 If the X menu hasn't been invoked, the menu under B
2879 is up to date when leaving the minibuffer. */
2880 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2881 char *utf8_label
= get_utf8_string (val
->name
);
2882 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2884 gtk_label_set_text (wlabel
, utf8_label
);
2886 /* If this item has a submenu that has been detached, change
2887 the title in the WM decorations also. */
2888 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2889 /* Set the title of the detached window. */
2890 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2892 if (utf8_label
) g_free (utf8_label
);
2893 iter
= g_list_next (iter
);
2897 else if (! val_in_menubar
&& iter_in_new_menubar
)
2899 /* This corresponds to:
2906 GtkWidget
*w
= xg_create_one_menuitem (val
,
2913 /* Create a possibly empty submenu for menu bar items, since some
2914 themes don't highlight items correctly without it. */
2915 GtkWidget
*submenu
= create_menus (NULL
, f
,
2916 select_cb
, deactivate_cb
,
2918 0, 0, 0, 0, cl_data
, 0);
2919 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2920 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2921 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2923 g_list_free (*list
);
2924 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2925 while (nr
-- > 0) iter
= g_list_next (iter
);
2926 iter
= g_list_next (iter
);
2930 else /* if (val_in_menubar && iter_in_new_menubar) */
2933 /* This corresponds to:
2938 g_object_ref (G_OBJECT (witem2
));
2939 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2940 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2941 GTK_WIDGET (witem2
), pos
);
2942 g_object_unref (G_OBJECT (witem2
));
2944 g_list_free (*list
);
2945 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2946 while (nr
-- > 0) iter
= g_list_next (iter
);
2947 if (iter
) iter
= g_list_next (iter
);
2953 /* Update the rest of the menu bar. */
2954 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2955 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2958 /* Update the menu item W so it corresponds to VAL.
2959 SELECT_CB is the callback to use when a menu item is selected.
2960 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2961 CL_DATA is the data to set in the widget for menu invocation. */
2964 xg_update_menu_item (widget_value
*val
,
2966 GCallback select_cb
,
2967 GCallback highlight_cb
,
2968 xg_menu_cb_data
*cl_data
)
2975 const char *old_label
= 0;
2976 const char *old_key
= 0;
2977 xg_menu_item_cb_data
*cb_data
;
2979 wchild
= XG_BIN_CHILD (w
);
2980 utf8_label
= get_utf8_string (val
->name
);
2981 utf8_key
= get_utf8_string (val
->key
);
2983 /* See if W is a menu item with a key. See make_menu_item above. */
2984 if (GTK_IS_BOX (wchild
))
2986 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2988 wlbl
= GTK_LABEL (list
->data
);
2989 wkey
= GTK_LABEL (list
->next
->data
);
2994 /* Remove the key and keep just the label. */
2995 g_object_ref (G_OBJECT (wlbl
));
2996 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2997 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2998 g_object_unref (G_OBJECT (wlbl
));
3003 else /* Just a label. */
3005 wlbl
= GTK_LABEL (wchild
);
3007 /* Check if there is now a key. */
3010 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
3011 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
3013 wlbl
= GTK_LABEL (list
->data
);
3014 wkey
= GTK_LABEL (list
->next
->data
);
3017 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3018 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3023 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3024 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3026 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3027 gtk_label_set_text (wkey
, utf8_key
);
3029 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3030 gtk_label_set_text (wlbl
, utf8_label
);
3032 if (utf8_key
) g_free (utf8_key
);
3033 if (utf8_label
) g_free (utf8_label
);
3035 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3036 gtk_widget_set_sensitive (w
, FALSE
);
3037 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3038 gtk_widget_set_sensitive (w
, TRUE
);
3040 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
3044 cb_data
->call_data
= val
->call_data
;
3045 cb_data
->help
= val
->help
;
3046 cb_data
->cl_data
= cl_data
;
3048 /* We assume the callback functions don't change. */
3049 if (val
->call_data
&& ! val
->contents
)
3051 /* This item shall have a select callback. */
3052 if (! cb_data
->select_id
)
3054 = g_signal_connect (G_OBJECT (w
), "activate",
3055 select_cb
, cb_data
);
3057 else if (cb_data
->select_id
)
3059 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3060 cb_data
->select_id
= 0;
3065 /* Update the toggle menu item W so it corresponds to VAL. */
3068 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3070 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3073 /* Update the radio menu item W so it corresponds to VAL. */
3076 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3078 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3081 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3082 SUBMENU may be NULL, in that case a new menu is created.
3083 F is the frame the menu bar belongs to.
3084 VAL describes the contents of the menu bar.
3085 SELECT_CB is the callback to use when a menu item is selected.
3086 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3087 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3088 CL_DATA is the call back data to use for any newly created items.
3090 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3094 xg_update_submenu (GtkWidget
*submenu
,
3097 GCallback select_cb
,
3098 GCallback deactivate_cb
,
3099 GCallback highlight_cb
,
3100 xg_menu_cb_data
*cl_data
)
3102 GtkWidget
*newsub
= submenu
;
3106 int has_tearoff_p
= 0;
3107 GList
*first_radio
= 0;
3110 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3112 for (cur
= val
, iter
= list
;
3114 iter
= g_list_next (iter
), cur
= cur
->next
)
3116 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3118 /* Skip tearoff items, they have no counterpart in val. */
3119 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
3122 iter
= g_list_next (iter
);
3123 if (iter
) w
= GTK_WIDGET (iter
->data
);
3127 /* Remember first radio button in a group. If we get a mismatch in
3128 a radio group we must rebuild the whole group so that the connections
3129 in GTK becomes correct. */
3130 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3132 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3133 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3136 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3138 if (! menu_separator_name_p (cur
->name
))
3141 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3143 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3145 xg_update_toggle_item (cur
, w
);
3146 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3148 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3150 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3152 xg_update_radio_item (cur
, w
);
3153 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3155 else if (GTK_IS_MENU_ITEM (w
))
3157 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3160 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3161 menu_separator_name_p (cur
->name
))
3164 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3166 sub
= gtk_menu_item_get_submenu (witem
);
3167 if (sub
&& ! cur
->contents
)
3169 /* Not a submenu anymore. */
3170 g_object_ref (G_OBJECT (sub
));
3171 remove_submenu (witem
);
3172 gtk_widget_destroy (sub
);
3174 else if (cur
->contents
)
3178 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3179 select_cb
, deactivate_cb
,
3180 highlight_cb
, cl_data
);
3182 /* If this item just became a submenu, we must set it. */
3184 gtk_menu_item_set_submenu (witem
, nsub
);
3189 /* Structural difference. Remove everything from here and down
3195 /* Remove widgets from first structural change. */
3198 /* If we are adding new menu items below, we must remove from
3199 first radio button so that radio groups become correct. */
3200 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3201 else xg_destroy_widgets (iter
);
3206 /* More items added. Create them. */
3207 newsub
= create_menus (cur
,
3220 if (list
) g_list_free (list
);
3225 /* Update the MENUBAR.
3226 F is the frame the menu bar belongs to.
3227 VAL describes the contents of the menu bar.
3228 If DEEP_P is non-zero, rebuild all but the top level menu names in
3229 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3230 SELECT_CB is the callback to use when a menu item is selected.
3231 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3232 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3235 xg_modify_menubar_widgets (GtkWidget
*menubar
, FRAME_PTR f
, widget_value
*val
,
3237 GCallback select_cb
, GCallback deactivate_cb
,
3238 GCallback highlight_cb
)
3240 xg_menu_cb_data
*cl_data
;
3241 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3245 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
3248 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3249 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3255 /* Update all sub menus.
3256 We must keep the submenus (GTK menu item widgets) since the
3257 X Window in the XEvent that activates the menu are those widgets. */
3259 /* Update cl_data, menu_item things in F may have changed. */
3260 update_cl_data (cl_data
, f
, highlight_cb
);
3262 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3267 GtkMenuItem
*witem
= 0;
3269 /* Find sub menu that corresponds to val and update it. */
3270 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3272 witem
= GTK_MENU_ITEM (iter
->data
);
3273 if (xg_item_label_same_p (witem
, cur
->name
))
3275 sub
= gtk_menu_item_get_submenu (witem
);
3280 newsub
= xg_update_submenu (sub
,
3287 /* sub may still be NULL. If we just updated non deep and added
3288 a new menu bar item, it has no sub menu yet. So we set the
3289 newly created sub menu under witem. */
3290 if (newsub
!= sub
&& witem
!= 0)
3292 xg_set_screen (newsub
, f
);
3293 gtk_menu_item_set_submenu (witem
, newsub
);
3299 gtk_widget_show_all (menubar
);
3302 /* Callback called when the menu bar W is mapped.
3303 Used to find the height of the menu bar if we didn't get it
3304 after showing the widget. */
3307 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3310 FRAME_PTR f
= (FRAME_PTR
) user_data
;
3311 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3312 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3314 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3315 xg_height_or_width_changed (f
);
3319 /* Recompute all the widgets of frame F, when the menu bar has been
3320 changed. Value is non-zero if widgets were updated. */
3323 xg_update_frame_menubar (FRAME_PTR f
)
3325 struct x_output
*x
= f
->output_data
.x
;
3328 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3331 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3332 return 0; /* Already done this, happens for frames created invisible. */
3336 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3338 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3340 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3341 gtk_widget_show_all (x
->menubar_widget
);
3342 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3344 /* If menu bar doesn't know its height yet, cheat a little so the frame
3345 doesn't jump so much when resized later in menubar_map_cb. */
3346 if (req
.height
== 0)
3349 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3351 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3352 xg_height_or_width_changed (f
);
3359 /* Get rid of the menu bar of frame F, and free its storage.
3360 This is used when deleting a frame, and when turning off the menu bar. */
3363 free_frame_menubar (FRAME_PTR f
)
3365 struct x_output
*x
= f
->output_data
.x
;
3367 if (x
->menubar_widget
)
3371 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3372 /* The menubar and its children shall be deleted when removed from
3374 x
->menubar_widget
= 0;
3375 FRAME_MENUBAR_HEIGHT (f
) = 0;
3376 xg_height_or_width_changed (f
);
3382 xg_event_is_for_menubar (FRAME_PTR f
, XEvent
*event
)
3384 struct x_output
*x
= f
->output_data
.x
;
3393 if (! x
->menubar_widget
) return 0;
3395 if (! (event
->xbutton
.x
>= 0
3396 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3397 && event
->xbutton
.y
>= 0
3398 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3399 && event
->xbutton
.same_screen
))
3402 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3403 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3405 gevent
.any
.window
= gw
;
3406 gevent
.any
.type
= GDK_NOTHING
;
3407 gwdesc
= gtk_get_event_widget (&gevent
);
3408 if (! gwdesc
) return 0;
3409 if (! GTK_IS_MENU_BAR (gwdesc
)
3410 && ! GTK_IS_MENU_ITEM (gwdesc
)
3411 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3414 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3415 if (! list
) return 0;
3416 rec
.x
= event
->xbutton
.x
;
3417 rec
.y
= event
->xbutton
.y
;
3421 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3423 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3424 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3428 return iter
== 0 ? 0 : 1;
3433 /***********************************************************************
3434 Scroll bar functions
3435 ***********************************************************************/
3438 /* Setting scroll bar values invokes the callback. Use this variable
3439 to indicate that callback should do nothing. */
3441 int xg_ignore_gtk_scrollbar
;
3443 /* The width of the scroll bar for the current theme. */
3445 static int scroll_bar_width_for_theme
;
3447 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3448 may be larger than 32 bits. Keep a mapping from integer index to widget
3449 pointers to get around the 32 bit limitation. */
3453 GtkWidget
**widgets
;
3458 /* Grow this much every time we need to allocate more */
3460 #define ID_TO_WIDGET_INCR 32
3462 /* Store the widget pointer W in id_to_widget and return the integer index. */
3465 xg_store_widget_in_map (GtkWidget
*w
)
3469 if (id_to_widget
.max_size
== id_to_widget
.used
)
3472 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3473 memory_full (SIZE_MAX
);
3475 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3476 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3477 new_size
, sizeof (GtkWidget
*));
3479 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3480 id_to_widget
.widgets
[i
] = 0;
3481 id_to_widget
.max_size
= new_size
;
3484 /* Just loop over the array and find a free place. After all,
3485 how many scroll bars are we creating? Should be a small number.
3486 The check above guarantees we will find a free place. */
3487 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3489 if (! id_to_widget
.widgets
[i
])
3491 id_to_widget
.widgets
[i
] = w
;
3492 ++id_to_widget
.used
;
3498 /* Should never end up here */
3502 /* Remove pointer at IDX from id_to_widget.
3503 Called when scroll bar is destroyed. */
3506 xg_remove_widget_from_map (ptrdiff_t idx
)
3508 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3510 id_to_widget
.widgets
[idx
] = 0;
3511 --id_to_widget
.used
;
3515 /* Get the widget pointer at IDX from id_to_widget. */
3518 xg_get_widget_from_map (ptrdiff_t idx
)
3520 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3521 return id_to_widget
.widgets
[idx
];
3527 update_theme_scrollbar_width (void)
3530 GtkAdjustment
*vadj
;
3537 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3538 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3539 g_object_ref_sink (G_OBJECT (wscroll
));
3540 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3541 gtk_widget_destroy (wscroll
);
3542 g_object_unref (G_OBJECT (wscroll
));
3545 scroll_bar_width_for_theme
= w
;
3549 xg_get_default_scrollbar_width (void)
3551 return scroll_bar_width_for_theme
;
3554 /* Return the scrollbar id for X Window WID on display DPY.
3555 Return -1 if WID not in id_to_widget. */
3558 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3563 w
= xg_win_to_widget (dpy
, wid
);
3567 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3568 if (id_to_widget
.widgets
[idx
] == w
)
3575 /* Callback invoked when scroll bar WIDGET is destroyed.
3576 DATA is the index into id_to_widget for WIDGET.
3577 We free pointer to last scroll bar values here and remove the index. */
3580 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3582 intptr_t id
= (intptr_t) data
;
3583 xg_remove_widget_from_map (id
);
3586 /* Create a scroll bar widget for frame F. Store the scroll bar
3588 SCROLL_CALLBACK is the callback to invoke when the value of the
3590 END_CALLBACK is the callback to invoke when scrolling ends.
3591 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3592 to set resources for the widget. */
3595 xg_create_scroll_bar (FRAME_PTR f
,
3596 struct scroll_bar
*bar
,
3597 GCallback scroll_callback
,
3598 GCallback end_callback
,
3599 const char *scroll_bar_name
)
3605 GtkAdjustment
*vadj
;
3610 /* Page, step increment values are not so important here, they
3611 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3612 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3615 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3616 webox
= gtk_event_box_new ();
3617 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3619 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3621 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3623 scroll_id
= xg_store_widget_in_map (wscroll
);
3625 g_signal_connect (G_OBJECT (wscroll
),
3627 G_CALLBACK (xg_gtk_scroll_destroy
),
3628 (gpointer
) scroll_id
);
3629 g_signal_connect (G_OBJECT (wscroll
),
3633 g_signal_connect (G_OBJECT (wscroll
),
3634 "button-release-event",
3638 /* The scroll bar widget does not draw on a window of its own. Instead
3639 it draws on the parent window, in this case the edit widget. So
3640 whenever the edit widget is cleared, the scroll bar needs to redraw
3641 also, which causes flicker. Put an event box between the edit widget
3642 and the scroll bar, so the scroll bar instead draws itself on the
3643 event box window. */
3644 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3645 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3648 /* Set the cursor to an arrow. */
3649 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3651 bar
->x_window
= scroll_id
;
3654 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3657 xg_remove_scroll_bar (FRAME_PTR f
, ptrdiff_t scrollbar_id
)
3659 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3662 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3663 gtk_widget_destroy (w
);
3664 gtk_widget_destroy (wparent
);
3665 SET_FRAME_GARBAGED (f
);
3669 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3671 TOP/LEFT are the new pixel positions where the bar shall appear.
3672 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3675 xg_update_scrollbar_pos (FRAME_PTR f
,
3676 ptrdiff_t scrollbar_id
,
3683 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3687 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3688 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3691 /* Clear out old position. */
3692 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3693 if (gtk_widget_get_parent (wparent
) == wfixed
)
3695 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3696 "x", &oldx
, "y", &oldy
, NULL
);
3697 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3700 /* Move and resize to new values. */
3701 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3702 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3705 /* No room. Hide scroll bar as some themes output a warning if
3706 the height is less than the min size. */
3707 gtk_widget_hide (wparent
);
3708 gtk_widget_hide (wscroll
);
3712 gtk_widget_show_all (wparent
);
3713 gtk_widget_set_size_request (wscroll
, width
, height
);
3715 gtk_widget_queue_draw (wfixed
);
3716 gdk_window_process_all_updates ();
3717 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3719 /* Clear under old scroll bar position. This must be done after
3720 the gtk_widget_queue_draw and gdk_window_process_all_updates
3722 x_clear_area (FRAME_X_DISPLAY (f
),
3724 oldx
, oldy
, oldw
, oldh
, 0);
3727 /* GTK does not redraw until the main loop is entered again, but
3728 if there are no X events pending we will not enter it. So we sync
3729 here to get some events. */
3732 SET_FRAME_GARBAGED (f
);
3733 cancel_mouse_face (f
);
3737 /* Get the current value of the range, truncated to an integer. */
3740 int_gtk_range_get_value (GtkRange
*range
)
3742 return gtk_range_get_value (range
);
3746 /* Set the thumb size and position of scroll bar BAR. We are currently
3747 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3750 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3755 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3757 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3759 if (wscroll
&& NILP (bar
->dragging
))
3769 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3771 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3772 rather than the real portion value. This makes the thumb less likely
3773 to resize and that looks better. */
3774 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3775 /* When the thumb is at the bottom, position == whole.
3776 So we need to increase `whole' to make space for the thumb. */
3783 top
= (gdouble
) position
/ whole
;
3784 shown
= (gdouble
) portion
/ whole
;
3787 size
= shown
* XG_SB_RANGE
;
3788 size
= min (size
, XG_SB_RANGE
);
3789 size
= max (size
, 1);
3791 value
= top
* XG_SB_RANGE
;
3792 value
= min (value
, XG_SB_MAX
- size
);
3793 value
= max (value
, XG_SB_MIN
);
3795 /* Assume all lines are of equal size. */
3796 new_step
= size
/ max (1, FRAME_LINES (f
));
3798 old_size
= gtk_adjustment_get_page_size (adj
);
3799 if (old_size
!= size
)
3801 int old_step
= gtk_adjustment_get_step_increment (adj
);
3802 if (old_step
!= new_step
)
3804 gtk_adjustment_set_page_size (adj
, size
);
3805 gtk_adjustment_set_step_increment (adj
, new_step
);
3806 /* Assume a page increment is about 95% of the page size */
3807 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3812 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3816 /* gtk_range_set_value invokes the callback. Set
3817 ignore_gtk_scrollbar to make the callback do nothing */
3818 xg_ignore_gtk_scrollbar
= 1;
3820 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3821 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3823 gtk_adjustment_changed (adj
);
3825 xg_ignore_gtk_scrollbar
= 0;
3832 /* Return non-zero if EVENT is for a scroll bar in frame F.
3833 When the same X window is used for several Gtk+ widgets, we cannot
3834 say for sure based on the X window alone if an event is for the
3835 frame. This function does additional checks.
3837 Return non-zero if the event is for a scroll bar, zero otherwise. */
3840 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3844 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3846 /* Check if press occurred outside the edit widget. */
3847 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3850 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
3851 (gdk_display_get_device_manager (gdpy
));
3852 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
3854 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
3856 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3859 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3860 || event
->type
== MotionNotify
))
3862 /* If we are releasing or moving the scroll bar, it has the grab. */
3863 GtkWidget
*w
= gtk_grab_get_current ();
3864 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3872 /***********************************************************************
3874 ***********************************************************************/
3875 /* The key for the data we put in the GtkImage widgets. The data is
3876 the image used by Emacs. We use this to see if we need to update
3877 the GtkImage with a new image. */
3878 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3880 /* The key for storing the latest modifiers so the activate callback can
3882 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3884 /* The key for storing the button widget in its proxy menu item. */
3885 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3887 /* The key for the data we put in the GtkImage widgets. The data is
3888 the stock name used by Emacs. We use this to see if we need to update
3889 the GtkImage with a new image. */
3890 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3892 /* As above, but this is used for named theme widgets, as opposed to
3894 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3896 /* Callback function invoked when a tool bar item is pressed.
3897 W is the button widget in the tool bar that got pressed,
3898 CLIENT_DATA is an integer that is the index of the button in the
3899 tool bar. 0 is the first button. */
3902 xg_tool_bar_button_cb (GtkWidget
*widget
,
3903 GdkEventButton
*event
,
3906 intptr_t state
= event
->state
;
3907 gpointer ptr
= (gpointer
) state
;
3908 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3913 /* Callback function invoked when a tool bar item is pressed.
3914 W is the button widget in the tool bar that got pressed,
3915 CLIENT_DATA is an integer that is the index of the button in the
3916 tool bar. 0 is the first button. */
3919 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3921 intptr_t idx
= (intptr_t) client_data
;
3922 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3923 intptr_t mod
= (intptr_t) gmod
;
3925 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3926 Lisp_Object key
, frame
;
3927 struct input_event event
;
3930 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3933 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3935 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3936 XSETFRAME (frame
, f
);
3938 /* We generate two events here. The first one is to set the prefix
3939 to `(tool_bar)', see keyboard.c. */
3940 event
.kind
= TOOL_BAR_EVENT
;
3941 event
.frame_or_window
= frame
;
3943 kbd_buffer_store_event (&event
);
3945 event
.kind
= TOOL_BAR_EVENT
;
3946 event
.frame_or_window
= frame
;
3948 /* Convert between the modifier bits GDK uses and the modifier bits
3949 Emacs uses. This assumes GDK and X masks are the same, which they are when
3951 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3952 kbd_buffer_store_event (&event
);
3954 /* Return focus to the frame after we have clicked on a detached
3956 Fx_focus_frame (frame
);
3959 /* Callback function invoked when a tool bar item is pressed in a detached
3960 tool bar or the overflow drop down menu.
3961 We just call xg_tool_bar_callback.
3962 W is the menu item widget that got pressed,
3963 CLIENT_DATA is an integer that is the index of the button in the
3964 tool bar. 0 is the first button. */
3967 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3969 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3970 XG_TOOL_BAR_PROXY_BUTTON
));
3971 xg_tool_bar_callback (wbutton
, client_data
);
3976 xg_tool_bar_help_callback (GtkWidget
*w
,
3977 GdkEventCrossing
*event
,
3978 gpointer client_data
);
3980 /* This callback is called when a help is to be shown for an item in
3981 the detached tool bar when the detached tool bar it is not expanded. */
3984 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3985 GdkEventCrossing
*event
,
3986 gpointer client_data
)
3988 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3989 XG_TOOL_BAR_PROXY_BUTTON
));
3991 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3995 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3997 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3998 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3999 GtkWidget
*c2
= clist
->next
? (GtkWidget
*) clist
->next
->data
: NULL
;
4001 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4002 g_list_free (clist
);
4003 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4007 /* This callback is called when a tool item should create a proxy item,
4008 such as for the overflow menu. Also called when the tool bar is detached.
4009 If we don't create a proxy menu item, the detached tool bar will be
4013 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
4015 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
4016 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4018 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
4019 GtkImage
*wimage
= GTK_IMAGE (c1
);
4020 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
4021 (wlbl
? gtk_label_get_text (wlbl
) : "");
4022 GtkWidget
*wmenuimage
;
4025 if (gtk_button_get_use_stock (wbutton
))
4026 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
4027 GTK_ICON_SIZE_MENU
);
4030 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
4031 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
4033 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
4035 if (store_type
== GTK_IMAGE_STOCK
)
4038 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
4039 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
4041 else if (store_type
== GTK_IMAGE_ICON_SET
)
4043 GtkIconSet
*icon_set
;
4044 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
4045 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
4046 GTK_ICON_SIZE_MENU
);
4048 else if (store_type
== GTK_IMAGE_PIXBUF
)
4053 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
4056 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
4058 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
4059 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
4060 GDK_INTERP_BILINEAR
);
4062 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
4066 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
4070 else if (store_type
== GTK_IMAGE_ICON_NAME
)
4072 const gchar
*icon_name
;
4073 GtkIconSize icon_size
;
4075 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
4076 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
4077 GTK_ICON_SIZE_MENU
);
4081 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
4086 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
4088 g_signal_connect (G_OBJECT (wmenuitem
),
4090 G_CALLBACK (xg_tool_bar_proxy_callback
),
4094 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
4095 (gpointer
) wbutton
);
4096 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
4097 gtk_widget_set_sensitive (wmenuitem
,
4098 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
4100 /* Use enter/leave notify to show help. We use the events
4101 rather than the GtkButton specific signals "enter" and
4102 "leave", so we can have only one callback. The event
4103 will tell us what kind of event it is. */
4104 g_signal_connect (G_OBJECT (wmenuitem
),
4105 "enter-notify-event",
4106 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4108 g_signal_connect (G_OBJECT (wmenuitem
),
4109 "leave-notify-event",
4110 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4116 /* This callback is called when a tool bar is detached. We must set
4117 the height of the tool bar to zero when this happens so frame sizes
4118 are correctly calculated.
4119 WBOX is the handle box widget that enables detach/attach of the tool bar.
4120 W is the tool bar widget.
4121 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4124 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
4126 gpointer client_data
)
4128 FRAME_PTR f
= (FRAME_PTR
) client_data
;
4130 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
4135 GtkRequisition req
, req2
;
4136 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
4137 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4138 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4139 req
.width
-= req2
.width
;
4140 req
.height
-= req2
.height
;
4141 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4142 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4143 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4144 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4145 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4146 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4147 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4148 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4149 xg_height_or_width_changed (f
);
4153 /* This callback is called when a tool bar is reattached. We must set
4154 the height of the tool bar when this happens so frame sizes
4155 are correctly calculated.
4156 WBOX is the handle box widget that enables detach/attach of the tool bar.
4157 W is the tool bar widget.
4158 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4161 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
4163 gpointer client_data
)
4165 FRAME_PTR f
= (FRAME_PTR
) client_data
;
4166 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4170 GtkRequisition req
, req2
;
4171 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
4172 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4173 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4174 req
.width
+= req2
.width
;
4175 req
.height
+= req2
.height
;
4176 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4177 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4178 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4179 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4180 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4181 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4182 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4183 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4184 xg_height_or_width_changed (f
);
4188 /* This callback is called when the mouse enters or leaves a tool bar item.
4189 It is used for displaying and hiding the help text.
4190 W is the tool bar item, a button.
4191 EVENT is either an enter event or leave event.
4192 CLIENT_DATA is an integer that is the index of the button in the
4193 tool bar. 0 is the first button.
4195 Returns FALSE to tell GTK to keep processing this event. */
4198 xg_tool_bar_help_callback (GtkWidget
*w
,
4199 GdkEventCrossing
*event
,
4200 gpointer client_data
)
4202 intptr_t idx
= (intptr_t) client_data
;
4203 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4204 Lisp_Object help
, frame
;
4206 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4209 if (event
->type
== GDK_ENTER_NOTIFY
)
4211 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4212 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4215 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4220 XSETFRAME (frame
, f
);
4221 kbd_buffer_store_help_event (frame
, help
);
4227 /* This callback is called when a tool bar item shall be redrawn.
4228 It modifies the expose event so that the GtkImage widget redraws the
4229 whole image. This to overcome a bug that makes GtkImage draw the image
4230 in the wrong place when it tries to redraw just a part of the image.
4231 W is the GtkImage to be redrawn.
4232 EVENT is the expose event for W.
4233 CLIENT_DATA is unused.
4235 Returns FALSE to tell GTK to keep processing this event. */
4239 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4240 GdkEventExpose
*event
,
4241 gpointer client_data
)
4245 gdk_drawable_get_size (event
->window
, &width
, &height
);
4246 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4247 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4249 event
->area
.x
= max (0, event
->area
.x
);
4250 event
->area
.y
= max (0, event
->area
.y
);
4252 event
->area
.width
= max (width
, event
->area
.width
);
4253 event
->area
.height
= max (height
, event
->area
.height
);
4259 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4260 #define toolbar_set_orientation(w, o) \
4261 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4263 #define toolbar_set_orientation(w, o) \
4264 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4267 /* Attach a tool bar to frame F. */
4270 xg_pack_tool_bar (FRAME_PTR f
, Lisp_Object pos
)
4272 struct x_output
*x
= f
->output_data
.x
;
4273 int into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4275 toolbar_set_orientation (x
->toolbar_widget
,
4277 ? GTK_ORIENTATION_VERTICAL
4278 : GTK_ORIENTATION_HORIZONTAL
);
4279 if (!x
->handlebox_widget
)
4281 x
->handlebox_widget
= gtk_handle_box_new ();
4282 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4283 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4284 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4285 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4286 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4292 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4294 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), x
->handlebox_widget
,
4297 if (EQ (pos
, Qleft
))
4298 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4299 x
->handlebox_widget
,
4301 x
->toolbar_in_hbox
= 1;
4305 int vbox_pos
= x
->menubar_widget
? 1 : 0;
4306 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4308 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
4312 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4313 x
->handlebox_widget
,
4315 x
->toolbar_in_hbox
= 0;
4319 /* Create a tool bar for frame F. */
4322 xg_create_tool_bar (FRAME_PTR f
)
4324 struct x_output
*x
= f
->output_data
.x
;
4325 #if GTK_CHECK_VERSION (3, 3, 6)
4326 GtkStyleContext
*gsty
;
4328 struct xg_frame_tb_info
*tbinfo
4329 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4333 tbinfo
= xmalloc (sizeof (*tbinfo
));
4334 tbinfo
->last_tool_bar
= Qnil
;
4335 tbinfo
->style
= Qnil
;
4336 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4337 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4338 tbinfo
->n_last_items
= 0;
4339 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4344 x
->toolbar_widget
= gtk_toolbar_new ();
4345 x
->toolbar_detached
= 0;
4347 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4349 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4350 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4351 #if GTK_CHECK_VERSION (3, 3, 6)
4352 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4353 gtk_style_context_add_class (gsty
, "primary-toolbar");
4358 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4360 /* Find the right-to-left image named by RTL in the tool bar images for F.
4361 Returns IMAGE if RTL is not found. */
4364 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
4367 Lisp_Object file
, rtl_name
;
4368 struct gcpro gcpro1
, gcpro2
;
4369 GCPRO2 (file
, rtl_name
);
4371 rtl_name
= Ffile_name_nondirectory (rtl
);
4373 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4375 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4376 if (!NILP (file
= file_for_image (rtl_image
)))
4378 file
= call1 (intern ("file-name-sans-extension"),
4379 Ffile_name_nondirectory (file
));
4380 if (! NILP (Fequal (file
, rtl_name
)))
4391 static GtkToolItem
*
4392 xg_make_tool_item (FRAME_PTR f
,
4394 GtkWidget
**wbutton
,
4396 int i
, int horiz
, int text_image
)
4398 GtkToolItem
*ti
= gtk_tool_item_new ();
4399 GtkWidget
*vb
= gtk_box_new (horiz
4400 ? GTK_ORIENTATION_HORIZONTAL
4401 : GTK_ORIENTATION_VERTICAL
,
4403 GtkWidget
*wb
= gtk_button_new ();
4404 /* The eventbox is here so we can have tooltips on disabled items. */
4405 GtkWidget
*weventbox
= gtk_event_box_new ();
4406 #if GTK_CHECK_VERSION (3, 3, 6)
4407 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4408 GtkStyleContext
*gsty
;
4410 gtk_css_provider_load_from_data (css_prov
,
4412 " background-color: transparent;"
4416 gsty
= gtk_widget_get_style_context (weventbox
);
4417 gtk_style_context_add_provider (gsty
,
4418 GTK_STYLE_PROVIDER (css_prov
),
4419 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4420 g_object_unref (css_prov
);
4423 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4425 if (wimage
&& !text_image
)
4426 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4428 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4429 if (wimage
&& text_image
)
4430 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4432 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4433 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4434 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4435 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4436 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4438 if (wimage
|| label
)
4441 gpointer gi
= (gpointer
) ii
;
4443 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4444 G_CALLBACK (xg_tool_bar_menu_proxy
),
4447 g_signal_connect (G_OBJECT (wb
), "clicked",
4448 G_CALLBACK (xg_tool_bar_callback
),
4451 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4454 /* Catch expose events to overcome an annoying redraw bug, see
4455 comment for xg_tool_bar_item_expose_callback. */
4456 g_signal_connect (G_OBJECT (ti
),
4458 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4461 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4463 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4464 no distinction based on modifiers in the activate callback,
4465 so we have to do it ourselves. */
4466 g_signal_connect (wb
, "button-release-event",
4467 G_CALLBACK (xg_tool_bar_button_cb
),
4470 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4472 /* Use enter/leave notify to show help. We use the events
4473 rather than the GtkButton specific signals "enter" and
4474 "leave", so we can have only one callback. The event
4475 will tell us what kind of event it is. */
4476 g_signal_connect (G_OBJECT (weventbox
),
4477 "enter-notify-event",
4478 G_CALLBACK (xg_tool_bar_help_callback
),
4480 g_signal_connect (G_OBJECT (weventbox
),
4481 "leave-notify-event",
4482 G_CALLBACK (xg_tool_bar_help_callback
),
4486 if (wbutton
) *wbutton
= wb
;
4492 is_box_type (GtkWidget
*vb
, int is_horizontal
)
4496 if (GTK_IS_BOX (vb
))
4498 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4499 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4500 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4504 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4510 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4511 const char *icon_name
, const struct image
*img
,
4512 const char *label
, int horiz
)
4516 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4517 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4519 /* Check if the tool icon matches. */
4520 if (stock_name
&& wimage
)
4522 old
= g_object_get_data (G_OBJECT (wimage
),
4523 XG_TOOL_BAR_STOCK_NAME
);
4524 if (!old
|| strcmp (old
, stock_name
))
4527 else if (icon_name
&& wimage
)
4529 old
= g_object_get_data (G_OBJECT (wimage
),
4530 XG_TOOL_BAR_ICON_NAME
);
4531 if (!old
|| strcmp (old
, icon_name
))
4536 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4537 XG_TOOL_BAR_IMAGE_DATA
);
4538 Pixmap old_img
= (Pixmap
) gold_img
;
4539 if (old_img
!= img
->pixmap
)
4543 /* Check button configuration and label. */
4544 if (is_box_type (vb
, horiz
)
4545 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4548 /* Ensure label is correct. */
4550 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4555 xg_update_tool_bar_sizes (FRAME_PTR f
)
4557 struct x_output
*x
= f
->output_data
.x
;
4559 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4561 gtk_widget_get_preferred_size (GTK_WIDGET (x
->handlebox_widget
), NULL
, &req
);
4562 if (x
->toolbar_in_hbox
)
4565 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4566 x
->handlebox_widget
,
4567 "position", &pos
, NULL
);
4568 if (pos
== 0) nl
= req
.width
;
4569 else nr
= req
.width
;
4574 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4575 x
->handlebox_widget
,
4576 "position", &pos
, NULL
);
4577 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4578 else nb
= req
.height
;
4581 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4582 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4583 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4584 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4586 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4587 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4588 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4589 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4590 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4591 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4599 /* Update the tool bar for frame F. Add new buttons and remove old. */
4602 update_frame_tool_bar (FRAME_PTR f
)
4605 struct x_output
*x
= f
->output_data
.x
;
4606 int hmargin
= 0, vmargin
= 0;
4607 GtkToolbar
*wtoolbar
;
4609 GtkTextDirection dir
;
4610 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
4612 int text_image
, horiz
;
4613 struct xg_frame_tb_info
*tbinfo
;
4615 if (! FRAME_GTK_WIDGET (f
))
4620 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4622 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4623 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4625 else if (CONSP (Vtool_bar_button_margin
))
4627 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4628 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4630 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4631 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4634 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4635 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4636 i.e. zero. This means that margins less than
4637 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4638 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4639 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4641 if (! x
->toolbar_widget
)
4642 xg_create_tool_bar (f
);
4644 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4645 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4647 style
= Ftool_bar_get_system_style ();
4649 /* Are we up to date? */
4650 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4653 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4654 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4655 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4656 && tbinfo
->dir
== dir
4657 && ! NILP (Fequal (tbinfo
->style
, style
))
4658 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4664 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4665 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4666 tbinfo
->style
= style
;
4667 tbinfo
->hmargin
= hmargin
;
4668 tbinfo
->vmargin
= vmargin
;
4671 text_image
= EQ (style
, Qtext_image_horiz
);
4672 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4674 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4676 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4677 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4681 struct image
*img
= NULL
;
4683 Lisp_Object stock
= Qnil
;
4684 GtkStockItem stock_item
;
4685 char *stock_name
= NULL
;
4686 char *icon_name
= NULL
;
4688 GtkWidget
*wbutton
= NULL
;
4689 Lisp_Object specified_file
;
4690 int vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4692 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4693 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4694 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4697 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4699 /* If this is a separator, use a gtk separator item. */
4700 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4702 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4705 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4707 ti
= gtk_separator_tool_item_new ();
4708 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4714 /* Otherwise, the tool-bar item is an ordinary button. */
4716 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4718 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4722 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4724 /* Ignore invalid image specifications. */
4725 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4726 if (!valid_image_p (image
))
4729 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4734 specified_file
= file_for_image (image
);
4735 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4736 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4738 if (STRINGP (stock
))
4740 stock_name
= SSDATA (stock
);
4741 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4743 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4744 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4746 icon_name
= stock_name
+ 2;
4750 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4753 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4755 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4756 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4764 if (stock_name
== NULL
&& icon_name
== NULL
)
4766 /* No stock image, or stock item not known. Try regular
4767 image. If image is a vector, choose it according to the
4769 if (dir
== GTK_TEXT_DIR_RTL
4770 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4772 image
= find_rtl_image (f
, image
, rtl
);
4774 if (VECTORP (image
))
4778 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4779 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4782 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4783 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4785 eassert (ASIZE (image
) >= idx
);
4786 image
= AREF (image
, idx
);
4791 img_id
= lookup_image (f
, image
);
4792 img
= IMAGE_FROM_ID (f
, img_id
);
4793 prepare_image_for_display (f
, img
);
4795 if (img
->load_failed_p
|| img
->pixmap
== None
)
4798 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4804 /* If there is an existing widget, check if it's stale; if so,
4805 remove it and make a new tool item from scratch. */
4806 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4809 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4818 /* Save the image so we can see if an update is needed the
4819 next time we call xg_tool_item_match_p. */
4820 if (EQ (style
, Qtext
))
4822 else if (stock_name
)
4824 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4825 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4826 (gpointer
) xstrdup (stock_name
),
4827 (GDestroyNotify
) xfree
);
4831 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4832 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4833 (gpointer
) xstrdup (icon_name
),
4834 (GDestroyNotify
) xfree
);
4838 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4839 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4840 (gpointer
)img
->pixmap
);
4843 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4844 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4845 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4850 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4854 /* Remove buttons not longer needed. */
4857 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4859 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4860 } while (ti
!= NULL
);
4862 if (f
->n_tool_bar_items
!= 0)
4865 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4866 gtk_widget_show_all (GTK_WIDGET (x
->handlebox_widget
));
4867 if (xg_update_tool_bar_sizes (f
))
4868 xg_height_or_width_changed (f
);
4874 /* Deallocate all resources for the tool bar on frame F.
4875 Remove the tool bar. */
4878 free_frame_tool_bar (FRAME_PTR f
)
4880 struct x_output
*x
= f
->output_data
.x
;
4882 if (x
->toolbar_widget
)
4884 struct xg_frame_tb_info
*tbinfo
;
4885 int is_packed
= x
->handlebox_widget
!= 0;
4887 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4888 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4891 if (x
->toolbar_in_hbox
)
4892 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4893 x
->handlebox_widget
);
4895 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4896 x
->handlebox_widget
);
4899 gtk_widget_destroy (x
->toolbar_widget
);
4901 x
->toolbar_widget
= 0;
4902 x
->handlebox_widget
= 0;
4903 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4904 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4906 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4911 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4916 xg_height_or_width_changed (f
);
4923 xg_change_toolbar_position (FRAME_PTR f
, Lisp_Object pos
)
4925 struct x_output
*x
= f
->output_data
.x
;
4927 if (! x
->toolbar_widget
|| ! x
->handlebox_widget
)
4931 g_object_ref (x
->handlebox_widget
);
4932 if (x
->toolbar_in_hbox
)
4933 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4934 x
->handlebox_widget
);
4936 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4937 x
->handlebox_widget
);
4938 xg_pack_tool_bar (f
, pos
);
4939 g_object_unref (x
->handlebox_widget
);
4940 if (xg_update_tool_bar_sizes (f
))
4941 xg_height_or_width_changed (f
);
4949 /***********************************************************************
4951 ***********************************************************************/
4953 xg_initialize (void)
4955 GtkBindingSet
*binding_set
;
4956 GtkSettings
*settings
;
4959 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4960 we keep it permanently linked in. */
4965 xg_ignore_gtk_scrollbar
= 0;
4966 xg_detached_menus
= 0;
4967 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4968 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4970 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4971 id_to_widget
.widgets
= 0;
4973 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
4974 (gdk_display_get_default ()));
4975 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4976 bindings. It doesn't seem to be any way to remove properties,
4977 so we set it to VoidSymbol which in X means "no key". */
4978 gtk_settings_set_string_property (settings
,
4979 "gtk-menu-bar-accel",
4983 /* Make GTK text input widgets use Emacs style keybindings. This is
4985 gtk_settings_set_string_property (settings
,
4986 "gtk-key-theme-name",
4990 /* Make dialogs close on C-g. Since file dialog inherits from
4991 dialog, this works for them also. */
4992 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4993 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4996 /* Make menus close on C-g. */
4997 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4998 (GTK_TYPE_MENU_SHELL
));
4999 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5001 update_theme_scrollbar_width ();
5003 x_last_font_name
= NULL
;
5006 #endif /* USE_GTK */