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 (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 struct x_output
*x
= f
->output_data
.x
;
1192 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1193 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1194 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1195 #ifdef USE_GTK_TOOLTIP
1197 gtk_widget_destroy (x
->ttip_lbl
);
1199 g_object_unref (G_OBJECT (x
->ttip_widget
));
1204 /* Set the normal size hints for the window manager, for frame F.
1205 FLAGS is the flags word to use--or 0 meaning preserve the flags
1206 that the window now has.
1207 If USER_POSITION is nonzero, we set the User Position
1208 flag (this is useful when FLAGS is 0). */
1211 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
1213 /* Must use GTK routines here, otherwise GTK resets the size hints
1214 to its own defaults. */
1215 GdkGeometry size_hints
;
1216 gint hint_flags
= 0;
1217 int base_width
, base_height
;
1218 int min_rows
= 0, min_cols
= 0;
1219 int win_gravity
= f
->win_gravity
;
1221 /* Don't set size hints during initialization; that apparently leads
1222 to a race condition. See the thread at
1223 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1224 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1229 memset (&size_hints
, 0, sizeof (size_hints
));
1230 f
->output_data
.x
->size_hints
= size_hints
;
1231 f
->output_data
.x
->hint_flags
= hint_flags
;
1234 flags
= f
->size_hint_flags
;
1236 size_hints
= f
->output_data
.x
->size_hints
;
1237 hint_flags
= f
->output_data
.x
->hint_flags
;
1239 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1240 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1241 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1243 hint_flags
|= GDK_HINT_BASE_SIZE
;
1244 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0) + FRAME_TOOLBAR_WIDTH (f
);
1245 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
1246 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1248 check_frame_size (f
, &min_rows
, &min_cols
);
1250 size_hints
.base_width
= base_width
;
1251 size_hints
.base_height
= base_height
;
1252 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1253 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1255 /* These currently have a one to one mapping with the X values, but I
1256 don't think we should rely on that. */
1257 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1258 size_hints
.win_gravity
= 0;
1259 if (win_gravity
== NorthWestGravity
)
1260 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1261 else if (win_gravity
== NorthGravity
)
1262 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1263 else if (win_gravity
== NorthEastGravity
)
1264 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1265 else if (win_gravity
== WestGravity
)
1266 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1267 else if (win_gravity
== CenterGravity
)
1268 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1269 else if (win_gravity
== EastGravity
)
1270 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1271 else if (win_gravity
== SouthWestGravity
)
1272 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1273 else if (win_gravity
== SouthGravity
)
1274 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1275 else if (win_gravity
== SouthEastGravity
)
1276 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1277 else if (win_gravity
== StaticGravity
)
1278 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1282 hint_flags
&= ~GDK_HINT_POS
;
1283 hint_flags
|= GDK_HINT_USER_POS
;
1286 if (hint_flags
!= f
->output_data
.x
->hint_flags
1287 || memcmp (&size_hints
,
1288 &f
->output_data
.x
->size_hints
,
1289 sizeof (size_hints
)) != 0)
1292 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1293 NULL
, &size_hints
, hint_flags
);
1294 f
->output_data
.x
->size_hints
= size_hints
;
1295 f
->output_data
.x
->hint_flags
= hint_flags
;
1300 /* Change background color of a frame.
1301 Since GTK uses the background color to clear the window, we must
1302 keep the GTK and X colors in sync.
1303 F is the frame to change,
1304 BG is the pixel value to change to. */
1307 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
1309 if (FRAME_GTK_WIDGET (f
))
1312 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1318 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1319 functions so GTK does not overwrite the icon. */
1322 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1324 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1328 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1333 /***********************************************************************
1335 ***********************************************************************/
1336 /* Return the dialog title to use for a dialog of type KEY.
1337 This is the encoding used by lwlib. We use the same for GTK. */
1340 get_dialog_title (char key
)
1342 const char *title
= "";
1350 title
= "Information";
1369 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1370 the dialog, but return TRUE so the event does not propagate further
1371 in GTK. This prevents GTK from destroying the dialog widget automatically
1372 and we can always destrou the widget manually, regardles of how
1373 it was popped down (button press or WM_DELETE_WINDOW).
1374 W is the dialog widget.
1375 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1376 user_data is NULL (not used).
1378 Returns TRUE to end propagation of event. */
1381 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1383 gtk_widget_unmap (w
);
1387 /* Create a popup dialog window. See also xg_create_widget below.
1388 WV is a widget_value describing the dialog.
1389 SELECT_CB is the callback to use when a button has been pressed.
1390 DEACTIVATE_CB is the callback to use when the dialog pops down.
1392 Returns the GTK dialog widget. */
1395 create_dialog (widget_value
*wv
,
1396 GCallback select_cb
,
1397 GCallback deactivate_cb
)
1399 const char *title
= get_dialog_title (wv
->name
[0]);
1400 int total_buttons
= wv
->name
[1] - '0';
1401 int right_buttons
= wv
->name
[4] - '0';
1404 int button_spacing
= 10;
1405 GtkWidget
*wdialog
= gtk_dialog_new ();
1406 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1407 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1410 GtkWidget
*whbox_up
;
1411 GtkWidget
*whbox_down
;
1413 /* If the number of buttons is greater than 4, make two rows of buttons
1414 instead. This looks better. */
1415 int make_two_rows
= total_buttons
> 4;
1417 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1418 left_buttons
= total_buttons
- right_buttons
;
1420 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1421 gtk_widget_set_name (wdialog
, "emacs-dialog");
1426 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1427 whbox_up
= gtk_hbox_new (FALSE
, 0);
1428 whbox_down
= gtk_hbox_new (FALSE
, 0);
1430 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1431 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1432 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1434 cur_box
= GTK_BOX (whbox_up
);
1437 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1438 G_CALLBACK (dialog_delete_callback
), 0);
1442 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1443 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1446 for (item
= wv
->contents
; item
; item
= item
->next
)
1448 char *utf8_label
= get_utf8_string (item
->value
);
1452 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1454 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1455 /* This is the text part of the dialog. */
1456 w
= gtk_label_new (utf8_label
);
1457 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1458 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1459 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1461 /* Try to make dialog look better. Must realize first so
1462 the widget can calculate the size it needs. */
1463 gtk_widget_realize (w
);
1464 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1465 gtk_box_set_spacing (wvbox
, req
.height
);
1466 if (item
->value
&& strlen (item
->value
) > 0)
1467 button_spacing
= 2*req
.width
/strlen (item
->value
);
1471 /* This is one button to add to the dialog. */
1472 w
= gtk_button_new_with_label (utf8_label
);
1473 if (! item
->enabled
)
1474 gtk_widget_set_sensitive (w
, FALSE
);
1476 g_signal_connect (G_OBJECT (w
), "clicked",
1477 select_cb
, item
->call_data
);
1479 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1480 if (++button_nr
== left_buttons
)
1483 cur_box
= GTK_BOX (whbox_down
);
1485 gtk_box_pack_start (cur_box
,
1493 g_free (utf8_label
);
1499 struct xg_dialog_data
1507 /* Function that is called when the file or font dialogs pop down.
1508 W is the dialog widget, RESPONSE is the response code.
1509 USER_DATA is what we passed in to g_signal_connect. */
1512 xg_dialog_response_cb (GtkDialog
*w
,
1516 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1517 dd
->response
= response
;
1518 g_main_loop_quit (dd
->loop
);
1522 /* Destroy the dialog. This makes it pop down. */
1525 pop_down_dialog (Lisp_Object arg
)
1527 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1528 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1531 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1532 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1534 g_main_loop_quit (dd
->loop
);
1535 g_main_loop_unref (dd
->loop
);
1542 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1543 We pass in DATA as gpointer* so we can use this as a callback. */
1546 xg_maybe_add_timer (gpointer data
)
1548 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1549 EMACS_TIME next_time
= timer_check (1);
1550 long secs
= EMACS_SECS (next_time
);
1551 long usecs
= EMACS_USECS (next_time
);
1555 if (secs
>= 0 && usecs
>= 0 && secs
< ((guint
)-1)/1000)
1557 dd
->timerid
= g_timeout_add (secs
* 1000 + usecs
/1000,
1565 /* Pops up a modal dialog W and waits for response.
1566 We don't use gtk_dialog_run because we want to process emacs timers.
1567 The dialog W is not destroyed when this function returns. */
1570 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1572 int count
= SPECPDL_INDEX ();
1573 struct xg_dialog_data dd
;
1575 xg_set_screen (w
, f
);
1576 gtk_window_set_transient_for (GTK_WINDOW (w
),
1577 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1578 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1579 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1581 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1582 dd
.response
= GTK_RESPONSE_CANCEL
;
1586 g_signal_connect (G_OBJECT (w
),
1588 G_CALLBACK (xg_dialog_response_cb
),
1590 /* Don't destroy the widget if closed by the window manager close button. */
1591 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1592 gtk_widget_show (w
);
1594 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1596 (void) xg_maybe_add_timer (&dd
);
1597 g_main_loop_run (dd
.loop
);
1600 unbind_to (count
, Qnil
);
1606 /***********************************************************************
1607 File dialog functions
1608 ***********************************************************************/
1609 /* Return non-zero if the old file selection dialog is being used.
1610 Return zero if not. */
1613 xg_uses_old_file_dialog (void)
1615 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1616 return x_gtk_use_old_file_dialog
;
1623 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1625 /* Return the selected file for file chooser dialog W.
1626 The returned string must be free:d. */
1629 xg_get_file_name_from_chooser (GtkWidget
*w
)
1631 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1634 /* Callback called when the "Show hidden files" toggle is pressed.
1635 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1638 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1640 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1642 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1643 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1647 /* Callback called when a property changes in a file chooser.
1648 GOBJECT is the file chooser dialog, ARG1 describes the property.
1649 USER_DATA is the toggle widget in the file chooser dialog.
1650 We use this to update the "Show hidden files" toggle when the user
1651 changes that property by right clicking in the file list. */
1654 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1656 if (strcmp (arg1
->name
, "show-hidden") == 0)
1658 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1659 gboolean visible
, toggle_on
;
1661 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1662 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1664 if (!!visible
!= !!toggle_on
)
1666 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1667 G_CALLBACK (xg_toggle_visibility_cb
),
1669 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1670 g_signal_handlers_unblock_by_func
1671 (G_OBJECT (wtoggle
),
1672 G_CALLBACK (xg_toggle_visibility_cb
),
1675 x_gtk_show_hidden_files
= visible
;
1679 /* Read a file name from the user using a file chooser dialog.
1680 F is the current frame.
1681 PROMPT is a prompt to show to the user. May not be NULL.
1682 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1683 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1684 file. *FUNC is set to a function that can be used to retrieve the
1685 selected file name from the returned widget.
1687 Returns the created widget. */
1690 xg_get_file_with_chooser (FRAME_PTR f
,
1692 char *default_filename
,
1693 int mustmatch_p
, int only_dir_p
,
1694 xg_get_file_func
*func
)
1698 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1699 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1700 GtkFileChooserAction action
= (mustmatch_p
?
1701 GTK_FILE_CHOOSER_ACTION_OPEN
:
1702 GTK_FILE_CHOOSER_ACTION_SAVE
);
1705 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1707 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1708 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1709 (mustmatch_p
|| only_dir_p
?
1710 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1713 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1715 wbox
= gtk_vbox_new (FALSE
, 0);
1716 gtk_widget_show (wbox
);
1717 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1719 if (x_gtk_show_hidden_files
)
1721 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1722 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1724 gtk_widget_show (wtoggle
);
1725 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1726 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1727 g_signal_connect (G_OBJECT (filewin
), "notify",
1728 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1730 if (x_gtk_file_dialog_help_text
)
1733 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1734 Show the C-l help text only for versions < 2.10. */
1735 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1736 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1737 strcat (message
, "\nIf you don't like this file selector, use the "
1738 "corresponding\nkey binding or customize "
1739 "use-file-dialog to turn it off.");
1741 wmessage
= gtk_label_new (message
);
1742 gtk_widget_show (wmessage
);
1745 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1746 if (x_gtk_file_dialog_help_text
)
1747 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1748 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1750 if (default_filename
)
1753 struct gcpro gcpro1
;
1754 char *utf8_filename
;
1757 file
= build_string (default_filename
);
1759 /* File chooser does not understand ~/... in the file name. It must be
1760 an absolute name starting with /. */
1761 if (default_filename
[0] != '/')
1762 file
= Fexpand_file_name (file
, Qnil
);
1764 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1765 if (! NILP (Ffile_directory_p (file
)))
1766 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1770 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1772 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1774 char *cp
= strrchr (utf8_filename
, '/');
1776 else cp
= utf8_filename
;
1777 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1784 *func
= xg_get_file_name_from_chooser
;
1788 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1790 /* Return the selected file for file selector dialog W.
1791 The returned string must be free:d. */
1794 xg_get_file_name_from_selector (GtkWidget
*w
)
1796 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1797 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1800 /* Create a file selection dialog.
1801 F is the current frame.
1802 PROMPT is a prompt to show to the user. May not be NULL.
1803 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1804 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1805 file. *FUNC is set to a function that can be used to retrieve the
1806 selected file name from the returned widget.
1808 Returns the created widget. */
1811 xg_get_file_with_selection (FRAME_PTR f
,
1813 char *default_filename
,
1814 int mustmatch_p
, int only_dir_p
,
1815 xg_get_file_func
*func
)
1818 GtkFileSelection
*filesel
;
1820 filewin
= gtk_file_selection_new (prompt
);
1821 filesel
= GTK_FILE_SELECTION (filewin
);
1823 if (default_filename
)
1824 gtk_file_selection_set_filename (filesel
, default_filename
);
1828 /* The selection_entry part of filesel is not documented. */
1829 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1830 gtk_file_selection_hide_fileop_buttons (filesel
);
1833 *func
= xg_get_file_name_from_selector
;
1837 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1839 /* Read a file name from the user using a file dialog, either the old
1840 file selection dialog, or the new file chooser dialog. Which to use
1841 depends on what the GTK version used has, and what the value of
1842 gtk-use-old-file-dialog.
1843 F is the current frame.
1844 PROMPT is a prompt to show to the user. May not be NULL.
1845 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1846 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1849 Returns a file name or NULL if no file was selected.
1850 The returned string must be freed by the caller. */
1853 xg_get_file_name (FRAME_PTR f
,
1855 char *default_filename
,
1861 int filesel_done
= 0;
1862 xg_get_file_func func
;
1864 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1865 /* I really don't know why this is needed, but without this the GLIBC add on
1866 library linuxthreads hangs when the Gnome file chooser backend creates
1868 sigblock (sigmask (__SIGRTMIN
));
1869 #endif /* HAVE_GTK_AND_PTHREAD */
1871 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1873 if (xg_uses_old_file_dialog ())
1874 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1875 mustmatch_p
, only_dir_p
, &func
);
1877 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1878 mustmatch_p
, only_dir_p
, &func
);
1880 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1881 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1882 mustmatch_p
, only_dir_p
, &func
);
1883 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1885 gtk_widget_set_name (w
, "emacs-filedialog");
1887 filesel_done
= xg_dialog_run (f
, w
);
1889 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1890 sigunblock (sigmask (__SIGRTMIN
));
1893 if (filesel_done
== GTK_RESPONSE_OK
)
1896 gtk_widget_destroy (w
);
1900 #ifdef HAVE_FREETYPE
1901 /* Pop up a GTK font selector and return the name of the font the user
1902 selects, as a C string. The returned font name follows GTK's own
1905 `FAMILY [VALUE1 VALUE2] SIZE'
1907 This can be parsed using font_parse_fcname in font.c.
1908 DEFAULT_NAME, if non-zero, is the default font name. */
1911 xg_get_font_name (FRAME_PTR f
, const char *default_name
)
1914 char *fontname
= NULL
;
1917 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1918 sigblock (sigmask (__SIGRTMIN
));
1919 #endif /* HAVE_GTK_AND_PTHREAD */
1921 w
= gtk_font_selection_dialog_new ("Pick a font");
1923 default_name
= "Monospace 10";
1924 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1927 gtk_widget_set_name (w
, "emacs-fontdialog");
1929 done
= xg_dialog_run (f
, w
);
1931 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1932 sigunblock (sigmask (__SIGRTMIN
));
1935 if (done
== GTK_RESPONSE_OK
)
1936 fontname
= gtk_font_selection_dialog_get_font_name
1937 (GTK_FONT_SELECTION_DIALOG (w
));
1939 gtk_widget_destroy (w
);
1942 #endif /* HAVE_FREETYPE */
1946 /***********************************************************************
1948 ***********************************************************************/
1950 /* The name of menu items that can be used for customization. Since GTK
1951 RC files are very crude and primitive, we have to set this on all
1952 menu item names so a user can easily customize menu items. */
1954 #define MENU_ITEM_NAME "emacs-menuitem"
1957 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1958 during GC. The next member points to the items. */
1959 static xg_list_node xg_menu_cb_list
;
1961 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1962 during GC. The next member points to the items. */
1963 static xg_list_node xg_menu_item_cb_list
;
1965 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1966 F is the frame CL_DATA will be initialized for.
1967 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1969 The menu bar and all sub menus under the menu bar in a frame
1970 share the same structure, hence the reference count.
1972 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1973 allocated xg_menu_cb_data if CL_DATA is NULL. */
1975 static xg_menu_cb_data
*
1976 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
1980 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1982 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1983 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1984 cl_data
->highlight_cb
= highlight_cb
;
1985 cl_data
->ref_count
= 0;
1987 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1990 cl_data
->ref_count
++;
1995 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1996 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1998 When the menu bar is updated, menu items may have been added and/or
1999 removed, so menu_bar_vector and menu_bar_items_used change. We must
2000 then update CL_DATA since it is used to determine which menu
2001 item that is invoked in the menu.
2002 HIGHLIGHT_CB could change, there is no check that the same
2003 function is given when modifying a menu bar as was given when
2004 creating the menu bar. */
2007 update_cl_data (xg_menu_cb_data
*cl_data
,
2009 GCallback highlight_cb
)
2014 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2015 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2016 cl_data
->highlight_cb
= highlight_cb
;
2020 /* Decrease reference count for CL_DATA.
2021 If reference count is zero, free CL_DATA. */
2024 unref_cl_data (xg_menu_cb_data
*cl_data
)
2026 if (cl_data
&& cl_data
->ref_count
> 0)
2028 cl_data
->ref_count
--;
2029 if (cl_data
->ref_count
== 0)
2031 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2037 /* Function that marks all lisp data during GC. */
2044 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2045 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2047 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2049 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2051 if (! NILP (cb_data
->help
))
2052 mark_object (cb_data
->help
);
2057 /* Callback called when a menu item is destroyed. Used to free data.
2058 W is the widget that is being destroyed (not used).
2059 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2062 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2066 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
2067 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2072 /* Callback called when the pointer enters/leaves a menu item.
2073 W is the parent of the menu item.
2074 EVENT is either an enter event or leave event.
2075 CLIENT_DATA is not used.
2077 Returns FALSE to tell GTK to keep processing this event. */
2080 menuitem_highlight_callback (GtkWidget
*w
,
2081 GdkEventCrossing
*event
,
2082 gpointer client_data
)
2085 GtkWidget
*subwidget
;
2086 xg_menu_item_cb_data
*data
;
2088 ev
.crossing
= *event
;
2089 subwidget
= gtk_get_event_widget (&ev
);
2090 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
2094 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2096 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2097 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2098 (*func
) (subwidget
, call_data
);
2105 /* Callback called when a menu is destroyed. Used to free data.
2106 W is the widget that is being destroyed (not used).
2107 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2110 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2112 unref_cl_data ((xg_menu_cb_data
*) client_data
);
2115 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2116 must be non-NULL) and can be inserted into a menu item.
2118 Returns the GtkHBox. */
2121 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2127 wbox
= gtk_hbox_new (FALSE
, 0);
2128 wlbl
= gtk_label_new (utf8_label
);
2129 wkey
= gtk_label_new (utf8_key
);
2131 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2132 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2134 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2135 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2137 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2138 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2139 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2144 /* Make and return a menu item widget with the key to the right.
2145 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2146 UTF8_KEY is the text representing the key binding.
2147 ITEM is the widget_value describing the menu item.
2149 GROUP is an in/out parameter. If the menu item to be created is not
2150 part of any radio menu group, *GROUP contains NULL on entry and exit.
2151 If the menu item to be created is part of a radio menu group, on entry
2152 *GROUP contains the group to use, or NULL if this is the first item
2153 in the group. On exit, *GROUP contains the radio item group.
2155 Unfortunately, keys don't line up as nicely as in Motif,
2156 but the MacOS X version doesn't either, so I guess that is OK. */
2159 make_menu_item (const char *utf8_label
,
2160 const char *utf8_key
,
2165 GtkWidget
*wtoadd
= 0;
2167 /* It has been observed that some menu items have a NULL name field.
2168 This will lead to this function being called with a NULL utf8_label.
2169 GTK crashes on that so we set a blank label. Why there is a NULL
2170 name remains to be investigated. */
2171 if (! utf8_label
) utf8_label
= " ";
2174 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2176 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2179 if (utf8_key
) w
= gtk_check_menu_item_new ();
2180 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2181 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2183 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2185 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2186 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2187 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2189 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2194 if (utf8_key
) w
= gtk_menu_item_new ();
2195 else w
= gtk_menu_item_new_with_label (utf8_label
);
2198 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2199 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2204 static int xg_detached_menus
;
2206 /* Returns non-zero if there are detached menus. */
2209 xg_have_tear_offs (void)
2211 return xg_detached_menus
> 0;
2214 /* Callback invoked when a detached menu window is removed. Here we
2215 decrease the xg_detached_menus count.
2216 WIDGET is the top level window that is removed (the parent of the menu).
2217 CLIENT_DATA is not used. */
2220 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2222 if (xg_detached_menus
> 0) --xg_detached_menus
;
2225 /* Callback invoked when a menu is detached. It increases the
2226 xg_detached_menus count.
2227 WIDGET is the GtkTearoffMenuItem.
2228 CLIENT_DATA is not used. */
2231 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2233 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2234 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2236 ++xg_detached_menus
;
2237 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2239 G_CALLBACK (tearoff_remove
), 0);
2244 /* Create a menu item widget, and connect the callbacks.
2245 ITEM decribes the menu item.
2246 F is the frame the created menu belongs to.
2247 SELECT_CB is the callback to use when a menu item is selected.
2248 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2249 CL_DATA points to the callback data to be used for this menu.
2250 GROUP is an in/out parameter. If the menu item to be created is not
2251 part of any radio menu group, *GROUP contains NULL on entry and exit.
2252 If the menu item to be created is part of a radio menu group, on entry
2253 *GROUP contains the group to use, or NULL if this is the first item
2254 in the group. On exit, *GROUP contains the radio item group.
2256 Returns the created GtkWidget. */
2259 xg_create_one_menuitem (widget_value
*item
,
2261 GCallback select_cb
,
2262 GCallback highlight_cb
,
2263 xg_menu_cb_data
*cl_data
,
2269 xg_menu_item_cb_data
*cb_data
;
2271 utf8_label
= get_utf8_string (item
->name
);
2272 utf8_key
= get_utf8_string (item
->key
);
2274 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2276 if (utf8_label
) g_free (utf8_label
);
2277 if (utf8_key
) g_free (utf8_key
);
2279 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2281 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2283 cb_data
->select_id
= 0;
2284 cb_data
->help
= item
->help
;
2285 cb_data
->cl_data
= cl_data
;
2286 cb_data
->call_data
= item
->call_data
;
2288 g_signal_connect (G_OBJECT (w
),
2290 G_CALLBACK (menuitem_destroy_callback
),
2293 /* Put cb_data in widget, so we can get at it when modifying menubar */
2294 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2296 /* final item, not a submenu */
2297 if (item
->call_data
&& ! item
->contents
)
2301 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2307 /* Create a full menu tree specified by DATA.
2308 F is the frame the created menu belongs to.
2309 SELECT_CB is the callback to use when a menu item is selected.
2310 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2311 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2312 POP_UP_P is non-zero if we shall create a popup menu.
2313 MENU_BAR_P is non-zero if we shall create a menu bar.
2314 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2315 if MENU_BAR_P is non-zero.
2316 TOPMENU is the topmost GtkWidget that others shall be placed under.
2317 It may be NULL, in that case we create the appropriate widget
2318 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2319 CL_DATA is the callback data we shall use for this menu, or NULL
2320 if we haven't set the first callback yet.
2321 NAME is the name to give to the top level menu if this function
2322 creates it. May be NULL to not set any name.
2324 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2327 This function calls itself to create submenus. */
2330 create_menus (widget_value
*data
,
2332 GCallback select_cb
,
2333 GCallback deactivate_cb
,
2334 GCallback highlight_cb
,
2339 xg_menu_cb_data
*cl_data
,
2343 GtkWidget
*wmenu
= topmenu
;
2344 GSList
*group
= NULL
;
2350 wmenu
= gtk_menu_new ();
2351 xg_set_screen (wmenu
, f
);
2352 /* Connect this to the menu instead of items so we get enter/leave for
2353 disabled items also. TODO: Still does not get enter/leave for
2354 disabled items in detached menus. */
2355 g_signal_connect (G_OBJECT (wmenu
),
2356 "enter-notify-event",
2357 G_CALLBACK (menuitem_highlight_callback
),
2359 g_signal_connect (G_OBJECT (wmenu
),
2360 "leave-notify-event",
2361 G_CALLBACK (menuitem_highlight_callback
),
2366 wmenu
= gtk_menu_bar_new ();
2367 /* Set width of menu bar to a small value so it doesn't enlarge
2368 a small initial frame size. The width will be set to the
2369 width of the frame later on when it is added to a container.
2370 height -1: Natural height. */
2371 gtk_widget_set_size_request (wmenu
, 1, -1);
2374 /* Put cl_data on the top menu for easier access. */
2375 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2376 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2377 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2378 G_CALLBACK (menu_destroy_callback
), cl_data
);
2381 gtk_widget_set_name (wmenu
, name
);
2384 g_signal_connect (G_OBJECT (wmenu
),
2385 "selection-done", deactivate_cb
, 0);
2388 if (! menu_bar_p
&& add_tearoff_p
)
2390 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2391 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2393 g_signal_connect (G_OBJECT (tearoff
), "activate",
2394 G_CALLBACK (tearoff_activate
), 0);
2397 for (item
= data
; item
; item
= item
->next
)
2401 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2402 && !menu_separator_name_p (item
->name
))
2405 /* A title for a popup. We do the same as GTK does when
2406 creating titles, but it does not look good. */
2408 utf8_label
= get_utf8_string (item
->name
);
2410 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2411 w
= gtk_menu_item_new_with_label (utf8_label
);
2412 gtk_widget_set_sensitive (w
, FALSE
);
2413 if (utf8_label
) g_free (utf8_label
);
2415 else if (menu_separator_name_p (item
->name
))
2418 /* GTK only have one separator type. */
2419 w
= gtk_separator_menu_item_new ();
2423 w
= xg_create_one_menuitem (item
,
2425 item
->contents
? 0 : select_cb
,
2430 /* Create a possibly empty submenu for menu bar items, since some
2431 themes don't highlight items correctly without it. */
2432 if (item
->contents
|| menu_bar_p
)
2434 GtkWidget
*submenu
= create_menus (item
->contents
,
2445 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2449 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2450 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2456 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2457 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2458 with some text and buttons.
2459 F is the frame the created item belongs to.
2460 NAME is the name to use for the top widget.
2461 VAL is a widget_value structure describing items to be created.
2462 SELECT_CB is the callback to use when a menu item is selected or
2463 a dialog button is pressed.
2464 DEACTIVATE_CB is the callback to use when an item is deactivated.
2465 For a menu, when a sub menu is not shown anymore, for a dialog it is
2466 called when the dialog is popped down.
2467 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2469 Returns the widget created. */
2472 xg_create_widget (const char *type
, const char *name
, FRAME_PTR f
, widget_value
*val
,
2473 GCallback select_cb
, GCallback deactivate_cb
,
2474 GCallback highlight_cb
)
2477 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2478 int pop_up_p
= strcmp (type
, "popup") == 0;
2480 if (strcmp (type
, "dialog") == 0)
2482 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2483 xg_set_screen (w
, f
);
2484 gtk_window_set_transient_for (GTK_WINDOW (w
),
2485 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2486 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2487 gtk_widget_set_name (w
, "emacs-dialog");
2488 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2490 else if (menu_bar_p
|| pop_up_p
)
2492 w
= create_menus (val
->contents
,
2504 /* Set the cursor to an arrow for popup menus when they are mapped.
2505 This is done by default for menu bar menus. */
2508 /* Must realize so the GdkWindow inside the widget is created. */
2509 gtk_widget_realize (w
);
2510 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2515 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2522 /* Return the label for menu item WITEM. */
2525 xg_get_menu_item_label (GtkMenuItem
*witem
)
2527 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2528 return gtk_label_get_label (wlabel
);
2531 /* Return non-zero if the menu item WITEM has the text LABEL. */
2534 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2537 char *utf8_label
= get_utf8_string (label
);
2538 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2540 if (! old_label
&& ! utf8_label
)
2542 else if (old_label
&& utf8_label
)
2543 is_same
= strcmp (utf8_label
, old_label
) == 0;
2545 if (utf8_label
) g_free (utf8_label
);
2550 /* Destroy widgets in LIST. */
2553 xg_destroy_widgets (GList
*list
)
2557 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2559 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2561 /* Destroying the widget will remove it from the container it is in. */
2562 gtk_widget_destroy (w
);
2566 /* Update the top level names in MENUBAR (i.e. not submenus).
2567 F is the frame the menu bar belongs to.
2568 *LIST is a list with the current menu bar names (menu item widgets).
2569 ITER is the item within *LIST that shall be updated.
2570 POS is the numerical position, starting at 0, of ITER in *LIST.
2571 VAL describes what the menu bar shall look like after the update.
2572 SELECT_CB is the callback to use when a menu item is selected.
2573 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2574 CL_DATA points to the callback data to be used for this menu bar.
2576 This function calls itself to walk through the menu bar names. */
2579 xg_update_menubar (GtkWidget
*menubar
,
2585 GCallback select_cb
,
2586 GCallback deactivate_cb
,
2587 GCallback highlight_cb
,
2588 xg_menu_cb_data
*cl_data
)
2590 if (! iter
&& ! val
)
2592 else if (iter
&& ! val
)
2594 /* Item(s) have been removed. Remove all remaining items. */
2595 xg_destroy_widgets (iter
);
2597 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2598 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2599 gtk_menu_item_new_with_label (""),
2605 else if (! iter
&& val
)
2607 /* Item(s) added. Add all new items in one call. */
2608 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2609 0, 1, 0, menubar
, cl_data
, 0);
2615 /* Below this neither iter or val is NULL */
2616 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2618 /* This item is still the same, check next item. */
2620 iter
= g_list_next (iter
);
2623 else /* This item is changed. */
2625 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2626 GtkMenuItem
*witem2
= 0;
2627 int val_in_menubar
= 0;
2628 int iter_in_new_menubar
= 0;
2632 /* See if the changed entry (val) is present later in the menu bar */
2634 iter2
&& ! val_in_menubar
;
2635 iter2
= g_list_next (iter2
))
2637 witem2
= GTK_MENU_ITEM (iter2
->data
);
2638 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2641 /* See if the current entry (iter) is present later in the
2642 specification for the new menu bar. */
2643 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2644 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2646 if (val_in_menubar
&& ! iter_in_new_menubar
)
2650 /* This corresponds to:
2655 g_object_ref (G_OBJECT (witem
));
2656 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2657 gtk_widget_destroy (GTK_WIDGET (witem
));
2659 /* Must get new list since the old changed. */
2660 g_list_free (*list
);
2661 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2662 while (nr
-- > 0) iter
= g_list_next (iter
);
2664 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2666 /* This corresponds to:
2669 Rename B to X. This might seem to be a strange thing to do,
2670 since if there is a menu under B it will be totally wrong for X.
2671 But consider editing a C file. Then there is a C-mode menu
2672 (corresponds to B above).
2673 If then doing C-x C-f the minibuf menu (X above) replaces the
2674 C-mode menu. When returning from the minibuffer, we get
2675 back the C-mode menu. Thus we do:
2676 Rename B to X (C-mode to minibuf menu)
2677 Rename X to B (minibuf to C-mode menu).
2678 If the X menu hasn't been invoked, the menu under B
2679 is up to date when leaving the minibuffer. */
2680 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2681 char *utf8_label
= get_utf8_string (val
->name
);
2682 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2684 gtk_label_set_text (wlabel
, utf8_label
);
2686 /* If this item has a submenu that has been detached, change
2687 the title in the WM decorations also. */
2688 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2689 /* Set the title of the detached window. */
2690 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2692 if (utf8_label
) g_free (utf8_label
);
2693 iter
= g_list_next (iter
);
2697 else if (! val_in_menubar
&& iter_in_new_menubar
)
2699 /* This corresponds to:
2706 GtkWidget
*w
= xg_create_one_menuitem (val
,
2713 /* Create a possibly empty submenu for menu bar items, since some
2714 themes don't highlight items correctly without it. */
2715 GtkWidget
*submenu
= create_menus (NULL
, f
,
2716 select_cb
, deactivate_cb
,
2718 0, 0, 0, 0, cl_data
, 0);
2719 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2720 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2721 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2723 g_list_free (*list
);
2724 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2725 while (nr
-- > 0) iter
= g_list_next (iter
);
2726 iter
= g_list_next (iter
);
2730 else /* if (val_in_menubar && iter_in_new_menubar) */
2733 /* This corresponds to:
2738 g_object_ref (G_OBJECT (witem2
));
2739 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2740 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2741 GTK_WIDGET (witem2
), pos
);
2742 g_object_unref (G_OBJECT (witem2
));
2744 g_list_free (*list
);
2745 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2746 while (nr
-- > 0) iter
= g_list_next (iter
);
2747 if (iter
) iter
= g_list_next (iter
);
2753 /* Update the rest of the menu bar. */
2754 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2755 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2758 /* Update the menu item W so it corresponds to VAL.
2759 SELECT_CB is the callback to use when a menu item is selected.
2760 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2761 CL_DATA is the data to set in the widget for menu invocation. */
2764 xg_update_menu_item (widget_value
*val
,
2766 GCallback select_cb
,
2767 GCallback highlight_cb
,
2768 xg_menu_cb_data
*cl_data
)
2775 const char *old_label
= 0;
2776 const char *old_key
= 0;
2777 xg_menu_item_cb_data
*cb_data
;
2779 wchild
= XG_BIN_CHILD (w
);
2780 utf8_label
= get_utf8_string (val
->name
);
2781 utf8_key
= get_utf8_string (val
->key
);
2783 /* See if W is a menu item with a key. See make_menu_item above. */
2784 if (GTK_IS_HBOX (wchild
))
2786 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2788 wlbl
= GTK_LABEL (list
->data
);
2789 wkey
= GTK_LABEL (list
->next
->data
);
2794 /* Remove the key and keep just the label. */
2795 g_object_ref (G_OBJECT (wlbl
));
2796 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2797 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2798 g_object_unref (G_OBJECT (wlbl
));
2803 else /* Just a label. */
2805 wlbl
= GTK_LABEL (wchild
);
2807 /* Check if there is now a key. */
2810 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2811 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2813 wlbl
= GTK_LABEL (list
->data
);
2814 wkey
= GTK_LABEL (list
->next
->data
);
2817 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2818 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2823 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2824 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2826 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2827 gtk_label_set_text (wkey
, utf8_key
);
2829 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2830 gtk_label_set_text (wlbl
, utf8_label
);
2832 if (utf8_key
) g_free (utf8_key
);
2833 if (utf8_label
) g_free (utf8_label
);
2835 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2836 gtk_widget_set_sensitive (w
, FALSE
);
2837 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2838 gtk_widget_set_sensitive (w
, TRUE
);
2840 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2844 cb_data
->call_data
= val
->call_data
;
2845 cb_data
->help
= val
->help
;
2846 cb_data
->cl_data
= cl_data
;
2848 /* We assume the callback functions don't change. */
2849 if (val
->call_data
&& ! val
->contents
)
2851 /* This item shall have a select callback. */
2852 if (! cb_data
->select_id
)
2854 = g_signal_connect (G_OBJECT (w
), "activate",
2855 select_cb
, cb_data
);
2857 else if (cb_data
->select_id
)
2859 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2860 cb_data
->select_id
= 0;
2865 /* Update the toggle menu item W so it corresponds to VAL. */
2868 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
2870 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2873 /* Update the radio menu item W so it corresponds to VAL. */
2876 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
2878 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2881 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2882 SUBMENU may be NULL, in that case a new menu is created.
2883 F is the frame the menu bar belongs to.
2884 VAL describes the contents of the menu bar.
2885 SELECT_CB is the callback to use when a menu item is selected.
2886 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2887 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2888 CL_DATA is the call back data to use for any newly created items.
2890 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2894 xg_update_submenu (GtkWidget
*submenu
,
2897 GCallback select_cb
,
2898 GCallback deactivate_cb
,
2899 GCallback highlight_cb
,
2900 xg_menu_cb_data
*cl_data
)
2902 GtkWidget
*newsub
= submenu
;
2906 int has_tearoff_p
= 0;
2907 GList
*first_radio
= 0;
2910 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2912 for (cur
= val
, iter
= list
;
2914 iter
= g_list_next (iter
), cur
= cur
->next
)
2916 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2918 /* Skip tearoff items, they have no counterpart in val. */
2919 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2922 iter
= g_list_next (iter
);
2923 if (iter
) w
= GTK_WIDGET (iter
->data
);
2927 /* Remember first radio button in a group. If we get a mismatch in
2928 a radio group we must rebuild the whole group so that the connections
2929 in GTK becomes correct. */
2930 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2932 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2933 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2936 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2938 if (! menu_separator_name_p (cur
->name
))
2941 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2943 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2945 xg_update_toggle_item (cur
, w
);
2946 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2948 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2950 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2952 xg_update_radio_item (cur
, w
);
2953 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2955 else if (GTK_IS_MENU_ITEM (w
))
2957 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2960 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2961 menu_separator_name_p (cur
->name
))
2964 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2966 sub
= gtk_menu_item_get_submenu (witem
);
2967 if (sub
&& ! cur
->contents
)
2969 /* Not a submenu anymore. */
2970 g_object_ref (G_OBJECT (sub
));
2971 remove_submenu (witem
);
2972 gtk_widget_destroy (sub
);
2974 else if (cur
->contents
)
2978 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2979 select_cb
, deactivate_cb
,
2980 highlight_cb
, cl_data
);
2982 /* If this item just became a submenu, we must set it. */
2984 gtk_menu_item_set_submenu (witem
, nsub
);
2989 /* Structural difference. Remove everything from here and down
2995 /* Remove widgets from first structual change. */
2998 /* If we are adding new menu items below, we must remove from
2999 first radio button so that radio groups become correct. */
3000 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3001 else xg_destroy_widgets (iter
);
3006 /* More items added. Create them. */
3007 newsub
= create_menus (cur
,
3020 if (list
) g_list_free (list
);
3025 /* Update the MENUBAR.
3026 F is the frame the menu bar belongs to.
3027 VAL describes the contents of the menu bar.
3028 If DEEP_P is non-zero, rebuild all but the top level menu names in
3029 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3030 SELECT_CB is the callback to use when a menu item is selected.
3031 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3032 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3035 xg_modify_menubar_widgets (GtkWidget
*menubar
, FRAME_PTR f
, widget_value
*val
,
3037 GCallback select_cb
, GCallback deactivate_cb
,
3038 GCallback highlight_cb
)
3040 xg_menu_cb_data
*cl_data
;
3041 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3045 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
3048 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3049 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3055 /* Update all sub menus.
3056 We must keep the submenus (GTK menu item widgets) since the
3057 X Window in the XEvent that activates the menu are those widgets. */
3059 /* Update cl_data, menu_item things in F may have changed. */
3060 update_cl_data (cl_data
, f
, highlight_cb
);
3062 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3067 GtkMenuItem
*witem
= 0;
3069 /* Find sub menu that corresponds to val and update it. */
3070 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3072 witem
= GTK_MENU_ITEM (iter
->data
);
3073 if (xg_item_label_same_p (witem
, cur
->name
))
3075 sub
= gtk_menu_item_get_submenu (witem
);
3080 newsub
= xg_update_submenu (sub
,
3087 /* sub may still be NULL. If we just updated non deep and added
3088 a new menu bar item, it has no sub menu yet. So we set the
3089 newly created sub menu under witem. */
3090 if (newsub
!= sub
&& witem
!= 0)
3092 xg_set_screen (newsub
, f
);
3093 gtk_menu_item_set_submenu (witem
, newsub
);
3099 gtk_widget_show_all (menubar
);
3102 /* Callback called when the menu bar W is mapped.
3103 Used to find the height of the menu bar if we didn't get it
3104 after showing the widget. */
3107 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3110 FRAME_PTR f
= (FRAME_PTR
) user_data
;
3111 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3112 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3114 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3115 xg_height_or_width_changed (f
);
3119 /* Recompute all the widgets of frame F, when the menu bar has been
3120 changed. Value is non-zero if widgets were updated. */
3123 xg_update_frame_menubar (FRAME_PTR f
)
3125 struct x_output
*x
= f
->output_data
.x
;
3128 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3131 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3132 return 0; /* Already done this, happens for frames created invisible. */
3136 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3138 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3140 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3141 gtk_widget_show_all (x
->menubar_widget
);
3142 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3144 /* If menu bar doesn't know its height yet, cheat a little so the frame
3145 doesn't jump so much when resized later in menubar_map_cb. */
3146 if (req
.height
== 0)
3149 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3151 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3152 xg_height_or_width_changed (f
);
3159 /* Get rid of the menu bar of frame F, and free its storage.
3160 This is used when deleting a frame, and when turning off the menu bar. */
3163 free_frame_menubar (FRAME_PTR f
)
3165 struct x_output
*x
= f
->output_data
.x
;
3167 if (x
->menubar_widget
)
3171 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3172 /* The menubar and its children shall be deleted when removed from
3174 x
->menubar_widget
= 0;
3175 FRAME_MENUBAR_HEIGHT (f
) = 0;
3176 xg_height_or_width_changed (f
);
3182 xg_event_is_for_menubar (FRAME_PTR f
, XEvent
*event
)
3184 struct x_output
*x
= f
->output_data
.x
;
3193 if (! x
->menubar_widget
) return 0;
3195 if (! (event
->xbutton
.x
>= 0
3196 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3197 && event
->xbutton
.y
>= 0
3198 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3199 && event
->xbutton
.same_screen
))
3202 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3203 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3205 gevent
.any
.window
= gw
;
3206 gwdesc
= gtk_get_event_widget (&gevent
);
3207 if (! gwdesc
) return 0;
3208 if (! GTK_IS_MENU_BAR (gwdesc
)
3209 && ! GTK_IS_MENU_ITEM (gwdesc
)
3210 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3213 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3214 if (! list
) return 0;
3215 rec
.x
= event
->xbutton
.x
;
3216 rec
.y
= event
->xbutton
.y
;
3220 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3222 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3223 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3227 return iter
== 0 ? 0 : 1;
3232 /***********************************************************************
3233 Scroll bar functions
3234 ***********************************************************************/
3237 /* Setting scroll bar values invokes the callback. Use this variable
3238 to indicate that callback should do nothing. */
3240 int xg_ignore_gtk_scrollbar
;
3242 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3243 may be larger than 32 bits. Keep a mapping from integer index to widget
3244 pointers to get around the 32 bit limitation. */
3248 GtkWidget
**widgets
;
3253 /* Grow this much every time we need to allocate more */
3255 #define ID_TO_WIDGET_INCR 32
3257 /* Store the widget pointer W in id_to_widget and return the integer index. */
3260 xg_store_widget_in_map (GtkWidget
*w
)
3264 if (id_to_widget
.max_size
== id_to_widget
.used
)
3266 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3268 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
3269 sizeof (GtkWidget
*)*new_size
);
3271 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3272 id_to_widget
.widgets
[i
] = 0;
3273 id_to_widget
.max_size
= new_size
;
3276 /* Just loop over the array and find a free place. After all,
3277 how many scroll bars are we creating? Should be a small number.
3278 The check above guarantees we will find a free place. */
3279 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3281 if (! id_to_widget
.widgets
[i
])
3283 id_to_widget
.widgets
[i
] = w
;
3284 ++id_to_widget
.used
;
3290 /* Should never end up here */
3294 /* Remove pointer at IDX from id_to_widget.
3295 Called when scroll bar is destroyed. */
3298 xg_remove_widget_from_map (int idx
)
3300 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3302 id_to_widget
.widgets
[idx
] = 0;
3303 --id_to_widget
.used
;
3307 /* Get the widget pointer at IDX from id_to_widget. */
3310 xg_get_widget_from_map (int idx
)
3312 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3313 return id_to_widget
.widgets
[idx
];
3318 /* Return the scrollbar id for X Window WID on display DPY.
3319 Return -1 if WID not in id_to_widget. */
3322 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3327 w
= xg_win_to_widget (dpy
, wid
);
3331 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3332 if (id_to_widget
.widgets
[idx
] == w
)
3339 /* Callback invoked when scroll bar WIDGET is destroyed.
3340 DATA is the index into id_to_widget for WIDGET.
3341 We free pointer to last scroll bar values here and remove the index. */
3344 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3346 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
3347 xg_remove_widget_from_map (id
);
3350 /* Create a scroll bar widget for frame F. Store the scroll bar
3352 SCROLL_CALLBACK is the callback to invoke when the value of the
3354 END_CALLBACK is the callback to invoke when scrolling ends.
3355 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3356 to set resources for the widget. */
3359 xg_create_scroll_bar (FRAME_PTR f
,
3360 struct scroll_bar
*bar
,
3361 GCallback scroll_callback
,
3362 GCallback end_callback
,
3363 const char *scroll_bar_name
)
3369 GtkAdjustment
*vadj
;
3374 /* Page, step increment values are not so important here, they
3375 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3376 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3379 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3380 webox
= gtk_event_box_new ();
3381 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3383 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3385 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3387 scroll_id
= xg_store_widget_in_map (wscroll
);
3389 /* The EMACS_INT cast avoids a warning. */
3390 g_signal_connect (G_OBJECT (wscroll
),
3392 G_CALLBACK (xg_gtk_scroll_destroy
),
3393 (gpointer
) (EMACS_INT
) scroll_id
);
3394 g_signal_connect (G_OBJECT (wscroll
),
3398 g_signal_connect (G_OBJECT (wscroll
),
3399 "button-release-event",
3403 /* The scroll bar widget does not draw on a window of its own. Instead
3404 it draws on the parent window, in this case the edit widget. So
3405 whenever the edit widget is cleared, the scroll bar needs to redraw
3406 also, which causes flicker. Put an event box between the edit widget
3407 and the scroll bar, so the scroll bar instead draws itself on the
3408 event box window. */
3409 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3410 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3413 /* Set the cursor to an arrow. */
3414 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3416 bar
->x_window
= scroll_id
;
3419 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3422 xg_remove_scroll_bar (FRAME_PTR f
, int scrollbar_id
)
3424 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3427 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3428 gtk_widget_destroy (w
);
3429 gtk_widget_destroy (wparent
);
3430 SET_FRAME_GARBAGED (f
);
3434 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3436 TOP/LEFT are the new pixel positions where the bar shall appear.
3437 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3440 xg_update_scrollbar_pos (FRAME_PTR f
,
3448 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3452 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3453 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3456 /* Clear out old position. */
3457 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3458 if (gtk_widget_get_parent (wparent
) == wfixed
)
3460 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3461 "x", &oldx
, "y", &oldy
, NULL
);
3462 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3465 /* Move and resize to new values. */
3466 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3467 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3470 /* No room. Hide scroll bar as some themes output a warning if
3471 the height is less than the min size. */
3472 gtk_widget_hide (wparent
);
3473 gtk_widget_hide (wscroll
);
3477 gtk_widget_show_all (wparent
);
3478 gtk_widget_set_size_request (wscroll
, width
, height
);
3480 gtk_widget_queue_draw (wfixed
);
3481 gdk_window_process_all_updates ();
3482 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3484 /* Clear under old scroll bar position. This must be done after
3485 the gtk_widget_queue_draw and gdk_window_process_all_updates
3487 x_clear_area (FRAME_X_DISPLAY (f
),
3489 oldx
, oldy
, oldw
, oldh
, 0);
3492 /* GTK does not redraw until the main loop is entered again, but
3493 if there are no X events pending we will not enter it. So we sync
3494 here to get some events. */
3497 SET_FRAME_GARBAGED (f
);
3498 cancel_mouse_face (f
);
3502 /* Set the thumb size and position of scroll bar BAR. We are currently
3503 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3506 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3511 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3513 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3515 if (wscroll
&& NILP (bar
->dragging
))
3524 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3526 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3527 rather than the real portion value. This makes the thumb less likely
3528 to resize and that looks better. */
3529 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3530 /* When the thumb is at the bottom, position == whole.
3531 So we need to increase `whole' to make space for the thumb. */
3538 top
= (gdouble
) position
/ whole
;
3539 shown
= (gdouble
) portion
/ whole
;
3542 size
= shown
* XG_SB_RANGE
;
3543 size
= min (size
, XG_SB_RANGE
);
3544 size
= max (size
, 1);
3546 value
= top
* XG_SB_RANGE
;
3547 value
= min (value
, XG_SB_MAX
- size
);
3548 value
= max (value
, XG_SB_MIN
);
3550 /* Assume all lines are of equal size. */
3551 new_step
= size
/ max (1, FRAME_LINES (f
));
3553 if ((int) gtk_adjustment_get_page_size (adj
) != size
3554 || (int) gtk_adjustment_get_step_increment (adj
) != new_step
)
3556 gtk_adjustment_set_page_size (adj
, size
);
3557 gtk_adjustment_set_step_increment (adj
, new_step
);
3558 /* Assume a page increment is about 95% of the page size */
3559 gtk_adjustment_set_page_increment (adj
,(int) (0.95*size
));
3563 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3567 /* gtk_range_set_value invokes the callback. Set
3568 ignore_gtk_scrollbar to make the callback do nothing */
3569 xg_ignore_gtk_scrollbar
= 1;
3571 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3572 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3574 gtk_adjustment_changed (adj
);
3576 xg_ignore_gtk_scrollbar
= 0;
3583 /* Return non-zero if EVENT is for a scroll bar in frame F.
3584 When the same X window is used for several Gtk+ widgets, we cannot
3585 say for sure based on the X window alone if an event is for the
3586 frame. This function does additional checks.
3588 Return non-zero if the event is for a scroll bar, zero otherwise. */
3591 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3595 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3597 /* Check if press occurred outside the edit widget. */
3598 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3599 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3600 != gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3603 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3604 || event
->type
== MotionNotify
))
3606 /* If we are releasing or moving the scroll bar, it has the grab. */
3607 GtkWidget
*w
= gtk_grab_get_current ();
3608 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3616 /***********************************************************************
3618 ***********************************************************************/
3619 /* The key for the data we put in the GtkImage widgets. The data is
3620 the image used by Emacs. We use this to see if we need to update
3621 the GtkImage with a new image. */
3622 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3624 /* The key for storing the latest modifiers so the activate callback can
3626 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3628 /* The key for storing the button widget in its proxy menu item. */
3629 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3631 /* The key for the data we put in the GtkImage widgets. The data is
3632 the stock name used by Emacs. We use this to see if we need to update
3633 the GtkImage with a new image. */
3634 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3636 /* As above, but this is used for named theme widgets, as opposed to
3638 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3640 /* Callback function invoked when a tool bar item is pressed.
3641 W is the button widget in the tool bar that got pressed,
3642 CLIENT_DATA is an integer that is the index of the button in the
3643 tool bar. 0 is the first button. */
3646 xg_tool_bar_button_cb (GtkWidget
*widget
,
3647 GdkEventButton
*event
,
3650 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3651 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3652 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3657 /* Callback function invoked when a tool bar item is pressed.
3658 W is the button widget in the tool bar that got pressed,
3659 CLIENT_DATA is an integer that is the index of the button in the
3660 tool bar. 0 is the first button. */
3663 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3665 /* The EMACS_INT cast avoids a warning. */
3666 int idx
= (int) (EMACS_INT
) client_data
;
3667 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3668 XG_TOOL_BAR_LAST_MODIFIER
);
3670 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3671 Lisp_Object key
, frame
;
3672 struct input_event event
;
3675 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3678 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3680 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3681 XSETFRAME (frame
, f
);
3683 /* We generate two events here. The first one is to set the prefix
3684 to `(tool_bar)', see keyboard.c. */
3685 event
.kind
= TOOL_BAR_EVENT
;
3686 event
.frame_or_window
= frame
;
3688 kbd_buffer_store_event (&event
);
3690 event
.kind
= TOOL_BAR_EVENT
;
3691 event
.frame_or_window
= frame
;
3693 /* Convert between the modifier bits GDK uses and the modifier bits
3694 Emacs uses. This assumes GDK and X masks are the same, which they are when
3696 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3697 kbd_buffer_store_event (&event
);
3699 /* Return focus to the frame after we have clicked on a detached
3701 Fx_focus_frame (frame
);
3704 /* Callback function invoked when a tool bar item is pressed in a detached
3705 tool bar or the overflow drop down menu.
3706 We just call xg_tool_bar_callback.
3707 W is the menu item widget that got pressed,
3708 CLIENT_DATA is an integer that is the index of the button in the
3709 tool bar. 0 is the first button. */
3712 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3714 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3715 XG_TOOL_BAR_PROXY_BUTTON
));
3716 xg_tool_bar_callback (wbutton
, client_data
);
3721 xg_tool_bar_help_callback (GtkWidget
*w
,
3722 GdkEventCrossing
*event
,
3723 gpointer client_data
);
3725 /* This callback is called when a help is to be shown for an item in
3726 the detached tool bar when the detached tool bar it is not expanded. */
3729 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3730 GdkEventCrossing
*event
,
3731 gpointer client_data
)
3733 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3734 XG_TOOL_BAR_PROXY_BUTTON
));
3736 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3740 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3742 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3743 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3744 GtkWidget
*c2
= clist
->next
? (GtkWidget
*) clist
->next
->data
: NULL
;
3746 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3747 g_list_free (clist
);
3748 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3752 /* This callback is called when a tool item should create a proxy item,
3753 such as for the overflow menu. Also called when the tool bar is detached.
3754 If we don't create a proxy menu item, the detached tool bar will be
3758 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3760 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
3761 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
3763 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3764 GtkImage
*wimage
= GTK_IMAGE (c1
);
3765 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3766 (wlbl
? gtk_label_get_text (wlbl
) : "");
3767 GtkWidget
*wmenuimage
;
3770 if (gtk_button_get_use_stock (wbutton
))
3771 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3772 GTK_ICON_SIZE_MENU
);
3775 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3776 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3778 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
3780 if (store_type
== GTK_IMAGE_STOCK
)
3783 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3784 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3786 else if (store_type
== GTK_IMAGE_ICON_SET
)
3788 GtkIconSet
*icon_set
;
3789 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3790 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3791 GTK_ICON_SIZE_MENU
);
3793 else if (store_type
== GTK_IMAGE_PIXBUF
)
3798 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3801 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3803 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3804 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3805 GDK_INTERP_BILINEAR
);
3807 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3811 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3815 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3817 const gchar
*icon_name
;
3818 GtkIconSize icon_size
;
3820 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3821 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3822 GTK_ICON_SIZE_MENU
);
3826 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3831 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3833 g_signal_connect (G_OBJECT (wmenuitem
),
3835 G_CALLBACK (xg_tool_bar_proxy_callback
),
3839 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3840 (gpointer
) wbutton
);
3841 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3842 gtk_widget_set_sensitive (wmenuitem
,
3843 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
3845 /* Use enter/leave notify to show help. We use the events
3846 rather than the GtkButton specific signals "enter" and
3847 "leave", so we can have only one callback. The event
3848 will tell us what kind of event it is. */
3849 g_signal_connect (G_OBJECT (wmenuitem
),
3850 "enter-notify-event",
3851 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3853 g_signal_connect (G_OBJECT (wmenuitem
),
3854 "leave-notify-event",
3855 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3861 /* This callback is called when a tool bar is detached. We must set
3862 the height of the tool bar to zero when this happens so frame sizes
3863 are correctly calculated.
3864 WBOX is the handle box widget that enables detach/attach of the tool bar.
3865 W is the tool bar widget.
3866 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3869 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
3871 gpointer client_data
)
3873 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3875 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3880 GtkRequisition req
, req2
;
3881 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3882 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
3883 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
3884 req
.width
-= req2
.width
;
3885 req
.height
-= req2
.height
;
3886 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
3887 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
3888 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
3889 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
3890 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
3891 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
3892 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
3893 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
3894 xg_height_or_width_changed (f
);
3898 /* This callback is called when a tool bar is reattached. We must set
3899 the height of the tool bar when this happens so frame sizes
3900 are correctly calculated.
3901 WBOX is the handle box widget that enables detach/attach of the tool bar.
3902 W is the tool bar widget.
3903 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3906 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
3908 gpointer client_data
)
3910 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3911 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3915 GtkRequisition req
, req2
;
3916 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3917 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
3918 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
3919 req
.width
+= req2
.width
;
3920 req
.height
+= req2
.height
;
3921 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
3922 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
3923 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
3924 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
3925 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
3926 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
3927 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
3928 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
3929 xg_height_or_width_changed (f
);
3933 /* This callback is called when the mouse enters or leaves a tool bar item.
3934 It is used for displaying and hiding the help text.
3935 W is the tool bar item, a button.
3936 EVENT is either an enter event or leave event.
3937 CLIENT_DATA is an integer that is the index of the button in the
3938 tool bar. 0 is the first button.
3940 Returns FALSE to tell GTK to keep processing this event. */
3943 xg_tool_bar_help_callback (GtkWidget
*w
,
3944 GdkEventCrossing
*event
,
3945 gpointer client_data
)
3947 /* The EMACS_INT cast avoids a warning. */
3948 int idx
= (int) (EMACS_INT
) client_data
;
3949 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3950 Lisp_Object help
, frame
;
3952 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3955 if (event
->type
== GDK_ENTER_NOTIFY
)
3957 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3958 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3961 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3966 XSETFRAME (frame
, f
);
3967 kbd_buffer_store_help_event (frame
, help
);
3973 /* This callback is called when a tool bar item shall be redrawn.
3974 It modifies the expose event so that the GtkImage widget redraws the
3975 whole image. This to overcome a bug that makes GtkImage draw the image
3976 in the wrong place when it tries to redraw just a part of the image.
3977 W is the GtkImage to be redrawn.
3978 EVENT is the expose event for W.
3979 CLIENT_DATA is unused.
3981 Returns FALSE to tell GTK to keep processing this event. */
3985 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
3986 GdkEventExpose
*event
,
3987 gpointer client_data
)
3991 gdk_drawable_get_size (event
->window
, &width
, &height
);
3992 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3993 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3995 event
->area
.x
= max (0, event
->area
.x
);
3996 event
->area
.y
= max (0, event
->area
.y
);
3998 event
->area
.width
= max (width
, event
->area
.width
);
3999 event
->area
.height
= max (height
, event
->area
.height
);
4005 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4006 #define toolbar_set_orientation(w, o) \
4007 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4009 #define toolbar_set_orientation(w, o) \
4010 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4013 /* Attach a tool bar to frame F. */
4016 xg_pack_tool_bar (FRAME_PTR f
, Lisp_Object pos
)
4018 struct x_output
*x
= f
->output_data
.x
;
4019 int into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4021 toolbar_set_orientation (x
->toolbar_widget
,
4023 ? GTK_ORIENTATION_VERTICAL
4024 : GTK_ORIENTATION_HORIZONTAL
);
4025 if (!x
->handlebox_widget
)
4027 x
->handlebox_widget
= gtk_handle_box_new ();
4028 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4029 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4030 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4031 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4032 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4038 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4040 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), x
->handlebox_widget
,
4043 if (EQ (pos
, Qleft
))
4044 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4045 x
->handlebox_widget
,
4047 x
->toolbar_in_hbox
= 1;
4051 int vbox_pos
= x
->menubar_widget
? 1 : 0;
4052 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4054 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
4058 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4059 x
->handlebox_widget
,
4061 x
->toolbar_in_hbox
= 0;
4065 /* Create a tool bar for frame F. */
4068 xg_create_tool_bar (FRAME_PTR f
)
4070 struct x_output
*x
= f
->output_data
.x
;
4072 x
->toolbar_widget
= gtk_toolbar_new ();
4073 x
->toolbar_detached
= 0;
4075 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4077 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4078 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4082 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4084 /* Find the right-to-left image named by RTL in the tool bar images for F.
4085 Returns IMAGE if RTL is not found. */
4088 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
4091 Lisp_Object file
, rtl_name
;
4092 struct gcpro gcpro1
, gcpro2
;
4093 GCPRO2 (file
, rtl_name
);
4095 rtl_name
= Ffile_name_nondirectory (rtl
);
4097 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4099 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4100 if (!NILP (file
= file_for_image (rtl_image
)))
4102 file
= call1 (intern ("file-name-sans-extension"),
4103 Ffile_name_nondirectory (file
));
4104 if (EQ (Fequal (file
, rtl_name
), Qt
))
4115 static GtkToolItem
*
4116 xg_make_tool_item (FRAME_PTR f
,
4118 GtkWidget
**wbutton
,
4120 int i
, int horiz
, int text_image
)
4122 GtkToolItem
*ti
= gtk_tool_item_new ();
4123 GtkWidget
*vb
= horiz
? gtk_hbox_new (FALSE
, 0) : gtk_vbox_new (FALSE
, 0);
4124 GtkWidget
*wb
= gtk_button_new ();
4125 GtkWidget
*weventbox
= gtk_event_box_new ();
4127 if (wimage
&& !text_image
)
4128 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4130 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4131 if (wimage
&& text_image
)
4132 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4134 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4135 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4136 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4137 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4138 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4142 /* The EMACS_INT cast avoids a warning. */
4143 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4144 G_CALLBACK (xg_tool_bar_menu_proxy
),
4145 (gpointer
) (EMACS_INT
) i
);
4147 g_signal_connect (G_OBJECT (wb
), "clicked",
4148 G_CALLBACK (xg_tool_bar_callback
),
4149 (gpointer
) (EMACS_INT
) i
);
4151 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4154 /* Catch expose events to overcome an annoying redraw bug, see
4155 comment for xg_tool_bar_item_expose_callback. */
4156 g_signal_connect (G_OBJECT (ti
),
4158 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4161 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4163 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
4164 no distinction based on modifiers in the activate callback,
4165 so we have to do it ourselves. */
4166 g_signal_connect (wb
, "button-release-event",
4167 G_CALLBACK (xg_tool_bar_button_cb
),
4170 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4172 /* Use enter/leave notify to show help. We use the events
4173 rather than the GtkButton specific signals "enter" and
4174 "leave", so we can have only one callback. The event
4175 will tell us what kind of event it is. */
4176 /* The EMACS_INT cast avoids a warning. */
4177 g_signal_connect (G_OBJECT (weventbox
),
4178 "enter-notify-event",
4179 G_CALLBACK (xg_tool_bar_help_callback
),
4180 (gpointer
) (EMACS_INT
) i
);
4181 g_signal_connect (G_OBJECT (weventbox
),
4182 "leave-notify-event",
4183 G_CALLBACK (xg_tool_bar_help_callback
),
4184 (gpointer
) (EMACS_INT
) i
);
4187 if (wbutton
) *wbutton
= wb
;
4193 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4194 const char *icon_name
, const struct image
*img
,
4195 const char *label
, int horiz
)
4199 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4200 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4202 /* Check if the tool icon matches. */
4205 old
= g_object_get_data (G_OBJECT (wimage
),
4206 XG_TOOL_BAR_STOCK_NAME
);
4207 if (!old
|| strcmp (old
, stock_name
))
4212 old
= g_object_get_data (G_OBJECT (wimage
),
4213 XG_TOOL_BAR_ICON_NAME
);
4214 if (!old
|| strcmp (old
, icon_name
))
4220 = (Pixmap
) g_object_get_data (G_OBJECT (wimage
),
4221 XG_TOOL_BAR_IMAGE_DATA
);
4222 if (old_img
!= img
->pixmap
)
4226 /* Check button configuration and label. */
4227 if ((horiz
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
))
4228 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4231 /* Ensure label is correct. */
4233 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4238 xg_update_tool_bar_sizes (FRAME_PTR f
)
4240 struct x_output
*x
= f
->output_data
.x
;
4242 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4244 gtk_widget_get_preferred_size (GTK_WIDGET (x
->handlebox_widget
), NULL
, &req
);
4245 if (x
->toolbar_in_hbox
)
4248 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4249 x
->handlebox_widget
,
4250 "position", &pos
, NULL
);
4251 if (pos
== 0) nl
= req
.width
;
4252 else nr
= req
.width
;
4257 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4258 x
->handlebox_widget
,
4259 "position", &pos
, NULL
);
4260 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4261 else nb
= req
.height
;
4264 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4265 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4266 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4267 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4269 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4270 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4271 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4272 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4273 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4274 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4282 /* Update the tool bar for frame F. Add new buttons and remove old. */
4285 update_frame_tool_bar (FRAME_PTR f
)
4288 struct x_output
*x
= f
->output_data
.x
;
4289 int hmargin
= 0, vmargin
= 0;
4290 GtkToolbar
*wtoolbar
;
4292 GtkTextDirection dir
;
4293 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
4295 int text_image
, horiz
;
4297 if (! FRAME_GTK_WIDGET (f
))
4302 if (INTEGERP (Vtool_bar_button_margin
)
4303 && XINT (Vtool_bar_button_margin
) > 0)
4305 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4306 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4308 else if (CONSP (Vtool_bar_button_margin
))
4310 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
4311 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
4312 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4314 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
4315 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
4316 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4319 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4320 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4321 i.e. zero. This means that margins less than
4322 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4323 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4324 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4326 if (! x
->toolbar_widget
)
4327 xg_create_tool_bar (f
);
4329 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4330 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4332 style
= Ftool_bar_get_system_style ();
4333 text_image
= EQ (style
, Qtext_image_horiz
);
4334 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4336 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4338 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4339 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4343 struct image
*img
= NULL
;
4345 Lisp_Object stock
= Qnil
;
4346 GtkStockItem stock_item
;
4347 char *stock_name
= NULL
;
4348 char *icon_name
= NULL
;
4350 GtkWidget
*wbutton
= NULL
;
4351 Lisp_Object specified_file
;
4352 int vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4354 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4355 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4356 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4359 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4361 /* If this is a separator, use a gtk separator item. */
4362 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4364 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4367 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4369 ti
= gtk_separator_tool_item_new ();
4370 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4376 /* Otherwise, the tool-bar item is an ordinary button. */
4378 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4380 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4384 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4386 /* Ignore invalid image specifications. */
4387 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4388 if (!valid_image_p (image
))
4391 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4396 specified_file
= file_for_image (image
);
4397 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4398 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4400 if (STRINGP (stock
))
4402 stock_name
= SSDATA (stock
);
4403 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4405 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4406 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4408 icon_name
= stock_name
+ 2;
4412 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4415 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4417 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4418 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4426 if (stock_name
== NULL
&& icon_name
== NULL
)
4428 /* No stock image, or stock item not known. Try regular
4429 image. If image is a vector, choose it according to the
4431 if (dir
== GTK_TEXT_DIR_RTL
4432 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4434 image
= find_rtl_image (f
, image
, rtl
);
4436 if (VECTORP (image
))
4440 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4441 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4444 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4445 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4447 xassert (ASIZE (image
) >= idx
);
4448 image
= AREF (image
, idx
);
4453 img_id
= lookup_image (f
, image
);
4454 img
= IMAGE_FROM_ID (f
, img_id
);
4455 prepare_image_for_display (f
, img
);
4457 if (img
->load_failed_p
|| img
->pixmap
== None
)
4460 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4466 /* If there is an existing widget, check if it's stale; if so,
4467 remove it and make a new tool item from scratch. */
4468 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4471 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4480 /* Save the image so we can see if an update is needed the
4481 next time we call xg_tool_item_match_p. */
4482 if (EQ (style
, Qtext
))
4484 else if (stock_name
)
4486 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4487 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4488 (gpointer
) xstrdup (stock_name
),
4489 (GDestroyNotify
) xfree
);
4493 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4494 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4495 (gpointer
) xstrdup (icon_name
),
4496 (GDestroyNotify
) xfree
);
4500 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4501 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4502 (gpointer
)img
->pixmap
);
4505 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4506 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4507 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4512 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4516 /* Remove buttons not longer needed. */
4519 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4521 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4522 } while (ti
!= NULL
);
4524 if (f
->n_tool_bar_items
!= 0)
4527 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4528 gtk_widget_show_all (GTK_WIDGET (x
->handlebox_widget
));
4529 if (xg_update_tool_bar_sizes (f
))
4530 xg_height_or_width_changed (f
);
4536 /* Deallocate all resources for the tool bar on frame F.
4537 Remove the tool bar. */
4540 free_frame_tool_bar (FRAME_PTR f
)
4542 struct x_output
*x
= f
->output_data
.x
;
4544 if (x
->toolbar_widget
)
4546 int is_packed
= x
->handlebox_widget
!= 0;
4548 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4549 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4552 if (x
->toolbar_in_hbox
)
4553 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4554 x
->handlebox_widget
);
4556 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4557 x
->handlebox_widget
);
4560 gtk_widget_destroy (x
->toolbar_widget
);
4562 x
->toolbar_widget
= 0;
4563 x
->handlebox_widget
= 0;
4564 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4565 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4567 xg_height_or_width_changed (f
);
4574 xg_change_toolbar_position (FRAME_PTR f
, Lisp_Object pos
)
4576 struct x_output
*x
= f
->output_data
.x
;
4578 if (! x
->toolbar_widget
|| ! x
->handlebox_widget
)
4582 g_object_ref (x
->handlebox_widget
);
4583 if (x
->toolbar_in_hbox
)
4584 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4585 x
->handlebox_widget
);
4587 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4588 x
->handlebox_widget
);
4589 xg_pack_tool_bar (f
, pos
);
4590 g_object_unref (x
->handlebox_widget
);
4591 if (xg_update_tool_bar_sizes (f
))
4592 xg_height_or_width_changed (f
);
4600 /***********************************************************************
4602 ***********************************************************************/
4604 xg_initialize (void)
4606 GtkBindingSet
*binding_set
;
4609 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4610 we keep it permanently linked in. */
4615 xg_ignore_gtk_scrollbar
= 0;
4616 xg_detached_menus
= 0;
4617 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4618 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4620 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4621 id_to_widget
.widgets
= 0;
4623 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4624 bindings. It doesn't seem to be any way to remove properties,
4625 so we set it to VoidSymbol which in X means "no key". */
4626 gtk_settings_set_string_property (gtk_settings_get_default (),
4627 "gtk-menu-bar-accel",
4631 /* Make GTK text input widgets use Emacs style keybindings. This is
4633 gtk_settings_set_string_property (gtk_settings_get_default (),
4634 "gtk-key-theme-name",
4638 /* Make dialogs close on C-g. Since file dialog inherits from
4639 dialog, this works for them also. */
4640 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4641 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4644 /* Make menus close on C-g. */
4645 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4646 (GTK_TYPE_MENU_SHELL
));
4647 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4651 #endif /* USE_GTK */