1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2011 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/>. */
28 #include "blockinput.h"
29 #include "syssignal.h"
32 #include "termhooks.h"
36 #include <gdk/gdkkeysyms.h>
37 #include "xsettings.h"
40 #include <X11/Xft/Xft.h>
47 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
48 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
50 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
51 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
53 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
54 #define gtk_widget_set_has_window(w, b) \
55 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
57 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
58 #define gtk_dialog_get_action_area(w) ((w)->action_area)
59 #define gtk_dialog_get_content_area(w) ((w)->vbox)
61 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
62 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
64 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
65 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
66 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
67 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
68 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
70 #if GTK_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 11
71 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
73 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
77 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
78 #define gdk_window_get_geometry(w, a, b, c, d) \
79 gdk_window_get_geometry (w, a, b, c, d, 0)
80 #define gdk_x11_window_lookup_for_display(d, w) \
81 gdk_xid_table_lookup_for_display (d, w)
82 #define GDK_KEY_g GDK_g
85 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
88 /***********************************************************************
89 Display handling functions
90 ***********************************************************************/
92 /* Keep track of the default display, or NULL if there is none. Emacs
93 may close all its displays. */
95 static GdkDisplay
*gdpy_def
;
97 /* When the GTK widget W is to be created on a display for F that
98 is not the default display, set the display for W.
99 W can be a GtkMenu or a GtkWindow widget. */
102 xg_set_screen (GtkWidget
*w
, FRAME_PTR f
)
104 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
106 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
107 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
110 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
112 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
117 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
118 *DPY is set to NULL if the display can't be opened.
120 Returns non-zero if display could be opened, zero if display could not
121 be opened, and less than zero if the GTK version doesn't support
125 xg_display_open (char *display_name
, Display
**dpy
)
129 gdpy
= gdk_display_open (display_name
);
130 if (!gdpy_def
&& gdpy
)
133 gdk_display_manager_set_default_display (gdk_display_manager_get (),
137 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
141 /* Close display DPY. */
144 xg_display_close (Display
*dpy
)
146 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
148 /* If this is the default display, try to change it before closing.
149 If there is no other display to use, gdpy_def is set to NULL, and
150 the next call to xg_display_open resets the default display. */
151 if (gdk_display_get_default () == gdpy
)
153 struct x_display_info
*dpyinfo
;
154 GdkDisplay
*gdpy_new
= NULL
;
156 /* Find another display. */
157 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
158 if (dpyinfo
->display
!= dpy
)
160 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
161 gdk_display_manager_set_default_display (gdk_display_manager_get (),
168 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
169 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
170 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
171 can continue running, but there will be memory leaks. */
172 g_object_run_dispose (G_OBJECT (gdpy
));
174 /* This seems to be fixed in GTK 2.10. */
175 gdk_display_close (gdpy
);
180 /***********************************************************************
182 ***********************************************************************/
183 /* The next two variables and functions are taken from lwlib. */
184 static widget_value
*widget_value_free_list
;
185 static int malloc_cpt
;
187 /* Allocate a widget_value structure, either by taking one from the
188 widget_value_free_list or by malloc:ing a new one.
190 Return a pointer to the allocated structure. */
193 malloc_widget_value (void)
196 if (widget_value_free_list
)
198 wv
= widget_value_free_list
;
199 widget_value_free_list
= wv
->free_list
;
204 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
207 memset (wv
, 0, sizeof (widget_value
));
211 /* This is analogous to free. It frees only what was allocated
212 by malloc_widget_value, and no substructures. */
215 free_widget_value (widget_value
*wv
)
222 /* When the number of already allocated cells is too big,
229 wv
->free_list
= widget_value_free_list
;
230 widget_value_free_list
= wv
;
235 /* Create and return the cursor to be used for popup menus and
236 scroll bars on display DPY. */
239 xg_create_default_cursor (Display
*dpy
)
241 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
242 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
246 xg_get_pixbuf_from_pixmap (FRAME_PTR f
, Pixmap pix
)
251 unsigned int width
, height
, uunused
;
254 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
255 &width
, &height
, &uunused
, &uunused
);
257 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
261 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
274 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
277 xg_get_pixbuf_from_pix_and_mask (FRAME_PTR f
,
282 GdkPixbuf
*icon_buf
, *tmp_buf
;
284 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
285 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
286 g_object_unref (G_OBJECT (tmp_buf
));
288 width
= gdk_pixbuf_get_width (icon_buf
);
289 height
= gdk_pixbuf_get_height (icon_buf
);
293 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
294 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
295 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
296 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
297 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
300 for (y
= 0; y
< height
; ++y
)
302 guchar
*iconptr
, *maskptr
;
305 iconptr
= pixels
+ y
* rowstride
;
306 maskptr
= mask_pixels
+ y
* mask_rowstride
;
308 for (x
= 0; x
< width
; ++x
)
310 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
311 just R is sufficient. */
313 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
315 iconptr
+= rowstride
/width
;
316 maskptr
+= mask_rowstride
/width
;
320 g_object_unref (G_OBJECT (mask_buf
));
327 file_for_image (Lisp_Object image
)
329 Lisp_Object specified_file
= Qnil
;
332 for (tail
= XCDR (image
);
333 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
334 tail
= XCDR (XCDR (tail
)))
335 if (EQ (XCAR (tail
), QCfile
))
336 specified_file
= XCAR (XCDR (tail
));
338 return specified_file
;
341 /* For the image defined in IMG, make and return a GtkImage. For displays with
342 8 planes or less we must make a GdkPixbuf and apply the mask manually.
343 Otherwise the highlightning and dimming the tool bar code in GTK does
344 will look bad. For display with more than 8 planes we just use the
345 pixmap and mask directly. For monochrome displays, GTK doesn't seem
346 able to use external pixmaps, it looks bad whatever we do.
347 The image is defined on the display where frame F is.
348 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
349 If OLD_WIDGET is NULL, a new widget is constructed and returned.
350 If OLD_WIDGET is not NULL, that widget is modified. */
353 xg_get_image_for_pixmap (FRAME_PTR f
,
356 GtkImage
*old_widget
)
360 /* If we have a file, let GTK do all the image handling.
361 This seems to be the only way to make insensitive and activated icons
362 look good in all cases. */
363 Lisp_Object specified_file
= file_for_image (img
->spec
);
366 /* We already loaded the image once before calling this
367 function, so this only fails if the image file has been removed.
368 In that case, use the pixmap already loaded. */
370 if (STRINGP (specified_file
)
371 && STRINGP (file
= x_find_image_file (specified_file
)))
374 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
376 gtk_image_set_from_file (old_widget
, SSDATA (file
));
378 return GTK_WIDGET (old_widget
);
381 /* No file, do the image handling ourselves. This will look very bad
382 on a monochrome display, and sometimes bad on all displays with
385 /* This is a workaround to make icons look good on pseudo color
386 displays. Apparently GTK expects the images to have an alpha
387 channel. If they don't, insensitive and activated icons will
388 look bad. This workaround does not work on monochrome displays,
389 and is strictly not needed on true color/static color displays (i.e.
390 16 bits and higher). But we do it anyway so we get a pixbuf that is
391 not associated with the img->pixmap. The img->pixmap may be removed
392 by clearing the image cache and then the tool bar redraw fails, since
393 Gtk+ assumes the pixmap is always there. */
394 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
399 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
401 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
403 g_object_unref (G_OBJECT (icon_buf
));
406 return GTK_WIDGET (old_widget
);
410 /* Set CURSOR on W and all widgets W contain. We must do like this
411 for scroll bars and menu because they create widgets internally,
412 and it is those widgets that are visible. */
415 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
417 GdkWindow
*window
= gtk_widget_get_window(w
);
418 GList
*children
= gdk_window_peek_children (window
);
420 gdk_window_set_cursor (window
, cursor
);
422 /* The scroll bar widget has more than one GDK window (had to look at
423 the source to figure this out), and there is no way to set cursor
424 on widgets in GTK. So we must set the cursor for all GDK windows.
427 for ( ; children
; children
= g_list_next (children
))
428 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
431 /* Insert NODE into linked LIST. */
434 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
436 xg_list_node
*list_start
= list
->next
;
438 if (list_start
) list_start
->prev
= node
;
439 node
->next
= list_start
;
444 /* Remove NODE from linked LIST. */
447 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
449 xg_list_node
*list_start
= list
->next
;
450 if (node
== list_start
)
452 list
->next
= node
->next
;
453 if (list
->next
) list
->next
->prev
= 0;
457 node
->prev
->next
= node
->next
;
458 if (node
->next
) node
->next
->prev
= node
->prev
;
462 /* Allocate and return a utf8 version of STR. If STR is already
463 utf8 or NULL, just return a copy of STR.
464 A new string is allocated and the caller must free the result
468 get_utf8_string (const char *str
)
472 if (!str
) return NULL
;
474 /* If not UTF-8, try current locale. */
475 if (!g_utf8_validate (str
, -1, NULL
))
476 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
478 return g_strdup (str
);
482 /* Probably some control characters in str. Escape them. */
486 unsigned char *p
= (unsigned char *)str
;
488 GError
*error
= NULL
;
490 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
491 &bytes_written
, &error
))
492 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
495 p
+= bytes_written
+1;
496 g_error_free (error
);
502 g_error_free (error
);
507 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
508 p
= (unsigned char *)str
;
510 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
511 &bytes_written
, &error
))
512 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
514 strncpy (up
, (char *)p
, bytes_written
);
515 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
516 up
[bytes_written
+4] = '\0';
517 up
+= bytes_written
+4;
518 p
+= bytes_written
+1;
519 g_error_free (error
);
525 strcat (utf8_str
, cp
);
530 g_error_free (error
);
537 /* Check for special colors used in face spec for region face.
538 The colors are fetched from the Gtk+ theme.
539 Return 1 if color was found, 0 if not. */
542 xg_check_special_colors (struct frame
*f
,
543 const char *color_name
,
547 int get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
548 int get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
550 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
556 GtkStyleContext
*gsty
557 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
560 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
562 gtk_style_context_get_color (gsty
, state
, &col
);
564 gtk_style_context_get_background_color (gsty
, state
, &col
);
566 sprintf (buf
, "rgbi:%lf/%lf/%lf", col
.red
, col
.green
, col
.blue
);
567 success_p
= XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
570 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
571 GdkColor
*grgb
= get_bg
572 ? &gsty
->bg
[GTK_STATE_SELECTED
]
573 : &gsty
->fg
[GTK_STATE_SELECTED
];
575 color
->red
= grgb
->red
;
576 color
->green
= grgb
->green
;
577 color
->blue
= grgb
->blue
;
578 color
->pixel
= grgb
->pixel
;
589 /***********************************************************************
591 ***********************************************************************/
592 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
593 We use that to pop down the tooltip. This happens if Gtk+ for some
594 reason wants to change or hide the tooltip. */
596 #ifdef USE_GTK_TOOLTIP
599 hierarchy_ch_cb (GtkWidget
*widget
,
600 GtkWidget
*previous_toplevel
,
603 FRAME_PTR f
= (FRAME_PTR
) user_data
;
604 struct x_output
*x
= f
->output_data
.x
;
605 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
607 if (! top
|| ! GTK_IS_WINDOW (top
))
608 gtk_widget_hide (previous_toplevel
);
611 /* Callback called when Gtk+ thinks a tooltip should be displayed.
612 We use it to get the tooltip window and the tooltip widget so
613 we can manipulate the ourselves.
615 Return FALSE ensures that the tooltip is not shown. */
618 qttip_cb (GtkWidget
*widget
,
621 gboolean keyboard_mode
,
625 FRAME_PTR f
= (FRAME_PTR
) user_data
;
626 struct x_output
*x
= f
->output_data
.x
;
627 if (x
->ttip_widget
== NULL
)
629 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
630 x
->ttip_widget
= tooltip
;
631 g_object_ref (G_OBJECT (tooltip
));
632 x
->ttip_lbl
= gtk_label_new ("");
633 g_object_ref (G_OBJECT (x
->ttip_lbl
));
634 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
635 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
636 /* ATK needs an empty title for some reason. */
637 gtk_window_set_title (x
->ttip_window
, "");
638 /* Realize so we can safely get screen later on. */
639 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
640 gtk_widget_realize (x
->ttip_lbl
);
642 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
643 G_CALLBACK (hierarchy_ch_cb
), f
);
648 #endif /* USE_GTK_TOOLTIP */
650 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
651 Return zero if no system tooltip available, non-zero otherwise. */
654 xg_prepare_tooltip (FRAME_PTR f
,
659 #ifndef USE_GTK_TOOLTIP
662 struct x_output
*x
= f
->output_data
.x
;
666 GtkSettings
*settings
;
667 gboolean tt_enabled
= TRUE
;
669 Lisp_Object encoded_string
;
671 if (!x
->ttip_lbl
) return 0;
674 encoded_string
= ENCODE_UTF_8 (string
);
675 widget
= GTK_WIDGET (x
->ttip_lbl
);
676 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
677 screen
= gdk_window_get_screen (gwin
);
678 settings
= gtk_settings_get_for_screen (screen
);
679 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
682 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
683 /* Record that we disabled it so it can be enabled again. */
684 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
688 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
689 g_object_set_data (G_OBJECT
690 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
691 "gdk-display-current-tooltip", NULL
);
693 /* Put out dummy widget in so we can get callbacks for unrealize and
694 hierarchy-changed. */
695 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
697 gtk_tooltip_set_text (x
->ttip_widget
, SDATA (encoded_string
));
698 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
699 if (width
) *width
= req
.width
;
700 if (height
) *height
= req
.height
;
705 #endif /* USE_GTK_TOOLTIP */
708 /* Show the tooltip at ROOT_X and ROOT_Y.
709 xg_prepare_tooltip must have been called before this function. */
712 xg_show_tooltip (FRAME_PTR f
, int root_x
, int root_y
)
714 #ifdef USE_GTK_TOOLTIP
715 struct x_output
*x
= f
->output_data
.x
;
719 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
720 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
726 /* Hide tooltip if shown. Do nothing if not shown.
727 Return non-zero if tip was hidden, non-ero if not (i.e. not using
731 xg_hide_tooltip (FRAME_PTR f
)
734 #ifdef USE_GTK_TOOLTIP
735 if (f
->output_data
.x
->ttip_window
)
737 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
739 gtk_widget_hide (GTK_WIDGET (win
));
741 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
743 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
744 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
745 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
746 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
757 /***********************************************************************
758 General functions for creating widgets, resizing, events, e.t.c.
759 ***********************************************************************/
761 /* Make a geometry string and pass that to GTK. It seems this is the
762 only way to get geometry position right if the user explicitly
763 asked for a position when starting Emacs.
764 F is the frame we shall set geometry for. */
767 xg_set_geometry (FRAME_PTR f
)
769 if (f
->size_hint_flags
& (USPosition
| PPosition
))
771 int left
= f
->left_pos
;
772 int xneg
= f
->size_hint_flags
& XNegative
;
773 int top
= f
->top_pos
;
774 int yneg
= f
->size_hint_flags
& YNegative
;
782 sprintf (geom_str
, "=%dx%d%c%d%c%d",
783 FRAME_PIXEL_WIDTH (f
),
784 FRAME_PIXEL_HEIGHT (f
),
785 (xneg
? '-' : '+'), left
,
786 (yneg
? '-' : '+'), top
);
788 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
790 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
794 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
795 and use a GtkFixed widget, this doesn't happen automatically. */
798 xg_clear_under_internal_border (FRAME_PTR f
)
800 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
802 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
803 gtk_widget_queue_draw (wfixed
);
804 gdk_window_process_all_updates ();
805 x_clear_area (FRAME_X_DISPLAY (f
),
808 FRAME_PIXEL_WIDTH (f
),
809 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
810 x_clear_area (FRAME_X_DISPLAY (f
),
813 FRAME_INTERNAL_BORDER_WIDTH (f
),
814 FRAME_PIXEL_HEIGHT (f
), 0);
815 x_clear_area (FRAME_X_DISPLAY (f
),
817 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
818 FRAME_PIXEL_WIDTH (f
),
819 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
820 x_clear_area (FRAME_X_DISPLAY (f
),
822 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
824 FRAME_INTERNAL_BORDER_WIDTH (f
),
825 FRAME_PIXEL_HEIGHT (f
), 0);
829 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
830 and a Gtk+ menu bar, we get resize events for the edit part of the
831 frame only. We let Gtk+ deal with the Gtk+ parts.
832 F is the frame to resize.
833 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
836 xg_frame_resized (FRAME_PTR f
, int pixelwidth
, int pixelheight
)
840 if (pixelwidth
== -1 && pixelheight
== -1)
842 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
843 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
845 &pixelwidth
, &pixelheight
);
850 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
851 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
853 if (columns
!= FRAME_COLS (f
)
854 || rows
!= FRAME_LINES (f
)
855 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
856 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
858 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
859 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
861 xg_clear_under_internal_border (f
);
862 change_frame_size (f
, rows
, columns
, 0, 1, 0);
863 SET_FRAME_GARBAGED (f
);
864 cancel_mouse_face (f
);
868 /* Resize the outer window of frame F after chainging the height.
869 COLUMNS/ROWS is the size the edit area shall have after the resize. */
872 xg_frame_set_char_size (FRAME_PTR f
, int cols
, int rows
)
874 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
875 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
878 if (FRAME_PIXEL_HEIGHT (f
) == 0)
881 /* Take into account the size of the scroll bar. Always use the
882 number of columns occupied by the scroll bar here otherwise we
883 might end up with a frame width that is not a multiple of the
884 frame's character width which is bad for vertically split
886 f
->scroll_bar_actual_width
887 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
889 compute_fringe_widths (f
, 0);
891 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
892 after calculating that value. */
893 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
894 + FRAME_TOOLBAR_WIDTH (f
);
897 /* Do this before resize, as we don't know yet if we will be resized. */
898 xg_clear_under_internal_border (f
);
900 /* Must resize our top level widget. Font size may have changed,
901 but not rows/cols. */
902 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
903 pixelwidth
, pixelheight
);
904 x_wm_set_size_hint (f
, 0, 0);
906 SET_FRAME_GARBAGED (f
);
907 cancel_mouse_face (f
);
909 /* We can not call change_frame_size for a mapped frame,
910 we can not set pixel width/height either. The window manager may
911 override our resize request, XMonad does this all the time.
912 The best we can do is try to sync, so lisp code sees the updated
913 size as fast as possible.
914 For unmapped windows, we can set rows/cols. When
915 the frame is mapped again we will (hopefully) get the correct size. */
916 if (f
->async_visible
)
918 /* Must call this to flush out events */
919 (void)gtk_events_pending ();
921 x_wait_for_event (f
, ConfigureNotify
);
925 change_frame_size (f
, rows
, cols
, 0, 1, 0);
926 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
927 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
931 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
932 The policy is to keep the number of editable lines. */
935 xg_height_or_width_changed (FRAME_PTR f
)
937 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
938 FRAME_TOTAL_PIXEL_WIDTH (f
),
939 FRAME_TOTAL_PIXEL_HEIGHT (f
));
940 f
->output_data
.x
->hint_flags
= 0;
941 x_wm_set_size_hint (f
, 0, 0);
944 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
945 Must be done like this, because GtkWidget:s can have "hidden"
946 X Window that aren't accessible.
948 Return 0 if no widget match WDESC. */
951 xg_win_to_widget (Display
*dpy
, Window wdesc
)
954 GtkWidget
*gwdesc
= 0;
958 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
963 event
.any
.window
= gdkwin
;
964 gwdesc
= gtk_get_event_widget (&event
);
971 /* Set the background of widget W to PIXEL. */
974 xg_set_widget_bg (FRAME_PTR f
, GtkWidget
*w
, long unsigned int pixel
)
980 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
982 bg
.red
= (double)xbg
.red
/65536.0;
983 bg
.green
= (double)xbg
.green
/65536.0;
984 bg
.blue
= (double)xbg
.blue
/65536.0;
986 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
990 GdkColormap
*map
= gtk_widget_get_colormap (w
);
991 gdk_colormap_query_color (map
, pixel
, &bg
);
992 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
996 /* Callback called when the gtk theme changes.
997 We notify lisp code so it can fix faces used for region for example. */
1000 style_changed_cb (GObject
*go
,
1004 struct input_event event
;
1005 GdkDisplay
*gdpy
= (GdkDisplay
*) user_data
;
1006 const char *display_name
= gdk_display_get_name (gdpy
);
1009 event
.kind
= CONFIG_CHANGED_EVENT
;
1010 event
.frame_or_window
= make_string (display_name
, strlen (display_name
));
1011 /* Theme doesn't change often, so intern is called seldom. */
1012 event
.arg
= intern ("theme-name");
1013 kbd_buffer_store_event (&event
);
1016 /* Called when a delete-event occurs on WIDGET. */
1019 delete_cb (GtkWidget
*widget
,
1024 /* The event doesn't arrive in the normal event loop. Send event
1026 FRAME_PTR f
= (FRAME_PTR
) user_data
;
1027 struct input_event ie
;
1030 ie
.kind
= DELETE_WINDOW_EVENT
;
1031 XSETFRAME (ie
.frame_or_window
, f
);
1032 kbd_buffer_store_event (&ie
);
1038 /* Create and set up the GTK widgets for frame F.
1039 Return 0 if creation failed, non-zero otherwise. */
1042 xg_create_frame_widgets (FRAME_PTR f
)
1045 GtkWidget
*wvbox
, *whbox
;
1052 if (FRAME_X_EMBEDDED_P (f
))
1053 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
1055 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1057 xg_set_screen (wtop
, f
);
1059 wvbox
= gtk_vbox_new (FALSE
, 0);
1060 whbox
= gtk_hbox_new (FALSE
, 0);
1061 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
1063 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1065 if (wtop
) gtk_widget_destroy (wtop
);
1066 if (wvbox
) gtk_widget_destroy (wvbox
);
1067 if (whbox
) gtk_widget_destroy (whbox
);
1068 if (wfixed
) gtk_widget_destroy (wfixed
);
1074 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1075 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1076 gtk_widget_set_name (wvbox
, "pane");
1077 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1079 /* If this frame has a title or name, set it in the title bar. */
1080 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1081 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1083 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1085 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1086 FRAME_GTK_WIDGET (f
) = wfixed
;
1087 f
->output_data
.x
->vbox_widget
= wvbox
;
1088 f
->output_data
.x
->hbox_widget
= whbox
;
1090 gtk_widget_set_has_window (wfixed
, TRUE
);
1092 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1093 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1094 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1096 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1097 update_frame_tool_bar (f
);
1099 /* We don't want this widget double buffered, because we draw on it
1100 with regular X drawing primitives, so from a GTK/GDK point of
1101 view, the widget is totally blank. When an expose comes, this
1102 will make the widget blank, and then Emacs redraws it. This flickers
1103 a lot, so we turn off double buffering. */
1104 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1106 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1107 SSDATA (Vx_resource_name
),
1108 SSDATA (Vx_resource_class
));
1110 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1111 GTK is to destroy the widget. We want Emacs to do that instead. */
1112 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1113 G_CALLBACK (delete_cb
), f
);
1115 /* Convert our geometry parameters into a geometry string
1117 GTK will itself handle calculating the real position this way. */
1118 xg_set_geometry (f
);
1120 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1122 gtk_widget_add_events (wfixed
,
1123 GDK_POINTER_MOTION_MASK
1125 | GDK_BUTTON_PRESS_MASK
1126 | GDK_BUTTON_RELEASE_MASK
1127 | GDK_KEY_PRESS_MASK
1128 | GDK_ENTER_NOTIFY_MASK
1129 | GDK_LEAVE_NOTIFY_MASK
1130 | GDK_FOCUS_CHANGE_MASK
1131 | GDK_STRUCTURE_MASK
1132 | GDK_VISIBILITY_NOTIFY_MASK
);
1134 /* Must realize the windows so the X window gets created. It is used
1135 by callers of this function. */
1136 gtk_widget_realize (wfixed
);
1137 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1139 /* Since GTK clears its window by filling with the background color,
1140 we must keep X and GTK background in sync. */
1141 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1144 /* Also, do not let any background pixmap to be set, this looks very
1145 bad as Emacs overwrites the background pixmap with its own idea
1146 of background color. */
1147 style
= gtk_widget_get_modifier_style (wfixed
);
1149 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1150 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1151 gtk_widget_modify_style (wfixed
, style
);
1153 gtk_widget_set_can_focus (wfixed
, TRUE
);
1156 #ifdef USE_GTK_TOOLTIP
1157 /* Steal a tool tip window we can move ourselves. */
1158 f
->output_data
.x
->ttip_widget
= 0;
1159 f
->output_data
.x
->ttip_lbl
= 0;
1160 f
->output_data
.x
->ttip_window
= 0;
1161 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1162 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1166 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1167 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1168 /* Only connect this signal once per screen. */
1169 if (! g_signal_handler_find (G_OBJECT (gs
),
1170 G_SIGNAL_MATCH_FUNC
,
1172 G_CALLBACK (style_changed_cb
),
1175 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1176 G_CALLBACK (style_changed_cb
),
1177 gdk_screen_get_display (screen
));
1187 xg_free_frame_widgets (FRAME_PTR f
)
1189 if (FRAME_GTK_OUTER_WIDGET (f
))
1191 #ifdef USE_GTK_TOOLTIP
1192 struct x_output
*x
= f
->output_data
.x
;
1194 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1195 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1196 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1197 #ifdef USE_GTK_TOOLTIP
1199 gtk_widget_destroy (x
->ttip_lbl
);
1201 g_object_unref (G_OBJECT (x
->ttip_widget
));
1206 /* Set the normal size hints for the window manager, for frame F.
1207 FLAGS is the flags word to use--or 0 meaning preserve the flags
1208 that the window now has.
1209 If USER_POSITION is nonzero, we set the User Position
1210 flag (this is useful when FLAGS is 0). */
1213 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
1215 /* Must use GTK routines here, otherwise GTK resets the size hints
1216 to its own defaults. */
1217 GdkGeometry size_hints
;
1218 gint hint_flags
= 0;
1219 int base_width
, base_height
;
1220 int min_rows
= 0, min_cols
= 0;
1221 int win_gravity
= f
->win_gravity
;
1223 /* Don't set size hints during initialization; that apparently leads
1224 to a race condition. See the thread at
1225 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1226 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1231 memset (&size_hints
, 0, sizeof (size_hints
));
1232 f
->output_data
.x
->size_hints
= size_hints
;
1233 f
->output_data
.x
->hint_flags
= hint_flags
;
1236 flags
= f
->size_hint_flags
;
1238 size_hints
= f
->output_data
.x
->size_hints
;
1239 hint_flags
= f
->output_data
.x
->hint_flags
;
1241 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1242 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1243 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1245 hint_flags
|= GDK_HINT_BASE_SIZE
;
1246 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0) + FRAME_TOOLBAR_WIDTH (f
);
1247 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
1248 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1250 check_frame_size (f
, &min_rows
, &min_cols
);
1252 size_hints
.base_width
= base_width
;
1253 size_hints
.base_height
= base_height
;
1254 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1255 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1257 /* These currently have a one to one mapping with the X values, but I
1258 don't think we should rely on that. */
1259 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1260 size_hints
.win_gravity
= 0;
1261 if (win_gravity
== NorthWestGravity
)
1262 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1263 else if (win_gravity
== NorthGravity
)
1264 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1265 else if (win_gravity
== NorthEastGravity
)
1266 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1267 else if (win_gravity
== WestGravity
)
1268 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1269 else if (win_gravity
== CenterGravity
)
1270 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1271 else if (win_gravity
== EastGravity
)
1272 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1273 else if (win_gravity
== SouthWestGravity
)
1274 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1275 else if (win_gravity
== SouthGravity
)
1276 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1277 else if (win_gravity
== SouthEastGravity
)
1278 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1279 else if (win_gravity
== StaticGravity
)
1280 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1284 hint_flags
&= ~GDK_HINT_POS
;
1285 hint_flags
|= GDK_HINT_USER_POS
;
1288 if (hint_flags
!= f
->output_data
.x
->hint_flags
1289 || memcmp (&size_hints
,
1290 &f
->output_data
.x
->size_hints
,
1291 sizeof (size_hints
)) != 0)
1294 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1295 NULL
, &size_hints
, hint_flags
);
1296 f
->output_data
.x
->size_hints
= size_hints
;
1297 f
->output_data
.x
->hint_flags
= hint_flags
;
1302 /* Change background color of a frame.
1303 Since GTK uses the background color to clear the window, we must
1304 keep the GTK and X colors in sync.
1305 F is the frame to change,
1306 BG is the pixel value to change to. */
1309 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
1311 if (FRAME_GTK_WIDGET (f
))
1314 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1320 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1321 functions so GTK does not overwrite the icon. */
1324 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1326 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1330 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1335 /***********************************************************************
1337 ***********************************************************************/
1338 /* Return the dialog title to use for a dialog of type KEY.
1339 This is the encoding used by lwlib. We use the same for GTK. */
1342 get_dialog_title (char key
)
1344 const char *title
= "";
1352 title
= "Information";
1371 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1372 the dialog, but return TRUE so the event does not propagate further
1373 in GTK. This prevents GTK from destroying the dialog widget automatically
1374 and we can always destrou the widget manually, regardles of how
1375 it was popped down (button press or WM_DELETE_WINDOW).
1376 W is the dialog widget.
1377 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1378 user_data is NULL (not used).
1380 Returns TRUE to end propagation of event. */
1383 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1385 gtk_widget_unmap (w
);
1389 /* Create a popup dialog window. See also xg_create_widget below.
1390 WV is a widget_value describing the dialog.
1391 SELECT_CB is the callback to use when a button has been pressed.
1392 DEACTIVATE_CB is the callback to use when the dialog pops down.
1394 Returns the GTK dialog widget. */
1397 create_dialog (widget_value
*wv
,
1398 GCallback select_cb
,
1399 GCallback deactivate_cb
)
1401 const char *title
= get_dialog_title (wv
->name
[0]);
1402 int total_buttons
= wv
->name
[1] - '0';
1403 int right_buttons
= wv
->name
[4] - '0';
1406 int button_spacing
= 10;
1407 GtkWidget
*wdialog
= gtk_dialog_new ();
1408 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1409 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1412 GtkWidget
*whbox_up
;
1413 GtkWidget
*whbox_down
;
1415 /* If the number of buttons is greater than 4, make two rows of buttons
1416 instead. This looks better. */
1417 int make_two_rows
= total_buttons
> 4;
1419 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1420 left_buttons
= total_buttons
- right_buttons
;
1422 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1423 gtk_widget_set_name (wdialog
, "emacs-dialog");
1428 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1429 whbox_up
= gtk_hbox_new (FALSE
, 0);
1430 whbox_down
= gtk_hbox_new (FALSE
, 0);
1432 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1433 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1434 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1436 cur_box
= GTK_BOX (whbox_up
);
1439 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1440 G_CALLBACK (dialog_delete_callback
), 0);
1444 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1445 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1448 for (item
= wv
->contents
; item
; item
= item
->next
)
1450 char *utf8_label
= get_utf8_string (item
->value
);
1454 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1456 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1457 /* This is the text part of the dialog. */
1458 w
= gtk_label_new (utf8_label
);
1459 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1460 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1461 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1463 /* Try to make dialog look better. Must realize first so
1464 the widget can calculate the size it needs. */
1465 gtk_widget_realize (w
);
1466 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1467 gtk_box_set_spacing (wvbox
, req
.height
);
1468 if (item
->value
&& strlen (item
->value
) > 0)
1469 button_spacing
= 2*req
.width
/strlen (item
->value
);
1473 /* This is one button to add to the dialog. */
1474 w
= gtk_button_new_with_label (utf8_label
);
1475 if (! item
->enabled
)
1476 gtk_widget_set_sensitive (w
, FALSE
);
1478 g_signal_connect (G_OBJECT (w
), "clicked",
1479 select_cb
, item
->call_data
);
1481 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1482 if (++button_nr
== left_buttons
)
1485 cur_box
= GTK_BOX (whbox_down
);
1487 gtk_box_pack_start (cur_box
,
1495 g_free (utf8_label
);
1501 struct xg_dialog_data
1509 /* Function that is called when the file or font dialogs pop down.
1510 W is the dialog widget, RESPONSE is the response code.
1511 USER_DATA is what we passed in to g_signal_connect. */
1514 xg_dialog_response_cb (GtkDialog
*w
,
1518 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1519 dd
->response
= response
;
1520 g_main_loop_quit (dd
->loop
);
1524 /* Destroy the dialog. This makes it pop down. */
1527 pop_down_dialog (Lisp_Object arg
)
1529 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1530 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1533 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1534 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1536 g_main_loop_quit (dd
->loop
);
1537 g_main_loop_unref (dd
->loop
);
1544 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1545 We pass in DATA as gpointer* so we can use this as a callback. */
1548 xg_maybe_add_timer (gpointer data
)
1550 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1551 EMACS_TIME next_time
= timer_check (1);
1552 long secs
= EMACS_SECS (next_time
);
1553 long usecs
= EMACS_USECS (next_time
);
1557 if (secs
>= 0 && usecs
>= 0 && secs
< ((guint
)-1)/1000)
1559 dd
->timerid
= g_timeout_add (secs
* 1000 + usecs
/1000,
1567 /* Pops up a modal dialog W and waits for response.
1568 We don't use gtk_dialog_run because we want to process emacs timers.
1569 The dialog W is not destroyed when this function returns. */
1572 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1574 int count
= SPECPDL_INDEX ();
1575 struct xg_dialog_data dd
;
1577 xg_set_screen (w
, f
);
1578 gtk_window_set_transient_for (GTK_WINDOW (w
),
1579 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1580 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1581 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1583 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1584 dd
.response
= GTK_RESPONSE_CANCEL
;
1588 g_signal_connect (G_OBJECT (w
),
1590 G_CALLBACK (xg_dialog_response_cb
),
1592 /* Don't destroy the widget if closed by the window manager close button. */
1593 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1594 gtk_widget_show (w
);
1596 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1598 (void) xg_maybe_add_timer (&dd
);
1599 g_main_loop_run (dd
.loop
);
1602 unbind_to (count
, Qnil
);
1608 /***********************************************************************
1609 File dialog functions
1610 ***********************************************************************/
1611 /* Return non-zero if the old file selection dialog is being used.
1612 Return zero if not. */
1615 xg_uses_old_file_dialog (void)
1617 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1618 return x_gtk_use_old_file_dialog
;
1625 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1627 /* Return the selected file for file chooser dialog W.
1628 The returned string must be free:d. */
1631 xg_get_file_name_from_chooser (GtkWidget
*w
)
1633 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1636 /* Callback called when the "Show hidden files" toggle is pressed.
1637 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1640 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1642 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1644 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1645 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1649 /* Callback called when a property changes in a file chooser.
1650 GOBJECT is the file chooser dialog, ARG1 describes the property.
1651 USER_DATA is the toggle widget in the file chooser dialog.
1652 We use this to update the "Show hidden files" toggle when the user
1653 changes that property by right clicking in the file list. */
1656 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1658 if (strcmp (arg1
->name
, "show-hidden") == 0)
1660 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1661 gboolean visible
, toggle_on
;
1663 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1664 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1666 if (!!visible
!= !!toggle_on
)
1668 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1669 G_CALLBACK (xg_toggle_visibility_cb
),
1671 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1672 g_signal_handlers_unblock_by_func
1673 (G_OBJECT (wtoggle
),
1674 G_CALLBACK (xg_toggle_visibility_cb
),
1677 x_gtk_show_hidden_files
= visible
;
1681 /* Read a file name from the user using a file chooser dialog.
1682 F is the current frame.
1683 PROMPT is a prompt to show to the user. May not be NULL.
1684 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1685 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1686 file. *FUNC is set to a function that can be used to retrieve the
1687 selected file name from the returned widget.
1689 Returns the created widget. */
1692 xg_get_file_with_chooser (FRAME_PTR f
,
1694 char *default_filename
,
1695 int mustmatch_p
, int only_dir_p
,
1696 xg_get_file_func
*func
)
1700 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1701 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1702 GtkFileChooserAction action
= (mustmatch_p
?
1703 GTK_FILE_CHOOSER_ACTION_OPEN
:
1704 GTK_FILE_CHOOSER_ACTION_SAVE
);
1707 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1709 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1710 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1711 (mustmatch_p
|| only_dir_p
?
1712 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1715 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1717 wbox
= gtk_vbox_new (FALSE
, 0);
1718 gtk_widget_show (wbox
);
1719 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1721 if (x_gtk_show_hidden_files
)
1723 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1724 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1726 gtk_widget_show (wtoggle
);
1727 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1728 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1729 g_signal_connect (G_OBJECT (filewin
), "notify",
1730 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1732 if (x_gtk_file_dialog_help_text
)
1735 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1736 Show the C-l help text only for versions < 2.10. */
1737 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1738 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1739 strcat (message
, "\nIf you don't like this file selector, use the "
1740 "corresponding\nkey binding or customize "
1741 "use-file-dialog to turn it off.");
1743 wmessage
= gtk_label_new (message
);
1744 gtk_widget_show (wmessage
);
1747 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1748 if (x_gtk_file_dialog_help_text
)
1749 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1750 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1752 if (default_filename
)
1755 struct gcpro gcpro1
;
1756 char *utf8_filename
;
1759 file
= build_string (default_filename
);
1761 /* File chooser does not understand ~/... in the file name. It must be
1762 an absolute name starting with /. */
1763 if (default_filename
[0] != '/')
1764 file
= Fexpand_file_name (file
, Qnil
);
1766 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1767 if (! NILP (Ffile_directory_p (file
)))
1768 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1772 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1774 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1776 char *cp
= strrchr (utf8_filename
, '/');
1778 else cp
= utf8_filename
;
1779 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1786 *func
= xg_get_file_name_from_chooser
;
1790 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1792 /* Return the selected file for file selector dialog W.
1793 The returned string must be free:d. */
1796 xg_get_file_name_from_selector (GtkWidget
*w
)
1798 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1799 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1802 /* Create a file selection dialog.
1803 F is the current frame.
1804 PROMPT is a prompt to show to the user. May not be NULL.
1805 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1806 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1807 file. *FUNC is set to a function that can be used to retrieve the
1808 selected file name from the returned widget.
1810 Returns the created widget. */
1813 xg_get_file_with_selection (FRAME_PTR f
,
1815 char *default_filename
,
1816 int mustmatch_p
, int only_dir_p
,
1817 xg_get_file_func
*func
)
1820 GtkFileSelection
*filesel
;
1822 filewin
= gtk_file_selection_new (prompt
);
1823 filesel
= GTK_FILE_SELECTION (filewin
);
1825 if (default_filename
)
1826 gtk_file_selection_set_filename (filesel
, default_filename
);
1830 /* The selection_entry part of filesel is not documented. */
1831 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1832 gtk_file_selection_hide_fileop_buttons (filesel
);
1835 *func
= xg_get_file_name_from_selector
;
1839 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1841 /* Read a file name from the user using a file dialog, either the old
1842 file selection dialog, or the new file chooser dialog. Which to use
1843 depends on what the GTK version used has, and what the value of
1844 gtk-use-old-file-dialog.
1845 F is the current frame.
1846 PROMPT is a prompt to show to the user. May not be NULL.
1847 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1848 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1851 Returns a file name or NULL if no file was selected.
1852 The returned string must be freed by the caller. */
1855 xg_get_file_name (FRAME_PTR f
,
1857 char *default_filename
,
1863 int filesel_done
= 0;
1864 xg_get_file_func func
;
1866 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1867 /* I really don't know why this is needed, but without this the GLIBC add on
1868 library linuxthreads hangs when the Gnome file chooser backend creates
1870 sigblock (sigmask (__SIGRTMIN
));
1871 #endif /* HAVE_GTK_AND_PTHREAD */
1873 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1875 if (xg_uses_old_file_dialog ())
1876 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1877 mustmatch_p
, only_dir_p
, &func
);
1879 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1880 mustmatch_p
, only_dir_p
, &func
);
1882 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1883 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1884 mustmatch_p
, only_dir_p
, &func
);
1885 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1887 gtk_widget_set_name (w
, "emacs-filedialog");
1889 filesel_done
= xg_dialog_run (f
, w
);
1891 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1892 sigunblock (sigmask (__SIGRTMIN
));
1895 if (filesel_done
== GTK_RESPONSE_OK
)
1898 gtk_widget_destroy (w
);
1902 #ifdef HAVE_FREETYPE
1903 /* Pop up a GTK font selector and return the name of the font the user
1904 selects, as a C string. The returned font name follows GTK's own
1907 `FAMILY [VALUE1 VALUE2] SIZE'
1909 This can be parsed using font_parse_fcname in font.c.
1910 DEFAULT_NAME, if non-zero, is the default font name. */
1913 xg_get_font_name (FRAME_PTR f
, const char *default_name
)
1916 char *fontname
= NULL
;
1919 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1920 sigblock (sigmask (__SIGRTMIN
));
1921 #endif /* HAVE_GTK_AND_PTHREAD */
1923 w
= gtk_font_selection_dialog_new ("Pick a font");
1925 default_name
= "Monospace 10";
1926 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1929 gtk_widget_set_name (w
, "emacs-fontdialog");
1931 done
= xg_dialog_run (f
, w
);
1933 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1934 sigunblock (sigmask (__SIGRTMIN
));
1937 if (done
== GTK_RESPONSE_OK
)
1938 fontname
= gtk_font_selection_dialog_get_font_name
1939 (GTK_FONT_SELECTION_DIALOG (w
));
1941 gtk_widget_destroy (w
);
1944 #endif /* HAVE_FREETYPE */
1948 /***********************************************************************
1950 ***********************************************************************/
1952 /* The name of menu items that can be used for customization. Since GTK
1953 RC files are very crude and primitive, we have to set this on all
1954 menu item names so a user can easily customize menu items. */
1956 #define MENU_ITEM_NAME "emacs-menuitem"
1959 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1960 during GC. The next member points to the items. */
1961 static xg_list_node xg_menu_cb_list
;
1963 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1964 during GC. The next member points to the items. */
1965 static xg_list_node xg_menu_item_cb_list
;
1967 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1968 F is the frame CL_DATA will be initialized for.
1969 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1971 The menu bar and all sub menus under the menu bar in a frame
1972 share the same structure, hence the reference count.
1974 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1975 allocated xg_menu_cb_data if CL_DATA is NULL. */
1977 static xg_menu_cb_data
*
1978 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
1982 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1984 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1985 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1986 cl_data
->highlight_cb
= highlight_cb
;
1987 cl_data
->ref_count
= 0;
1989 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1992 cl_data
->ref_count
++;
1997 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1998 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2000 When the menu bar is updated, menu items may have been added and/or
2001 removed, so menu_bar_vector and menu_bar_items_used change. We must
2002 then update CL_DATA since it is used to determine which menu
2003 item that is invoked in the menu.
2004 HIGHLIGHT_CB could change, there is no check that the same
2005 function is given when modifying a menu bar as was given when
2006 creating the menu bar. */
2009 update_cl_data (xg_menu_cb_data
*cl_data
,
2011 GCallback highlight_cb
)
2016 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2017 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2018 cl_data
->highlight_cb
= highlight_cb
;
2022 /* Decrease reference count for CL_DATA.
2023 If reference count is zero, free CL_DATA. */
2026 unref_cl_data (xg_menu_cb_data
*cl_data
)
2028 if (cl_data
&& cl_data
->ref_count
> 0)
2030 cl_data
->ref_count
--;
2031 if (cl_data
->ref_count
== 0)
2033 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2039 /* Function that marks all lisp data during GC. */
2046 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2047 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2049 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2051 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2053 if (! NILP (cb_data
->help
))
2054 mark_object (cb_data
->help
);
2059 /* Callback called when a menu item is destroyed. Used to free data.
2060 W is the widget that is being destroyed (not used).
2061 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2064 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2068 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
2069 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2074 /* Callback called when the pointer enters/leaves a menu item.
2075 W is the parent of the menu item.
2076 EVENT is either an enter event or leave event.
2077 CLIENT_DATA is not used.
2079 Returns FALSE to tell GTK to keep processing this event. */
2082 menuitem_highlight_callback (GtkWidget
*w
,
2083 GdkEventCrossing
*event
,
2084 gpointer client_data
)
2087 GtkWidget
*subwidget
;
2088 xg_menu_item_cb_data
*data
;
2090 ev
.crossing
= *event
;
2091 subwidget
= gtk_get_event_widget (&ev
);
2092 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
2096 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2098 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2099 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2100 (*func
) (subwidget
, call_data
);
2107 /* Callback called when a menu is destroyed. Used to free data.
2108 W is the widget that is being destroyed (not used).
2109 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2112 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2114 unref_cl_data ((xg_menu_cb_data
*) client_data
);
2117 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2118 must be non-NULL) and can be inserted into a menu item.
2120 Returns the GtkHBox. */
2123 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2129 wbox
= gtk_hbox_new (FALSE
, 0);
2130 wlbl
= gtk_label_new (utf8_label
);
2131 wkey
= gtk_label_new (utf8_key
);
2133 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2134 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2136 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2137 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2139 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2140 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2141 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2146 /* Make and return a menu item widget with the key to the right.
2147 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2148 UTF8_KEY is the text representing the key binding.
2149 ITEM is the widget_value describing the menu item.
2151 GROUP is an in/out parameter. If the menu item to be created is not
2152 part of any radio menu group, *GROUP contains NULL on entry and exit.
2153 If the menu item to be created is part of a radio menu group, on entry
2154 *GROUP contains the group to use, or NULL if this is the first item
2155 in the group. On exit, *GROUP contains the radio item group.
2157 Unfortunately, keys don't line up as nicely as in Motif,
2158 but the MacOS X version doesn't either, so I guess that is OK. */
2161 make_menu_item (const char *utf8_label
,
2162 const char *utf8_key
,
2167 GtkWidget
*wtoadd
= 0;
2169 /* It has been observed that some menu items have a NULL name field.
2170 This will lead to this function being called with a NULL utf8_label.
2171 GTK crashes on that so we set a blank label. Why there is a NULL
2172 name remains to be investigated. */
2173 if (! utf8_label
) utf8_label
= " ";
2176 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2178 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2181 if (utf8_key
) w
= gtk_check_menu_item_new ();
2182 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2183 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2185 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2187 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2188 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2189 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2191 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2196 if (utf8_key
) w
= gtk_menu_item_new ();
2197 else w
= gtk_menu_item_new_with_label (utf8_label
);
2200 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2201 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2206 static int xg_detached_menus
;
2208 /* Returns non-zero if there are detached menus. */
2211 xg_have_tear_offs (void)
2213 return xg_detached_menus
> 0;
2216 /* Callback invoked when a detached menu window is removed. Here we
2217 decrease the xg_detached_menus count.
2218 WIDGET is the top level window that is removed (the parent of the menu).
2219 CLIENT_DATA is not used. */
2222 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2224 if (xg_detached_menus
> 0) --xg_detached_menus
;
2227 /* Callback invoked when a menu is detached. It increases the
2228 xg_detached_menus count.
2229 WIDGET is the GtkTearoffMenuItem.
2230 CLIENT_DATA is not used. */
2233 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2235 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2236 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2238 ++xg_detached_menus
;
2239 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2241 G_CALLBACK (tearoff_remove
), 0);
2246 /* Create a menu item widget, and connect the callbacks.
2247 ITEM decribes the menu item.
2248 F is the frame the created menu belongs to.
2249 SELECT_CB is the callback to use when a menu item is selected.
2250 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2251 CL_DATA points to the callback data to be used for this menu.
2252 GROUP is an in/out parameter. If the menu item to be created is not
2253 part of any radio menu group, *GROUP contains NULL on entry and exit.
2254 If the menu item to be created is part of a radio menu group, on entry
2255 *GROUP contains the group to use, or NULL if this is the first item
2256 in the group. On exit, *GROUP contains the radio item group.
2258 Returns the created GtkWidget. */
2261 xg_create_one_menuitem (widget_value
*item
,
2263 GCallback select_cb
,
2264 GCallback highlight_cb
,
2265 xg_menu_cb_data
*cl_data
,
2271 xg_menu_item_cb_data
*cb_data
;
2273 utf8_label
= get_utf8_string (item
->name
);
2274 utf8_key
= get_utf8_string (item
->key
);
2276 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2278 if (utf8_label
) g_free (utf8_label
);
2279 if (utf8_key
) g_free (utf8_key
);
2281 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2283 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2285 cb_data
->select_id
= 0;
2286 cb_data
->help
= item
->help
;
2287 cb_data
->cl_data
= cl_data
;
2288 cb_data
->call_data
= item
->call_data
;
2290 g_signal_connect (G_OBJECT (w
),
2292 G_CALLBACK (menuitem_destroy_callback
),
2295 /* Put cb_data in widget, so we can get at it when modifying menubar */
2296 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2298 /* final item, not a submenu */
2299 if (item
->call_data
&& ! item
->contents
)
2303 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2309 /* Create a full menu tree specified by DATA.
2310 F is the frame the created menu belongs to.
2311 SELECT_CB is the callback to use when a menu item is selected.
2312 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2313 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2314 POP_UP_P is non-zero if we shall create a popup menu.
2315 MENU_BAR_P is non-zero if we shall create a menu bar.
2316 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2317 if MENU_BAR_P is non-zero.
2318 TOPMENU is the topmost GtkWidget that others shall be placed under.
2319 It may be NULL, in that case we create the appropriate widget
2320 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2321 CL_DATA is the callback data we shall use for this menu, or NULL
2322 if we haven't set the first callback yet.
2323 NAME is the name to give to the top level menu if this function
2324 creates it. May be NULL to not set any name.
2326 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2329 This function calls itself to create submenus. */
2332 create_menus (widget_value
*data
,
2334 GCallback select_cb
,
2335 GCallback deactivate_cb
,
2336 GCallback highlight_cb
,
2341 xg_menu_cb_data
*cl_data
,
2345 GtkWidget
*wmenu
= topmenu
;
2346 GSList
*group
= NULL
;
2352 wmenu
= gtk_menu_new ();
2353 xg_set_screen (wmenu
, f
);
2354 /* Connect this to the menu instead of items so we get enter/leave for
2355 disabled items also. TODO: Still does not get enter/leave for
2356 disabled items in detached menus. */
2357 g_signal_connect (G_OBJECT (wmenu
),
2358 "enter-notify-event",
2359 G_CALLBACK (menuitem_highlight_callback
),
2361 g_signal_connect (G_OBJECT (wmenu
),
2362 "leave-notify-event",
2363 G_CALLBACK (menuitem_highlight_callback
),
2368 wmenu
= gtk_menu_bar_new ();
2369 /* Set width of menu bar to a small value so it doesn't enlarge
2370 a small initial frame size. The width will be set to the
2371 width of the frame later on when it is added to a container.
2372 height -1: Natural height. */
2373 gtk_widget_set_size_request (wmenu
, 1, -1);
2376 /* Put cl_data on the top menu for easier access. */
2377 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2378 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2379 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2380 G_CALLBACK (menu_destroy_callback
), cl_data
);
2383 gtk_widget_set_name (wmenu
, name
);
2386 g_signal_connect (G_OBJECT (wmenu
),
2387 "selection-done", deactivate_cb
, 0);
2390 if (! menu_bar_p
&& add_tearoff_p
)
2392 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2393 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2395 g_signal_connect (G_OBJECT (tearoff
), "activate",
2396 G_CALLBACK (tearoff_activate
), 0);
2399 for (item
= data
; item
; item
= item
->next
)
2403 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2404 && !menu_separator_name_p (item
->name
))
2407 /* A title for a popup. We do the same as GTK does when
2408 creating titles, but it does not look good. */
2410 utf8_label
= get_utf8_string (item
->name
);
2412 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2413 w
= gtk_menu_item_new_with_label (utf8_label
);
2414 gtk_widget_set_sensitive (w
, FALSE
);
2415 if (utf8_label
) g_free (utf8_label
);
2417 else if (menu_separator_name_p (item
->name
))
2420 /* GTK only have one separator type. */
2421 w
= gtk_separator_menu_item_new ();
2425 w
= xg_create_one_menuitem (item
,
2427 item
->contents
? 0 : select_cb
,
2432 /* Create a possibly empty submenu for menu bar items, since some
2433 themes don't highlight items correctly without it. */
2434 if (item
->contents
|| menu_bar_p
)
2436 GtkWidget
*submenu
= create_menus (item
->contents
,
2447 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2451 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2452 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2458 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2459 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2460 with some text and buttons.
2461 F is the frame the created item belongs to.
2462 NAME is the name to use for the top widget.
2463 VAL is a widget_value structure describing items to be created.
2464 SELECT_CB is the callback to use when a menu item is selected or
2465 a dialog button is pressed.
2466 DEACTIVATE_CB is the callback to use when an item is deactivated.
2467 For a menu, when a sub menu is not shown anymore, for a dialog it is
2468 called when the dialog is popped down.
2469 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2471 Returns the widget created. */
2474 xg_create_widget (const char *type
, const char *name
, FRAME_PTR f
, widget_value
*val
,
2475 GCallback select_cb
, GCallback deactivate_cb
,
2476 GCallback highlight_cb
)
2479 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2480 int pop_up_p
= strcmp (type
, "popup") == 0;
2482 if (strcmp (type
, "dialog") == 0)
2484 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2485 xg_set_screen (w
, f
);
2486 gtk_window_set_transient_for (GTK_WINDOW (w
),
2487 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2488 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2489 gtk_widget_set_name (w
, "emacs-dialog");
2490 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2492 else if (menu_bar_p
|| pop_up_p
)
2494 w
= create_menus (val
->contents
,
2506 /* Set the cursor to an arrow for popup menus when they are mapped.
2507 This is done by default for menu bar menus. */
2510 /* Must realize so the GdkWindow inside the widget is created. */
2511 gtk_widget_realize (w
);
2512 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2517 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2524 /* Return the label for menu item WITEM. */
2527 xg_get_menu_item_label (GtkMenuItem
*witem
)
2529 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2530 return gtk_label_get_label (wlabel
);
2533 /* Return non-zero if the menu item WITEM has the text LABEL. */
2536 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2539 char *utf8_label
= get_utf8_string (label
);
2540 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2542 if (! old_label
&& ! utf8_label
)
2544 else if (old_label
&& utf8_label
)
2545 is_same
= strcmp (utf8_label
, old_label
) == 0;
2547 if (utf8_label
) g_free (utf8_label
);
2552 /* Destroy widgets in LIST. */
2555 xg_destroy_widgets (GList
*list
)
2559 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2561 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2563 /* Destroying the widget will remove it from the container it is in. */
2564 gtk_widget_destroy (w
);
2568 /* Update the top level names in MENUBAR (i.e. not submenus).
2569 F is the frame the menu bar belongs to.
2570 *LIST is a list with the current menu bar names (menu item widgets).
2571 ITER is the item within *LIST that shall be updated.
2572 POS is the numerical position, starting at 0, of ITER in *LIST.
2573 VAL describes what the menu bar shall look like after the update.
2574 SELECT_CB is the callback to use when a menu item is selected.
2575 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2576 CL_DATA points to the callback data to be used for this menu bar.
2578 This function calls itself to walk through the menu bar names. */
2581 xg_update_menubar (GtkWidget
*menubar
,
2587 GCallback select_cb
,
2588 GCallback deactivate_cb
,
2589 GCallback highlight_cb
,
2590 xg_menu_cb_data
*cl_data
)
2592 if (! iter
&& ! val
)
2594 else if (iter
&& ! val
)
2596 /* Item(s) have been removed. Remove all remaining items. */
2597 xg_destroy_widgets (iter
);
2599 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2600 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2601 gtk_menu_item_new_with_label (""),
2607 else if (! iter
&& val
)
2609 /* Item(s) added. Add all new items in one call. */
2610 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2611 0, 1, 0, menubar
, cl_data
, 0);
2617 /* Below this neither iter or val is NULL */
2618 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2620 /* This item is still the same, check next item. */
2622 iter
= g_list_next (iter
);
2625 else /* This item is changed. */
2627 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2628 GtkMenuItem
*witem2
= 0;
2629 int val_in_menubar
= 0;
2630 int iter_in_new_menubar
= 0;
2634 /* See if the changed entry (val) is present later in the menu bar */
2636 iter2
&& ! val_in_menubar
;
2637 iter2
= g_list_next (iter2
))
2639 witem2
= GTK_MENU_ITEM (iter2
->data
);
2640 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2643 /* See if the current entry (iter) is present later in the
2644 specification for the new menu bar. */
2645 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2646 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2648 if (val_in_menubar
&& ! iter_in_new_menubar
)
2652 /* This corresponds to:
2657 g_object_ref (G_OBJECT (witem
));
2658 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2659 gtk_widget_destroy (GTK_WIDGET (witem
));
2661 /* Must get new list since the old changed. */
2662 g_list_free (*list
);
2663 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2664 while (nr
-- > 0) iter
= g_list_next (iter
);
2666 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2668 /* This corresponds to:
2671 Rename B to X. This might seem to be a strange thing to do,
2672 since if there is a menu under B it will be totally wrong for X.
2673 But consider editing a C file. Then there is a C-mode menu
2674 (corresponds to B above).
2675 If then doing C-x C-f the minibuf menu (X above) replaces the
2676 C-mode menu. When returning from the minibuffer, we get
2677 back the C-mode menu. Thus we do:
2678 Rename B to X (C-mode to minibuf menu)
2679 Rename X to B (minibuf to C-mode menu).
2680 If the X menu hasn't been invoked, the menu under B
2681 is up to date when leaving the minibuffer. */
2682 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2683 char *utf8_label
= get_utf8_string (val
->name
);
2684 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2686 gtk_label_set_text (wlabel
, utf8_label
);
2688 /* If this item has a submenu that has been detached, change
2689 the title in the WM decorations also. */
2690 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2691 /* Set the title of the detached window. */
2692 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2694 if (utf8_label
) g_free (utf8_label
);
2695 iter
= g_list_next (iter
);
2699 else if (! val_in_menubar
&& iter_in_new_menubar
)
2701 /* This corresponds to:
2708 GtkWidget
*w
= xg_create_one_menuitem (val
,
2715 /* Create a possibly empty submenu for menu bar items, since some
2716 themes don't highlight items correctly without it. */
2717 GtkWidget
*submenu
= create_menus (NULL
, f
,
2718 select_cb
, deactivate_cb
,
2720 0, 0, 0, 0, cl_data
, 0);
2721 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2722 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2723 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2725 g_list_free (*list
);
2726 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2727 while (nr
-- > 0) iter
= g_list_next (iter
);
2728 iter
= g_list_next (iter
);
2732 else /* if (val_in_menubar && iter_in_new_menubar) */
2735 /* This corresponds to:
2740 g_object_ref (G_OBJECT (witem2
));
2741 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2742 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2743 GTK_WIDGET (witem2
), pos
);
2744 g_object_unref (G_OBJECT (witem2
));
2746 g_list_free (*list
);
2747 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2748 while (nr
-- > 0) iter
= g_list_next (iter
);
2749 if (iter
) iter
= g_list_next (iter
);
2755 /* Update the rest of the menu bar. */
2756 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2757 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2760 /* Update the menu item W so it corresponds to VAL.
2761 SELECT_CB is the callback to use when a menu item is selected.
2762 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2763 CL_DATA is the data to set in the widget for menu invocation. */
2766 xg_update_menu_item (widget_value
*val
,
2768 GCallback select_cb
,
2769 GCallback highlight_cb
,
2770 xg_menu_cb_data
*cl_data
)
2777 const char *old_label
= 0;
2778 const char *old_key
= 0;
2779 xg_menu_item_cb_data
*cb_data
;
2781 wchild
= XG_BIN_CHILD (w
);
2782 utf8_label
= get_utf8_string (val
->name
);
2783 utf8_key
= get_utf8_string (val
->key
);
2785 /* See if W is a menu item with a key. See make_menu_item above. */
2786 if (GTK_IS_HBOX (wchild
))
2788 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2790 wlbl
= GTK_LABEL (list
->data
);
2791 wkey
= GTK_LABEL (list
->next
->data
);
2796 /* Remove the key and keep just the label. */
2797 g_object_ref (G_OBJECT (wlbl
));
2798 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2799 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2800 g_object_unref (G_OBJECT (wlbl
));
2805 else /* Just a label. */
2807 wlbl
= GTK_LABEL (wchild
);
2809 /* Check if there is now a key. */
2812 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2813 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2815 wlbl
= GTK_LABEL (list
->data
);
2816 wkey
= GTK_LABEL (list
->next
->data
);
2819 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2820 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2825 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2826 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2828 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2829 gtk_label_set_text (wkey
, utf8_key
);
2831 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2832 gtk_label_set_text (wlbl
, utf8_label
);
2834 if (utf8_key
) g_free (utf8_key
);
2835 if (utf8_label
) g_free (utf8_label
);
2837 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2838 gtk_widget_set_sensitive (w
, FALSE
);
2839 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2840 gtk_widget_set_sensitive (w
, TRUE
);
2842 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2846 cb_data
->call_data
= val
->call_data
;
2847 cb_data
->help
= val
->help
;
2848 cb_data
->cl_data
= cl_data
;
2850 /* We assume the callback functions don't change. */
2851 if (val
->call_data
&& ! val
->contents
)
2853 /* This item shall have a select callback. */
2854 if (! cb_data
->select_id
)
2856 = g_signal_connect (G_OBJECT (w
), "activate",
2857 select_cb
, cb_data
);
2859 else if (cb_data
->select_id
)
2861 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2862 cb_data
->select_id
= 0;
2867 /* Update the toggle menu item W so it corresponds to VAL. */
2870 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
2872 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2875 /* Update the radio menu item W so it corresponds to VAL. */
2878 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
2880 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2883 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2884 SUBMENU may be NULL, in that case a new menu is created.
2885 F is the frame the menu bar belongs to.
2886 VAL describes the contents of the menu bar.
2887 SELECT_CB is the callback to use when a menu item is selected.
2888 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2889 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2890 CL_DATA is the call back data to use for any newly created items.
2892 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2896 xg_update_submenu (GtkWidget
*submenu
,
2899 GCallback select_cb
,
2900 GCallback deactivate_cb
,
2901 GCallback highlight_cb
,
2902 xg_menu_cb_data
*cl_data
)
2904 GtkWidget
*newsub
= submenu
;
2908 int has_tearoff_p
= 0;
2909 GList
*first_radio
= 0;
2912 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2914 for (cur
= val
, iter
= list
;
2916 iter
= g_list_next (iter
), cur
= cur
->next
)
2918 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2920 /* Skip tearoff items, they have no counterpart in val. */
2921 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2924 iter
= g_list_next (iter
);
2925 if (iter
) w
= GTK_WIDGET (iter
->data
);
2929 /* Remember first radio button in a group. If we get a mismatch in
2930 a radio group we must rebuild the whole group so that the connections
2931 in GTK becomes correct. */
2932 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2934 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2935 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2938 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2940 if (! menu_separator_name_p (cur
->name
))
2943 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2945 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2947 xg_update_toggle_item (cur
, w
);
2948 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2950 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2952 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2954 xg_update_radio_item (cur
, w
);
2955 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2957 else if (GTK_IS_MENU_ITEM (w
))
2959 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2962 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2963 menu_separator_name_p (cur
->name
))
2966 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2968 sub
= gtk_menu_item_get_submenu (witem
);
2969 if (sub
&& ! cur
->contents
)
2971 /* Not a submenu anymore. */
2972 g_object_ref (G_OBJECT (sub
));
2973 remove_submenu (witem
);
2974 gtk_widget_destroy (sub
);
2976 else if (cur
->contents
)
2980 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2981 select_cb
, deactivate_cb
,
2982 highlight_cb
, cl_data
);
2984 /* If this item just became a submenu, we must set it. */
2986 gtk_menu_item_set_submenu (witem
, nsub
);
2991 /* Structural difference. Remove everything from here and down
2997 /* Remove widgets from first structual change. */
3000 /* If we are adding new menu items below, we must remove from
3001 first radio button so that radio groups become correct. */
3002 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3003 else xg_destroy_widgets (iter
);
3008 /* More items added. Create them. */
3009 newsub
= create_menus (cur
,
3022 if (list
) g_list_free (list
);
3027 /* Update the MENUBAR.
3028 F is the frame the menu bar belongs to.
3029 VAL describes the contents of the menu bar.
3030 If DEEP_P is non-zero, rebuild all but the top level menu names in
3031 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3032 SELECT_CB is the callback to use when a menu item is selected.
3033 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3034 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3037 xg_modify_menubar_widgets (GtkWidget
*menubar
, FRAME_PTR f
, widget_value
*val
,
3039 GCallback select_cb
, GCallback deactivate_cb
,
3040 GCallback highlight_cb
)
3042 xg_menu_cb_data
*cl_data
;
3043 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3047 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
3050 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3051 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3057 /* Update all sub menus.
3058 We must keep the submenus (GTK menu item widgets) since the
3059 X Window in the XEvent that activates the menu are those widgets. */
3061 /* Update cl_data, menu_item things in F may have changed. */
3062 update_cl_data (cl_data
, f
, highlight_cb
);
3064 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3069 GtkMenuItem
*witem
= 0;
3071 /* Find sub menu that corresponds to val and update it. */
3072 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3074 witem
= GTK_MENU_ITEM (iter
->data
);
3075 if (xg_item_label_same_p (witem
, cur
->name
))
3077 sub
= gtk_menu_item_get_submenu (witem
);
3082 newsub
= xg_update_submenu (sub
,
3089 /* sub may still be NULL. If we just updated non deep and added
3090 a new menu bar item, it has no sub menu yet. So we set the
3091 newly created sub menu under witem. */
3092 if (newsub
!= sub
&& witem
!= 0)
3094 xg_set_screen (newsub
, f
);
3095 gtk_menu_item_set_submenu (witem
, newsub
);
3101 gtk_widget_show_all (menubar
);
3104 /* Callback called when the menu bar W is mapped.
3105 Used to find the height of the menu bar if we didn't get it
3106 after showing the widget. */
3109 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3112 FRAME_PTR f
= (FRAME_PTR
) user_data
;
3113 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3114 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3116 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3117 xg_height_or_width_changed (f
);
3121 /* Recompute all the widgets of frame F, when the menu bar has been
3122 changed. Value is non-zero if widgets were updated. */
3125 xg_update_frame_menubar (FRAME_PTR f
)
3127 struct x_output
*x
= f
->output_data
.x
;
3130 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3133 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3134 return 0; /* Already done this, happens for frames created invisible. */
3138 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3140 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3142 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3143 gtk_widget_show_all (x
->menubar_widget
);
3144 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3146 /* If menu bar doesn't know its height yet, cheat a little so the frame
3147 doesn't jump so much when resized later in menubar_map_cb. */
3148 if (req
.height
== 0)
3151 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3153 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3154 xg_height_or_width_changed (f
);
3161 /* Get rid of the menu bar of frame F, and free its storage.
3162 This is used when deleting a frame, and when turning off the menu bar. */
3165 free_frame_menubar (FRAME_PTR f
)
3167 struct x_output
*x
= f
->output_data
.x
;
3169 if (x
->menubar_widget
)
3173 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3174 /* The menubar and its children shall be deleted when removed from
3176 x
->menubar_widget
= 0;
3177 FRAME_MENUBAR_HEIGHT (f
) = 0;
3178 xg_height_or_width_changed (f
);
3184 xg_event_is_for_menubar (FRAME_PTR f
, XEvent
*event
)
3186 struct x_output
*x
= f
->output_data
.x
;
3195 if (! x
->menubar_widget
) return 0;
3197 if (! (event
->xbutton
.x
>= 0
3198 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3199 && event
->xbutton
.y
>= 0
3200 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3201 && event
->xbutton
.same_screen
))
3204 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3205 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3207 gevent
.any
.window
= gw
;
3208 gwdesc
= gtk_get_event_widget (&gevent
);
3209 if (! gwdesc
) return 0;
3210 if (! GTK_IS_MENU_BAR (gwdesc
)
3211 && ! GTK_IS_MENU_ITEM (gwdesc
)
3212 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3215 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3216 if (! list
) return 0;
3217 rec
.x
= event
->xbutton
.x
;
3218 rec
.y
= event
->xbutton
.y
;
3222 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3224 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3225 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3229 return iter
== 0 ? 0 : 1;
3234 /***********************************************************************
3235 Scroll bar functions
3236 ***********************************************************************/
3239 /* Setting scroll bar values invokes the callback. Use this variable
3240 to indicate that callback should do nothing. */
3242 int xg_ignore_gtk_scrollbar
;
3244 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3245 may be larger than 32 bits. Keep a mapping from integer index to widget
3246 pointers to get around the 32 bit limitation. */
3250 GtkWidget
**widgets
;
3255 /* Grow this much every time we need to allocate more */
3257 #define ID_TO_WIDGET_INCR 32
3259 /* Store the widget pointer W in id_to_widget and return the integer index. */
3262 xg_store_widget_in_map (GtkWidget
*w
)
3266 if (id_to_widget
.max_size
== id_to_widget
.used
)
3268 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3270 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
3271 sizeof (GtkWidget
*)*new_size
);
3273 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3274 id_to_widget
.widgets
[i
] = 0;
3275 id_to_widget
.max_size
= new_size
;
3278 /* Just loop over the array and find a free place. After all,
3279 how many scroll bars are we creating? Should be a small number.
3280 The check above guarantees we will find a free place. */
3281 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3283 if (! id_to_widget
.widgets
[i
])
3285 id_to_widget
.widgets
[i
] = w
;
3286 ++id_to_widget
.used
;
3292 /* Should never end up here */
3296 /* Remove pointer at IDX from id_to_widget.
3297 Called when scroll bar is destroyed. */
3300 xg_remove_widget_from_map (int idx
)
3302 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3304 id_to_widget
.widgets
[idx
] = 0;
3305 --id_to_widget
.used
;
3309 /* Get the widget pointer at IDX from id_to_widget. */
3312 xg_get_widget_from_map (int idx
)
3314 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3315 return id_to_widget
.widgets
[idx
];
3320 /* Return the scrollbar id for X Window WID on display DPY.
3321 Return -1 if WID not in id_to_widget. */
3324 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3329 w
= xg_win_to_widget (dpy
, wid
);
3333 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3334 if (id_to_widget
.widgets
[idx
] == w
)
3341 /* Callback invoked when scroll bar WIDGET is destroyed.
3342 DATA is the index into id_to_widget for WIDGET.
3343 We free pointer to last scroll bar values here and remove the index. */
3346 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3348 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
3349 xg_remove_widget_from_map (id
);
3352 /* Create a scroll bar widget for frame F. Store the scroll bar
3354 SCROLL_CALLBACK is the callback to invoke when the value of the
3356 END_CALLBACK is the callback to invoke when scrolling ends.
3357 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3358 to set resources for the widget. */
3361 xg_create_scroll_bar (FRAME_PTR f
,
3362 struct scroll_bar
*bar
,
3363 GCallback scroll_callback
,
3364 GCallback end_callback
,
3365 const char *scroll_bar_name
)
3371 GtkAdjustment
*vadj
;
3376 /* Page, step increment values are not so important here, they
3377 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3378 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3381 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3382 webox
= gtk_event_box_new ();
3383 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3385 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3387 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3389 scroll_id
= xg_store_widget_in_map (wscroll
);
3391 /* The EMACS_INT cast avoids a warning. */
3392 g_signal_connect (G_OBJECT (wscroll
),
3394 G_CALLBACK (xg_gtk_scroll_destroy
),
3395 (gpointer
) (EMACS_INT
) scroll_id
);
3396 g_signal_connect (G_OBJECT (wscroll
),
3400 g_signal_connect (G_OBJECT (wscroll
),
3401 "button-release-event",
3405 /* The scroll bar widget does not draw on a window of its own. Instead
3406 it draws on the parent window, in this case the edit widget. So
3407 whenever the edit widget is cleared, the scroll bar needs to redraw
3408 also, which causes flicker. Put an event box between the edit widget
3409 and the scroll bar, so the scroll bar instead draws itself on the
3410 event box window. */
3411 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3412 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3415 /* Set the cursor to an arrow. */
3416 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3418 bar
->x_window
= scroll_id
;
3421 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3424 xg_remove_scroll_bar (FRAME_PTR f
, int scrollbar_id
)
3426 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3429 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3430 gtk_widget_destroy (w
);
3431 gtk_widget_destroy (wparent
);
3432 SET_FRAME_GARBAGED (f
);
3436 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3438 TOP/LEFT are the new pixel positions where the bar shall appear.
3439 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3442 xg_update_scrollbar_pos (FRAME_PTR f
,
3450 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3454 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3455 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3458 /* Clear out old position. */
3459 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3460 if (gtk_widget_get_parent (wparent
) == wfixed
)
3462 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3463 "x", &oldx
, "y", &oldy
, NULL
);
3464 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3467 /* Move and resize to new values. */
3468 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3469 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3472 /* No room. Hide scroll bar as some themes output a warning if
3473 the height is less than the min size. */
3474 gtk_widget_hide (wparent
);
3475 gtk_widget_hide (wscroll
);
3479 gtk_widget_show_all (wparent
);
3480 gtk_widget_set_size_request (wscroll
, width
, height
);
3482 gtk_widget_queue_draw (wfixed
);
3483 gdk_window_process_all_updates ();
3484 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3486 /* Clear under old scroll bar position. This must be done after
3487 the gtk_widget_queue_draw and gdk_window_process_all_updates
3489 x_clear_area (FRAME_X_DISPLAY (f
),
3491 oldx
, oldy
, oldw
, oldh
, 0);
3494 /* GTK does not redraw until the main loop is entered again, but
3495 if there are no X events pending we will not enter it. So we sync
3496 here to get some events. */
3499 SET_FRAME_GARBAGED (f
);
3500 cancel_mouse_face (f
);
3504 /* Set the thumb size and position of scroll bar BAR. We are currently
3505 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3508 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3513 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3515 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3517 if (wscroll
&& NILP (bar
->dragging
))
3526 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3528 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3529 rather than the real portion value. This makes the thumb less likely
3530 to resize and that looks better. */
3531 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3532 /* When the thumb is at the bottom, position == whole.
3533 So we need to increase `whole' to make space for the thumb. */
3540 top
= (gdouble
) position
/ whole
;
3541 shown
= (gdouble
) portion
/ whole
;
3544 size
= shown
* XG_SB_RANGE
;
3545 size
= min (size
, XG_SB_RANGE
);
3546 size
= max (size
, 1);
3548 value
= top
* XG_SB_RANGE
;
3549 value
= min (value
, XG_SB_MAX
- size
);
3550 value
= max (value
, XG_SB_MIN
);
3552 /* Assume all lines are of equal size. */
3553 new_step
= size
/ max (1, FRAME_LINES (f
));
3555 if ((int) gtk_adjustment_get_page_size (adj
) != size
3556 || (int) gtk_adjustment_get_step_increment (adj
) != new_step
)
3558 gtk_adjustment_set_page_size (adj
, size
);
3559 gtk_adjustment_set_step_increment (adj
, new_step
);
3560 /* Assume a page increment is about 95% of the page size */
3561 gtk_adjustment_set_page_increment (adj
,(int) (0.95*size
));
3565 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3569 /* gtk_range_set_value invokes the callback. Set
3570 ignore_gtk_scrollbar to make the callback do nothing */
3571 xg_ignore_gtk_scrollbar
= 1;
3573 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3574 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3576 gtk_adjustment_changed (adj
);
3578 xg_ignore_gtk_scrollbar
= 0;
3585 /* Return non-zero if EVENT is for a scroll bar in frame F.
3586 When the same X window is used for several Gtk+ widgets, we cannot
3587 say for sure based on the X window alone if an event is for the
3588 frame. This function does additional checks.
3590 Return non-zero if the event is for a scroll bar, zero otherwise. */
3593 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3597 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3599 /* Check if press occurred outside the edit widget. */
3600 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3601 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3602 != gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3605 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3606 || event
->type
== MotionNotify
))
3608 /* If we are releasing or moving the scroll bar, it has the grab. */
3609 GtkWidget
*w
= gtk_grab_get_current ();
3610 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3618 /***********************************************************************
3620 ***********************************************************************/
3621 /* The key for the data we put in the GtkImage widgets. The data is
3622 the image used by Emacs. We use this to see if we need to update
3623 the GtkImage with a new image. */
3624 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3626 /* The key for storing the latest modifiers so the activate callback can
3628 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3630 /* The key for storing the button widget in its proxy menu item. */
3631 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3633 /* The key for the data we put in the GtkImage widgets. The data is
3634 the stock name used by Emacs. We use this to see if we need to update
3635 the GtkImage with a new image. */
3636 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3638 /* As above, but this is used for named theme widgets, as opposed to
3640 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3642 /* Callback function invoked when a tool bar item is pressed.
3643 W is the button widget in the tool bar that got pressed,
3644 CLIENT_DATA is an integer that is the index of the button in the
3645 tool bar. 0 is the first button. */
3648 xg_tool_bar_button_cb (GtkWidget
*widget
,
3649 GdkEventButton
*event
,
3652 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3653 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3654 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3659 /* Callback function invoked when a tool bar item is pressed.
3660 W is the button widget in the tool bar that got pressed,
3661 CLIENT_DATA is an integer that is the index of the button in the
3662 tool bar. 0 is the first button. */
3665 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3667 /* The EMACS_INT cast avoids a warning. */
3668 int idx
= (int) (EMACS_INT
) client_data
;
3669 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3670 XG_TOOL_BAR_LAST_MODIFIER
);
3672 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3673 Lisp_Object key
, frame
;
3674 struct input_event event
;
3677 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3680 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3682 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3683 XSETFRAME (frame
, f
);
3685 /* We generate two events here. The first one is to set the prefix
3686 to `(tool_bar)', see keyboard.c. */
3687 event
.kind
= TOOL_BAR_EVENT
;
3688 event
.frame_or_window
= frame
;
3690 kbd_buffer_store_event (&event
);
3692 event
.kind
= TOOL_BAR_EVENT
;
3693 event
.frame_or_window
= frame
;
3695 /* Convert between the modifier bits GDK uses and the modifier bits
3696 Emacs uses. This assumes GDK and X masks are the same, which they are when
3698 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3699 kbd_buffer_store_event (&event
);
3701 /* Return focus to the frame after we have clicked on a detached
3703 Fx_focus_frame (frame
);
3706 /* Callback function invoked when a tool bar item is pressed in a detached
3707 tool bar or the overflow drop down menu.
3708 We just call xg_tool_bar_callback.
3709 W is the menu item widget that got pressed,
3710 CLIENT_DATA is an integer that is the index of the button in the
3711 tool bar. 0 is the first button. */
3714 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3716 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3717 XG_TOOL_BAR_PROXY_BUTTON
));
3718 xg_tool_bar_callback (wbutton
, client_data
);
3723 xg_tool_bar_help_callback (GtkWidget
*w
,
3724 GdkEventCrossing
*event
,
3725 gpointer client_data
);
3727 /* This callback is called when a help is to be shown for an item in
3728 the detached tool bar when the detached tool bar it is not expanded. */
3731 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3732 GdkEventCrossing
*event
,
3733 gpointer client_data
)
3735 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3736 XG_TOOL_BAR_PROXY_BUTTON
));
3738 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3742 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3744 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3745 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3746 GtkWidget
*c2
= clist
->next
? (GtkWidget
*) clist
->next
->data
: NULL
;
3748 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3749 g_list_free (clist
);
3750 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3754 /* This callback is called when a tool item should create a proxy item,
3755 such as for the overflow menu. Also called when the tool bar is detached.
3756 If we don't create a proxy menu item, the detached tool bar will be
3760 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3762 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
3763 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
3765 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3766 GtkImage
*wimage
= GTK_IMAGE (c1
);
3767 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3768 (wlbl
? gtk_label_get_text (wlbl
) : "");
3769 GtkWidget
*wmenuimage
;
3772 if (gtk_button_get_use_stock (wbutton
))
3773 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3774 GTK_ICON_SIZE_MENU
);
3777 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3778 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3780 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
3782 if (store_type
== GTK_IMAGE_STOCK
)
3785 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3786 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3788 else if (store_type
== GTK_IMAGE_ICON_SET
)
3790 GtkIconSet
*icon_set
;
3791 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3792 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3793 GTK_ICON_SIZE_MENU
);
3795 else if (store_type
== GTK_IMAGE_PIXBUF
)
3800 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3803 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3805 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3806 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3807 GDK_INTERP_BILINEAR
);
3809 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3813 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3817 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3819 const gchar
*icon_name
;
3820 GtkIconSize icon_size
;
3822 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3823 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3824 GTK_ICON_SIZE_MENU
);
3828 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3833 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3835 g_signal_connect (G_OBJECT (wmenuitem
),
3837 G_CALLBACK (xg_tool_bar_proxy_callback
),
3841 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3842 (gpointer
) wbutton
);
3843 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3844 gtk_widget_set_sensitive (wmenuitem
,
3845 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
3847 /* Use enter/leave notify to show help. We use the events
3848 rather than the GtkButton specific signals "enter" and
3849 "leave", so we can have only one callback. The event
3850 will tell us what kind of event it is. */
3851 g_signal_connect (G_OBJECT (wmenuitem
),
3852 "enter-notify-event",
3853 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3855 g_signal_connect (G_OBJECT (wmenuitem
),
3856 "leave-notify-event",
3857 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3863 /* This callback is called when a tool bar is detached. We must set
3864 the height of the tool bar to zero when this happens so frame sizes
3865 are correctly calculated.
3866 WBOX is the handle box widget that enables detach/attach of the tool bar.
3867 W is the tool bar widget.
3868 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3871 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
3873 gpointer client_data
)
3875 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3877 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3882 GtkRequisition req
, req2
;
3883 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3884 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
3885 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
3886 req
.width
-= req2
.width
;
3887 req
.height
-= req2
.height
;
3888 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
3889 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
3890 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
3891 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
3892 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
3893 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
3894 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
3895 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
3896 xg_height_or_width_changed (f
);
3900 /* This callback is called when a tool bar is reattached. We must set
3901 the height of the tool bar when this happens so frame sizes
3902 are correctly calculated.
3903 WBOX is the handle box widget that enables detach/attach of the tool bar.
3904 W is the tool bar widget.
3905 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3908 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
3910 gpointer client_data
)
3912 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3913 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3917 GtkRequisition req
, req2
;
3918 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3919 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
3920 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
3921 req
.width
+= req2
.width
;
3922 req
.height
+= req2
.height
;
3923 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
3924 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
3925 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
3926 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
3927 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
3928 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
3929 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
3930 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
3931 xg_height_or_width_changed (f
);
3935 /* This callback is called when the mouse enters or leaves a tool bar item.
3936 It is used for displaying and hiding the help text.
3937 W is the tool bar item, a button.
3938 EVENT is either an enter event or leave event.
3939 CLIENT_DATA is an integer that is the index of the button in the
3940 tool bar. 0 is the first button.
3942 Returns FALSE to tell GTK to keep processing this event. */
3945 xg_tool_bar_help_callback (GtkWidget
*w
,
3946 GdkEventCrossing
*event
,
3947 gpointer client_data
)
3949 /* The EMACS_INT cast avoids a warning. */
3950 int idx
= (int) (EMACS_INT
) client_data
;
3951 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3952 Lisp_Object help
, frame
;
3954 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3957 if (event
->type
== GDK_ENTER_NOTIFY
)
3959 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3960 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3963 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3968 XSETFRAME (frame
, f
);
3969 kbd_buffer_store_help_event (frame
, help
);
3975 /* This callback is called when a tool bar item shall be redrawn.
3976 It modifies the expose event so that the GtkImage widget redraws the
3977 whole image. This to overcome a bug that makes GtkImage draw the image
3978 in the wrong place when it tries to redraw just a part of the image.
3979 W is the GtkImage to be redrawn.
3980 EVENT is the expose event for W.
3981 CLIENT_DATA is unused.
3983 Returns FALSE to tell GTK to keep processing this event. */
3987 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
3988 GdkEventExpose
*event
,
3989 gpointer client_data
)
3993 gdk_drawable_get_size (event
->window
, &width
, &height
);
3994 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3995 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3997 event
->area
.x
= max (0, event
->area
.x
);
3998 event
->area
.y
= max (0, event
->area
.y
);
4000 event
->area
.width
= max (width
, event
->area
.width
);
4001 event
->area
.height
= max (height
, event
->area
.height
);
4007 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4008 #define toolbar_set_orientation(w, o) \
4009 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4011 #define toolbar_set_orientation(w, o) \
4012 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4015 /* Attach a tool bar to frame F. */
4018 xg_pack_tool_bar (FRAME_PTR f
, Lisp_Object pos
)
4020 struct x_output
*x
= f
->output_data
.x
;
4021 int into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4023 toolbar_set_orientation (x
->toolbar_widget
,
4025 ? GTK_ORIENTATION_VERTICAL
4026 : GTK_ORIENTATION_HORIZONTAL
);
4027 if (!x
->handlebox_widget
)
4029 x
->handlebox_widget
= gtk_handle_box_new ();
4030 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4031 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4032 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4033 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4034 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4040 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4042 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), x
->handlebox_widget
,
4045 if (EQ (pos
, Qleft
))
4046 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4047 x
->handlebox_widget
,
4049 x
->toolbar_in_hbox
= 1;
4053 int vbox_pos
= x
->menubar_widget
? 1 : 0;
4054 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4056 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
4060 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4061 x
->handlebox_widget
,
4063 x
->toolbar_in_hbox
= 0;
4067 /* Create a tool bar for frame F. */
4070 xg_create_tool_bar (FRAME_PTR f
)
4072 struct x_output
*x
= f
->output_data
.x
;
4074 x
->toolbar_widget
= gtk_toolbar_new ();
4075 x
->toolbar_detached
= 0;
4077 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4079 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4080 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4084 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4086 /* Find the right-to-left image named by RTL in the tool bar images for F.
4087 Returns IMAGE if RTL is not found. */
4090 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
4093 Lisp_Object file
, rtl_name
;
4094 struct gcpro gcpro1
, gcpro2
;
4095 GCPRO2 (file
, rtl_name
);
4097 rtl_name
= Ffile_name_nondirectory (rtl
);
4099 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4101 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4102 if (!NILP (file
= file_for_image (rtl_image
)))
4104 file
= call1 (intern ("file-name-sans-extension"),
4105 Ffile_name_nondirectory (file
));
4106 if (EQ (Fequal (file
, rtl_name
), Qt
))
4117 static GtkToolItem
*
4118 xg_make_tool_item (FRAME_PTR f
,
4120 GtkWidget
**wbutton
,
4122 int i
, int horiz
, int text_image
)
4124 GtkToolItem
*ti
= gtk_tool_item_new ();
4125 GtkWidget
*vb
= horiz
? gtk_hbox_new (FALSE
, 0) : gtk_vbox_new (FALSE
, 0);
4126 GtkWidget
*wb
= gtk_button_new ();
4127 GtkWidget
*weventbox
= gtk_event_box_new ();
4129 if (wimage
&& !text_image
)
4130 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4132 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4133 if (wimage
&& text_image
)
4134 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4136 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4137 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4138 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4139 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4140 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4144 /* The EMACS_INT cast avoids a warning. */
4145 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4146 G_CALLBACK (xg_tool_bar_menu_proxy
),
4147 (gpointer
) (EMACS_INT
) i
);
4149 g_signal_connect (G_OBJECT (wb
), "clicked",
4150 G_CALLBACK (xg_tool_bar_callback
),
4151 (gpointer
) (EMACS_INT
) i
);
4153 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4156 /* Catch expose events to overcome an annoying redraw bug, see
4157 comment for xg_tool_bar_item_expose_callback. */
4158 g_signal_connect (G_OBJECT (ti
),
4160 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4163 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4165 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
4166 no distinction based on modifiers in the activate callback,
4167 so we have to do it ourselves. */
4168 g_signal_connect (wb
, "button-release-event",
4169 G_CALLBACK (xg_tool_bar_button_cb
),
4172 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4174 /* Use enter/leave notify to show help. We use the events
4175 rather than the GtkButton specific signals "enter" and
4176 "leave", so we can have only one callback. The event
4177 will tell us what kind of event it is. */
4178 /* The EMACS_INT cast avoids a warning. */
4179 g_signal_connect (G_OBJECT (weventbox
),
4180 "enter-notify-event",
4181 G_CALLBACK (xg_tool_bar_help_callback
),
4182 (gpointer
) (EMACS_INT
) i
);
4183 g_signal_connect (G_OBJECT (weventbox
),
4184 "leave-notify-event",
4185 G_CALLBACK (xg_tool_bar_help_callback
),
4186 (gpointer
) (EMACS_INT
) i
);
4189 if (wbutton
) *wbutton
= wb
;
4195 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4196 const char *icon_name
, const struct image
*img
,
4197 const char *label
, int horiz
)
4201 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4202 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4204 /* Check if the tool icon matches. */
4207 old
= g_object_get_data (G_OBJECT (wimage
),
4208 XG_TOOL_BAR_STOCK_NAME
);
4209 if (!old
|| strcmp (old
, stock_name
))
4214 old
= g_object_get_data (G_OBJECT (wimage
),
4215 XG_TOOL_BAR_ICON_NAME
);
4216 if (!old
|| strcmp (old
, icon_name
))
4222 = (Pixmap
) g_object_get_data (G_OBJECT (wimage
),
4223 XG_TOOL_BAR_IMAGE_DATA
);
4224 if (old_img
!= img
->pixmap
)
4228 /* Check button configuration and label. */
4229 if ((horiz
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
))
4230 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4233 /* Ensure label is correct. */
4235 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4240 xg_update_tool_bar_sizes (FRAME_PTR f
)
4242 struct x_output
*x
= f
->output_data
.x
;
4244 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4246 gtk_widget_get_preferred_size (GTK_WIDGET (x
->handlebox_widget
), NULL
, &req
);
4247 if (x
->toolbar_in_hbox
)
4250 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4251 x
->handlebox_widget
,
4252 "position", &pos
, NULL
);
4253 if (pos
== 0) nl
= req
.width
;
4254 else nr
= req
.width
;
4259 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4260 x
->handlebox_widget
,
4261 "position", &pos
, NULL
);
4262 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4263 else nb
= req
.height
;
4266 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4267 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4268 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4269 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4271 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4272 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4273 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4274 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4275 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4276 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4284 /* Update the tool bar for frame F. Add new buttons and remove old. */
4287 update_frame_tool_bar (FRAME_PTR f
)
4290 struct x_output
*x
= f
->output_data
.x
;
4291 int hmargin
= 0, vmargin
= 0;
4292 GtkToolbar
*wtoolbar
;
4294 GtkTextDirection dir
;
4295 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
4297 int text_image
, horiz
;
4299 if (! FRAME_GTK_WIDGET (f
))
4304 if (INTEGERP (Vtool_bar_button_margin
)
4305 && XINT (Vtool_bar_button_margin
) > 0)
4307 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4308 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4310 else if (CONSP (Vtool_bar_button_margin
))
4312 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
4313 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
4314 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4316 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
4317 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
4318 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4321 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4322 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4323 i.e. zero. This means that margins less than
4324 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4325 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4326 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4328 if (! x
->toolbar_widget
)
4329 xg_create_tool_bar (f
);
4331 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4332 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4334 style
= Ftool_bar_get_system_style ();
4335 text_image
= EQ (style
, Qtext_image_horiz
);
4336 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4338 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4340 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4341 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4345 struct image
*img
= NULL
;
4347 Lisp_Object stock
= Qnil
;
4348 GtkStockItem stock_item
;
4349 char *stock_name
= NULL
;
4350 char *icon_name
= NULL
;
4352 GtkWidget
*wbutton
= NULL
;
4353 Lisp_Object specified_file
;
4354 int vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4356 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4357 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4358 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4361 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4363 /* If this is a separator, use a gtk separator item. */
4364 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4366 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4369 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4371 ti
= gtk_separator_tool_item_new ();
4372 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4378 /* Otherwise, the tool-bar item is an ordinary button. */
4380 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4382 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4386 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4388 /* Ignore invalid image specifications. */
4389 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4390 if (!valid_image_p (image
))
4393 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4398 specified_file
= file_for_image (image
);
4399 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4400 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4402 if (STRINGP (stock
))
4404 stock_name
= SSDATA (stock
);
4405 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4407 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4408 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4410 icon_name
= stock_name
+ 2;
4414 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4417 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4419 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4420 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4428 if (stock_name
== NULL
&& icon_name
== NULL
)
4430 /* No stock image, or stock item not known. Try regular
4431 image. If image is a vector, choose it according to the
4433 if (dir
== GTK_TEXT_DIR_RTL
4434 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4436 image
= find_rtl_image (f
, image
, rtl
);
4438 if (VECTORP (image
))
4442 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4443 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4446 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4447 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4449 xassert (ASIZE (image
) >= idx
);
4450 image
= AREF (image
, idx
);
4455 img_id
= lookup_image (f
, image
);
4456 img
= IMAGE_FROM_ID (f
, img_id
);
4457 prepare_image_for_display (f
, img
);
4459 if (img
->load_failed_p
|| img
->pixmap
== None
)
4462 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4468 /* If there is an existing widget, check if it's stale; if so,
4469 remove it and make a new tool item from scratch. */
4470 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4473 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4482 /* Save the image so we can see if an update is needed the
4483 next time we call xg_tool_item_match_p. */
4484 if (EQ (style
, Qtext
))
4486 else if (stock_name
)
4488 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4489 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4490 (gpointer
) xstrdup (stock_name
),
4491 (GDestroyNotify
) xfree
);
4495 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4496 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4497 (gpointer
) xstrdup (icon_name
),
4498 (GDestroyNotify
) xfree
);
4502 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4503 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4504 (gpointer
)img
->pixmap
);
4507 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4508 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4509 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4514 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4518 /* Remove buttons not longer needed. */
4521 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4523 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4524 } while (ti
!= NULL
);
4526 if (f
->n_tool_bar_items
!= 0)
4529 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4530 gtk_widget_show_all (GTK_WIDGET (x
->handlebox_widget
));
4531 if (xg_update_tool_bar_sizes (f
))
4532 xg_height_or_width_changed (f
);
4538 /* Deallocate all resources for the tool bar on frame F.
4539 Remove the tool bar. */
4542 free_frame_tool_bar (FRAME_PTR f
)
4544 struct x_output
*x
= f
->output_data
.x
;
4546 if (x
->toolbar_widget
)
4548 int is_packed
= x
->handlebox_widget
!= 0;
4550 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4551 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4554 if (x
->toolbar_in_hbox
)
4555 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4556 x
->handlebox_widget
);
4558 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4559 x
->handlebox_widget
);
4562 gtk_widget_destroy (x
->toolbar_widget
);
4564 x
->toolbar_widget
= 0;
4565 x
->handlebox_widget
= 0;
4566 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4567 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4569 xg_height_or_width_changed (f
);
4576 xg_change_toolbar_position (FRAME_PTR f
, Lisp_Object pos
)
4578 struct x_output
*x
= f
->output_data
.x
;
4580 if (! x
->toolbar_widget
|| ! x
->handlebox_widget
)
4584 g_object_ref (x
->handlebox_widget
);
4585 if (x
->toolbar_in_hbox
)
4586 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4587 x
->handlebox_widget
);
4589 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4590 x
->handlebox_widget
);
4591 xg_pack_tool_bar (f
, pos
);
4592 g_object_unref (x
->handlebox_widget
);
4593 if (xg_update_tool_bar_sizes (f
))
4594 xg_height_or_width_changed (f
);
4602 /***********************************************************************
4604 ***********************************************************************/
4606 xg_initialize (void)
4608 GtkBindingSet
*binding_set
;
4611 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4612 we keep it permanently linked in. */
4617 xg_ignore_gtk_scrollbar
= 0;
4618 xg_detached_menus
= 0;
4619 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4620 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4622 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4623 id_to_widget
.widgets
= 0;
4625 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4626 bindings. It doesn't seem to be any way to remove properties,
4627 so we set it to VoidSymbol which in X means "no key". */
4628 gtk_settings_set_string_property (gtk_settings_get_default (),
4629 "gtk-menu-bar-accel",
4633 /* Make GTK text input widgets use Emacs style keybindings. This is
4635 gtk_settings_set_string_property (gtk_settings_get_default (),
4636 "gtk-key-theme-name",
4640 /* Make dialogs close on C-g. Since file dialog inherits from
4641 dialog, this works for them also. */
4642 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4643 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4646 /* Make menus close on C-g. */
4647 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4648 (GTK_TYPE_MENU_SHELL
));
4649 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4653 #endif /* USE_GTK */