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>
45 #include "emacsgtkfixed.h"
48 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
49 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
51 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
52 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
54 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
55 #define gtk_widget_set_has_window(w, b) \
56 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
58 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
59 #define gtk_dialog_get_action_area(w) ((w)->action_area)
60 #define gtk_dialog_get_content_area(w) ((w)->vbox)
62 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
63 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
65 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
66 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
67 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
68 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
69 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
71 #if GTK_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 11
72 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
74 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
78 #ifdef USE_GTK_TOOLTIP
79 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
81 #define gdk_window_get_geometry(w, a, b, c, d) \
82 gdk_window_get_geometry (w, a, b, c, d, 0)
83 #define gdk_x11_window_lookup_for_display(d, w) \
84 gdk_xid_table_lookup_for_display (d, w)
86 #define GDK_KEY_g GDK_g
90 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
92 static void update_theme_scrollbar_width (void);
95 /***********************************************************************
96 Display handling functions
97 ***********************************************************************/
99 /* Keep track of the default display, or NULL if there is none. Emacs
100 may close all its displays. */
102 static GdkDisplay
*gdpy_def
;
104 /* When the GTK widget W is to be created on a display for F that
105 is not the default display, set the display for W.
106 W can be a GtkMenu or a GtkWindow widget. */
109 xg_set_screen (GtkWidget
*w
, FRAME_PTR f
)
111 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
113 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
114 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
117 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
119 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
124 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
125 *DPY is set to NULL if the display can't be opened.
127 Returns non-zero if display could be opened, zero if display could not
128 be opened, and less than zero if the GTK version doesn't support
132 xg_display_open (char *display_name
, Display
**dpy
)
136 gdpy
= gdk_display_open (display_name
);
137 if (!gdpy_def
&& gdpy
)
140 gdk_display_manager_set_default_display (gdk_display_manager_get (),
144 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
148 /* Close display DPY. */
151 xg_display_close (Display
*dpy
)
153 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
155 /* If this is the default display, try to change it before closing.
156 If there is no other display to use, gdpy_def is set to NULL, and
157 the next call to xg_display_open resets the default display. */
158 if (gdk_display_get_default () == gdpy
)
160 struct x_display_info
*dpyinfo
;
161 GdkDisplay
*gdpy_new
= NULL
;
163 /* Find another display. */
164 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
165 if (dpyinfo
->display
!= dpy
)
167 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
168 gdk_display_manager_set_default_display (gdk_display_manager_get (),
175 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
176 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
177 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
178 can continue running, but there will be memory leaks. */
179 g_object_run_dispose (G_OBJECT (gdpy
));
181 /* This seems to be fixed in GTK 2.10. */
182 gdk_display_close (gdpy
);
187 /***********************************************************************
189 ***********************************************************************/
190 /* The next two variables and functions are taken from lwlib. */
191 static widget_value
*widget_value_free_list
;
192 static int malloc_cpt
;
194 /* Allocate a widget_value structure, either by taking one from the
195 widget_value_free_list or by malloc:ing a new one.
197 Return a pointer to the allocated structure. */
200 malloc_widget_value (void)
203 if (widget_value_free_list
)
205 wv
= widget_value_free_list
;
206 widget_value_free_list
= wv
->free_list
;
211 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
214 memset (wv
, 0, sizeof (widget_value
));
218 /* This is analogous to free. It frees only what was allocated
219 by malloc_widget_value, and no substructures. */
222 free_widget_value (widget_value
*wv
)
229 /* When the number of already allocated cells is too big,
236 wv
->free_list
= widget_value_free_list
;
237 widget_value_free_list
= wv
;
242 /* Create and return the cursor to be used for popup menus and
243 scroll bars on display DPY. */
246 xg_create_default_cursor (Display
*dpy
)
248 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
249 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
253 xg_get_pixbuf_from_pixmap (FRAME_PTR f
, Pixmap pix
)
258 unsigned int width
, height
, uunused
;
261 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
262 &width
, &height
, &uunused
, &uunused
);
264 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
268 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
281 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
284 xg_get_pixbuf_from_pix_and_mask (FRAME_PTR f
,
289 GdkPixbuf
*icon_buf
, *tmp_buf
;
291 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
292 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
293 g_object_unref (G_OBJECT (tmp_buf
));
295 width
= gdk_pixbuf_get_width (icon_buf
);
296 height
= gdk_pixbuf_get_height (icon_buf
);
300 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
301 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
302 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
303 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
304 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
307 for (y
= 0; y
< height
; ++y
)
309 guchar
*iconptr
, *maskptr
;
312 iconptr
= pixels
+ y
* rowstride
;
313 maskptr
= mask_pixels
+ y
* mask_rowstride
;
315 for (x
= 0; x
< width
; ++x
)
317 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
318 just R is sufficient. */
320 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
322 iconptr
+= rowstride
/width
;
323 maskptr
+= mask_rowstride
/width
;
327 g_object_unref (G_OBJECT (mask_buf
));
334 file_for_image (Lisp_Object image
)
336 Lisp_Object specified_file
= Qnil
;
339 for (tail
= XCDR (image
);
340 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
341 tail
= XCDR (XCDR (tail
)))
342 if (EQ (XCAR (tail
), QCfile
))
343 specified_file
= XCAR (XCDR (tail
));
345 return specified_file
;
348 /* For the image defined in IMG, make and return a GtkImage. For displays with
349 8 planes or less we must make a GdkPixbuf and apply the mask manually.
350 Otherwise the highlightning and dimming the tool bar code in GTK does
351 will look bad. For display with more than 8 planes we just use the
352 pixmap and mask directly. For monochrome displays, GTK doesn't seem
353 able to use external pixmaps, it looks bad whatever we do.
354 The image is defined on the display where frame F is.
355 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
356 If OLD_WIDGET is NULL, a new widget is constructed and returned.
357 If OLD_WIDGET is not NULL, that widget is modified. */
360 xg_get_image_for_pixmap (FRAME_PTR f
,
363 GtkImage
*old_widget
)
367 /* If we have a file, let GTK do all the image handling.
368 This seems to be the only way to make insensitive and activated icons
369 look good in all cases. */
370 Lisp_Object specified_file
= file_for_image (img
->spec
);
373 /* We already loaded the image once before calling this
374 function, so this only fails if the image file has been removed.
375 In that case, use the pixmap already loaded. */
377 if (STRINGP (specified_file
)
378 && STRINGP (file
= x_find_image_file (specified_file
)))
381 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
383 gtk_image_set_from_file (old_widget
, SSDATA (file
));
385 return GTK_WIDGET (old_widget
);
388 /* No file, do the image handling ourselves. This will look very bad
389 on a monochrome display, and sometimes bad on all displays with
392 /* This is a workaround to make icons look good on pseudo color
393 displays. Apparently GTK expects the images to have an alpha
394 channel. If they don't, insensitive and activated icons will
395 look bad. This workaround does not work on monochrome displays,
396 and is strictly not needed on true color/static color displays (i.e.
397 16 bits and higher). But we do it anyway so we get a pixbuf that is
398 not associated with the img->pixmap. The img->pixmap may be removed
399 by clearing the image cache and then the tool bar redraw fails, since
400 Gtk+ assumes the pixmap is always there. */
401 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
406 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
408 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
410 g_object_unref (G_OBJECT (icon_buf
));
413 return GTK_WIDGET (old_widget
);
417 /* Set CURSOR on W and all widgets W contain. We must do like this
418 for scroll bars and menu because they create widgets internally,
419 and it is those widgets that are visible. */
422 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
424 GdkWindow
*window
= gtk_widget_get_window(w
);
425 GList
*children
= gdk_window_peek_children (window
);
427 gdk_window_set_cursor (window
, cursor
);
429 /* The scroll bar widget has more than one GDK window (had to look at
430 the source to figure this out), and there is no way to set cursor
431 on widgets in GTK. So we must set the cursor for all GDK windows.
434 for ( ; children
; children
= g_list_next (children
))
435 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
438 /* Insert NODE into linked LIST. */
441 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
443 xg_list_node
*list_start
= list
->next
;
445 if (list_start
) list_start
->prev
= node
;
446 node
->next
= list_start
;
451 /* Remove NODE from linked LIST. */
454 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
456 xg_list_node
*list_start
= list
->next
;
457 if (node
== list_start
)
459 list
->next
= node
->next
;
460 if (list
->next
) list
->next
->prev
= 0;
464 node
->prev
->next
= node
->next
;
465 if (node
->next
) node
->next
->prev
= node
->prev
;
469 /* Allocate and return a utf8 version of STR. If STR is already
470 utf8 or NULL, just return a copy of STR.
471 A new string is allocated and the caller must free the result
475 get_utf8_string (const char *str
)
479 if (!str
) return NULL
;
481 /* If not UTF-8, try current locale. */
482 if (!g_utf8_validate (str
, -1, NULL
))
483 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
485 return g_strdup (str
);
489 /* Probably some control characters in str. Escape them. */
493 unsigned char *p
= (unsigned char *)str
;
497 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
498 &bytes_written
, &err
))
499 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
502 p
+= bytes_written
+1;
514 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
515 p
= (unsigned char *)str
;
517 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
518 &bytes_written
, &err
))
519 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
521 strncpy (up
, (char *)p
, bytes_written
);
522 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
523 up
[bytes_written
+4] = '\0';
524 up
+= bytes_written
+4;
525 p
+= bytes_written
+1;
532 strcat (utf8_str
, cp
);
544 /* Check for special colors used in face spec for region face.
545 The colors are fetched from the Gtk+ theme.
546 Return 1 if color was found, 0 if not. */
549 xg_check_special_colors (struct frame
*f
,
550 const char *color_name
,
554 int get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
555 int get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
557 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
563 GtkStyleContext
*gsty
564 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
567 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
569 gtk_style_context_get_color (gsty
, state
, &col
);
571 gtk_style_context_get_background_color (gsty
, state
, &col
);
573 sprintf (buf
, "rgbi:%lf/%lf/%lf", col
.red
, col
.green
, col
.blue
);
574 success_p
= XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
577 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
578 GdkColor
*grgb
= get_bg
579 ? &gsty
->bg
[GTK_STATE_SELECTED
]
580 : &gsty
->fg
[GTK_STATE_SELECTED
];
582 color
->red
= grgb
->red
;
583 color
->green
= grgb
->green
;
584 color
->blue
= grgb
->blue
;
585 color
->pixel
= grgb
->pixel
;
596 /***********************************************************************
598 ***********************************************************************/
599 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
600 We use that to pop down the tooltip. This happens if Gtk+ for some
601 reason wants to change or hide the tooltip. */
603 #ifdef USE_GTK_TOOLTIP
606 hierarchy_ch_cb (GtkWidget
*widget
,
607 GtkWidget
*previous_toplevel
,
610 FRAME_PTR f
= (FRAME_PTR
) user_data
;
611 struct x_output
*x
= f
->output_data
.x
;
612 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
614 if (! top
|| ! GTK_IS_WINDOW (top
))
615 gtk_widget_hide (previous_toplevel
);
618 /* Callback called when Gtk+ thinks a tooltip should be displayed.
619 We use it to get the tooltip window and the tooltip widget so
620 we can manipulate the ourselves.
622 Return FALSE ensures that the tooltip is not shown. */
625 qttip_cb (GtkWidget
*widget
,
628 gboolean keyboard_mode
,
632 FRAME_PTR f
= (FRAME_PTR
) user_data
;
633 struct x_output
*x
= f
->output_data
.x
;
634 if (x
->ttip_widget
== NULL
)
639 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
640 x
->ttip_widget
= tooltip
;
641 g_object_ref (G_OBJECT (tooltip
));
642 x
->ttip_lbl
= gtk_label_new ("");
643 g_object_ref (G_OBJECT (x
->ttip_lbl
));
644 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
645 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
647 /* Change stupid Gtk+ default line wrapping. */
648 p
= gtk_widget_get_parent (x
->ttip_lbl
);
649 list
= gtk_container_get_children (GTK_CONTAINER (p
));
651 for (iter
= list
; iter
; iter
= g_list_next (iter
))
653 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
654 if (GTK_IS_LABEL (w
))
655 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
659 /* ATK needs an empty title for some reason. */
660 gtk_window_set_title (x
->ttip_window
, "");
661 /* Realize so we can safely get screen later on. */
662 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
663 gtk_widget_realize (x
->ttip_lbl
);
665 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
666 G_CALLBACK (hierarchy_ch_cb
), f
);
671 #endif /* USE_GTK_TOOLTIP */
673 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
674 Return zero if no system tooltip available, non-zero otherwise. */
677 xg_prepare_tooltip (FRAME_PTR f
,
682 #ifndef USE_GTK_TOOLTIP
685 struct x_output
*x
= f
->output_data
.x
;
689 GtkSettings
*settings
;
690 gboolean tt_enabled
= TRUE
;
692 Lisp_Object encoded_string
;
694 if (!x
->ttip_lbl
) return 0;
697 encoded_string
= ENCODE_UTF_8 (string
);
698 widget
= GTK_WIDGET (x
->ttip_lbl
);
699 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
700 screen
= gdk_window_get_screen (gwin
);
701 settings
= gtk_settings_get_for_screen (screen
);
702 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
705 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
706 /* Record that we disabled it so it can be enabled again. */
707 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
711 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
712 g_object_set_data (G_OBJECT
713 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
714 "gdk-display-current-tooltip", NULL
);
716 /* Put our dummy widget in so we can get callbacks for unrealize and
717 hierarchy-changed. */
718 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
719 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
720 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
721 if (width
) *width
= req
.width
;
722 if (height
) *height
= req
.height
;
727 #endif /* USE_GTK_TOOLTIP */
730 /* Show the tooltip at ROOT_X and ROOT_Y.
731 xg_prepare_tooltip must have been called before this function. */
734 xg_show_tooltip (FRAME_PTR f
, int root_x
, int root_y
)
736 #ifdef USE_GTK_TOOLTIP
737 struct x_output
*x
= f
->output_data
.x
;
741 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
742 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
748 /* Hide tooltip if shown. Do nothing if not shown.
749 Return non-zero if tip was hidden, non-zero if not (i.e. not using
753 xg_hide_tooltip (FRAME_PTR f
)
756 #ifdef USE_GTK_TOOLTIP
757 if (f
->output_data
.x
->ttip_window
)
759 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
761 gtk_widget_hide (GTK_WIDGET (win
));
763 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
765 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
766 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
767 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
768 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
779 /***********************************************************************
780 General functions for creating widgets, resizing, events, e.t.c.
781 ***********************************************************************/
783 /* Make a geometry string and pass that to GTK. It seems this is the
784 only way to get geometry position right if the user explicitly
785 asked for a position when starting Emacs.
786 F is the frame we shall set geometry for. */
789 xg_set_geometry (FRAME_PTR f
)
791 if (f
->size_hint_flags
& (USPosition
| PPosition
))
793 int left
= f
->left_pos
;
794 int xneg
= f
->size_hint_flags
& XNegative
;
795 int top
= f
->top_pos
;
796 int yneg
= f
->size_hint_flags
& YNegative
;
804 sprintf (geom_str
, "=%dx%d%c%d%c%d",
805 FRAME_PIXEL_WIDTH (f
),
806 FRAME_PIXEL_HEIGHT (f
),
807 (xneg
? '-' : '+'), left
,
808 (yneg
? '-' : '+'), top
);
810 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
812 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
816 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
817 and use a GtkFixed widget, this doesn't happen automatically. */
820 xg_clear_under_internal_border (FRAME_PTR f
)
822 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
824 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
825 gtk_widget_queue_draw (wfixed
);
826 gdk_window_process_all_updates ();
827 x_clear_area (FRAME_X_DISPLAY (f
),
830 FRAME_PIXEL_WIDTH (f
),
831 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
832 x_clear_area (FRAME_X_DISPLAY (f
),
835 FRAME_INTERNAL_BORDER_WIDTH (f
),
836 FRAME_PIXEL_HEIGHT (f
), 0);
837 x_clear_area (FRAME_X_DISPLAY (f
),
839 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
840 FRAME_PIXEL_WIDTH (f
),
841 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
842 x_clear_area (FRAME_X_DISPLAY (f
),
844 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
846 FRAME_INTERNAL_BORDER_WIDTH (f
),
847 FRAME_PIXEL_HEIGHT (f
), 0);
851 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
852 and a Gtk+ menu bar, we get resize events for the edit part of the
853 frame only. We let Gtk+ deal with the Gtk+ parts.
854 F is the frame to resize.
855 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
858 xg_frame_resized (FRAME_PTR f
, int pixelwidth
, int pixelheight
)
862 if (pixelwidth
== -1 && pixelheight
== -1)
864 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
865 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
867 &pixelwidth
, &pixelheight
);
872 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
873 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
875 if (columns
!= FRAME_COLS (f
)
876 || rows
!= FRAME_LINES (f
)
877 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
878 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
880 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
881 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
883 xg_clear_under_internal_border (f
);
884 change_frame_size (f
, rows
, columns
, 0, 1, 0);
885 SET_FRAME_GARBAGED (f
);
886 cancel_mouse_face (f
);
890 /* Resize the outer window of frame F after chainging the height.
891 COLUMNS/ROWS is the size the edit area shall have after the resize. */
894 xg_frame_set_char_size (FRAME_PTR f
, int cols
, int rows
)
896 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
897 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
900 if (FRAME_PIXEL_HEIGHT (f
) == 0)
903 /* Take into account the size of the scroll bar. Always use the
904 number of columns occupied by the scroll bar here otherwise we
905 might end up with a frame width that is not a multiple of the
906 frame's character width which is bad for vertically split
908 f
->scroll_bar_actual_width
909 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
911 compute_fringe_widths (f
, 0);
913 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
914 after calculating that value. */
915 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
916 + FRAME_TOOLBAR_WIDTH (f
);
919 /* Do this before resize, as we don't know yet if we will be resized. */
920 xg_clear_under_internal_border (f
);
922 /* Must resize our top level widget. Font size may have changed,
923 but not rows/cols. */
924 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
925 pixelwidth
, pixelheight
);
926 x_wm_set_size_hint (f
, 0, 0);
928 SET_FRAME_GARBAGED (f
);
929 cancel_mouse_face (f
);
931 /* We can not call change_frame_size for a mapped frame,
932 we can not set pixel width/height either. The window manager may
933 override our resize request, XMonad does this all the time.
934 The best we can do is try to sync, so lisp code sees the updated
935 size as fast as possible.
936 For unmapped windows, we can set rows/cols. When
937 the frame is mapped again we will (hopefully) get the correct size. */
938 if (f
->async_visible
)
940 /* Must call this to flush out events */
941 (void)gtk_events_pending ();
943 x_wait_for_event (f
, ConfigureNotify
);
947 change_frame_size (f
, rows
, cols
, 0, 1, 0);
948 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
949 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
953 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
954 The policy is to keep the number of editable lines. */
957 xg_height_or_width_changed (FRAME_PTR f
)
959 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
960 FRAME_TOTAL_PIXEL_WIDTH (f
),
961 FRAME_TOTAL_PIXEL_HEIGHT (f
));
962 f
->output_data
.x
->hint_flags
= 0;
963 x_wm_set_size_hint (f
, 0, 0);
966 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
967 Must be done like this, because GtkWidget:s can have "hidden"
968 X Window that aren't accessible.
970 Return 0 if no widget match WDESC. */
973 xg_win_to_widget (Display
*dpy
, Window wdesc
)
976 GtkWidget
*gwdesc
= 0;
980 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
985 event
.any
.window
= gdkwin
;
986 gwdesc
= gtk_get_event_widget (&event
);
993 /* Set the background of widget W to PIXEL. */
996 xg_set_widget_bg (FRAME_PTR f
, GtkWidget
*w
, long unsigned int pixel
)
1002 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1004 bg
.red
= (double)xbg
.red
/65536.0;
1005 bg
.green
= (double)xbg
.green
/65536.0;
1006 bg
.blue
= (double)xbg
.blue
/65536.0;
1008 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1012 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1013 gdk_colormap_query_color (map
, pixel
, &bg
);
1014 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1018 /* Callback called when the gtk theme changes.
1019 We notify lisp code so it can fix faces used for region for example. */
1022 style_changed_cb (GObject
*go
,
1026 struct input_event event
;
1027 GdkDisplay
*gdpy
= (GdkDisplay
*) user_data
;
1028 const char *display_name
= gdk_display_get_name (gdpy
);
1029 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1032 event
.kind
= CONFIG_CHANGED_EVENT
;
1033 event
.frame_or_window
= build_string (display_name
);
1034 /* Theme doesn't change often, so intern is called seldom. */
1035 event
.arg
= intern ("theme-name");
1036 kbd_buffer_store_event (&event
);
1038 update_theme_scrollbar_width ();
1040 /* If scroll bar width changed, we need set the new size on all frames
1044 Lisp_Object rest
, frame
;
1045 FOR_EACH_FRAME (rest
, frame
)
1047 FRAME_PTR f
= XFRAME (frame
);
1048 if (FRAME_X_DISPLAY (f
) == dpy
)
1050 x_set_scroll_bar_default_width (f
);
1051 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
1057 /* Called when a delete-event occurs on WIDGET. */
1060 delete_cb (GtkWidget
*widget
,
1065 /* The event doesn't arrive in the normal event loop. Send event
1067 FRAME_PTR f
= (FRAME_PTR
) user_data
;
1068 struct input_event ie
;
1071 ie
.kind
= DELETE_WINDOW_EVENT
;
1072 XSETFRAME (ie
.frame_or_window
, f
);
1073 kbd_buffer_store_event (&ie
);
1079 /* Create and set up the GTK widgets for frame F.
1080 Return 0 if creation failed, non-zero otherwise. */
1083 xg_create_frame_widgets (FRAME_PTR f
)
1086 GtkWidget
*wvbox
, *whbox
;
1093 if (FRAME_X_EMBEDDED_P (f
))
1094 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
1096 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1098 xg_set_screen (wtop
, f
);
1100 wvbox
= gtk_vbox_new (FALSE
, 0);
1101 whbox
= gtk_hbox_new (FALSE
, 0);
1104 wfixed
= emacs_fixed_new (f
);
1106 wfixed
= gtk_fixed_new ();
1109 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1111 if (wtop
) gtk_widget_destroy (wtop
);
1112 if (wvbox
) gtk_widget_destroy (wvbox
);
1113 if (whbox
) gtk_widget_destroy (whbox
);
1114 if (wfixed
) gtk_widget_destroy (wfixed
);
1120 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1121 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1122 gtk_widget_set_name (wvbox
, "pane");
1123 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1125 /* If this frame has a title or name, set it in the title bar. */
1126 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1127 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1129 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1131 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1132 FRAME_GTK_WIDGET (f
) = wfixed
;
1133 f
->output_data
.x
->vbox_widget
= wvbox
;
1134 f
->output_data
.x
->hbox_widget
= whbox
;
1136 gtk_widget_set_has_window (wfixed
, TRUE
);
1138 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1139 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1140 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1142 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1143 update_frame_tool_bar (f
);
1145 /* We don't want this widget double buffered, because we draw on it
1146 with regular X drawing primitives, so from a GTK/GDK point of
1147 view, the widget is totally blank. When an expose comes, this
1148 will make the widget blank, and then Emacs redraws it. This flickers
1149 a lot, so we turn off double buffering. */
1150 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1152 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1153 SSDATA (Vx_resource_name
),
1154 SSDATA (Vx_resource_class
));
1156 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1157 GTK is to destroy the widget. We want Emacs to do that instead. */
1158 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1159 G_CALLBACK (delete_cb
), f
);
1161 /* Convert our geometry parameters into a geometry string
1163 GTK will itself handle calculating the real position this way. */
1164 xg_set_geometry (f
);
1166 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1168 gtk_widget_add_events (wfixed
,
1169 GDK_POINTER_MOTION_MASK
1171 | GDK_BUTTON_PRESS_MASK
1172 | GDK_BUTTON_RELEASE_MASK
1173 | GDK_KEY_PRESS_MASK
1174 | GDK_ENTER_NOTIFY_MASK
1175 | GDK_LEAVE_NOTIFY_MASK
1176 | GDK_FOCUS_CHANGE_MASK
1177 | GDK_STRUCTURE_MASK
1178 | GDK_VISIBILITY_NOTIFY_MASK
);
1180 /* Must realize the windows so the X window gets created. It is used
1181 by callers of this function. */
1182 gtk_widget_realize (wfixed
);
1183 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1185 /* Since GTK clears its window by filling with the background color,
1186 we must keep X and GTK background in sync. */
1187 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1190 /* Also, do not let any background pixmap to be set, this looks very
1191 bad as Emacs overwrites the background pixmap with its own idea
1192 of background color. */
1193 style
= gtk_widget_get_modifier_style (wfixed
);
1195 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1196 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1197 gtk_widget_modify_style (wfixed
, style
);
1199 gtk_widget_set_can_focus (wfixed
, TRUE
);
1200 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1203 #ifdef USE_GTK_TOOLTIP
1204 /* Steal a tool tip window we can move ourselves. */
1205 f
->output_data
.x
->ttip_widget
= 0;
1206 f
->output_data
.x
->ttip_lbl
= 0;
1207 f
->output_data
.x
->ttip_window
= 0;
1208 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1209 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1213 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1214 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1215 /* Only connect this signal once per screen. */
1216 if (! g_signal_handler_find (G_OBJECT (gs
),
1217 G_SIGNAL_MATCH_FUNC
,
1219 G_CALLBACK (style_changed_cb
),
1222 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1223 G_CALLBACK (style_changed_cb
),
1224 gdk_screen_get_display (screen
));
1234 xg_free_frame_widgets (FRAME_PTR f
)
1236 if (FRAME_GTK_OUTER_WIDGET (f
))
1238 #ifdef USE_GTK_TOOLTIP
1239 struct x_output
*x
= f
->output_data
.x
;
1241 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1242 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1243 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1244 #ifdef USE_GTK_TOOLTIP
1246 gtk_widget_destroy (x
->ttip_lbl
);
1248 g_object_unref (G_OBJECT (x
->ttip_widget
));
1253 /* Set the normal size hints for the window manager, for frame F.
1254 FLAGS is the flags word to use--or 0 meaning preserve the flags
1255 that the window now has.
1256 If USER_POSITION is nonzero, we set the User Position
1257 flag (this is useful when FLAGS is 0). */
1260 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
1262 /* Must use GTK routines here, otherwise GTK resets the size hints
1263 to its own defaults. */
1264 GdkGeometry size_hints
;
1265 gint hint_flags
= 0;
1266 int base_width
, base_height
;
1267 int min_rows
= 0, min_cols
= 0;
1268 int win_gravity
= f
->win_gravity
;
1270 /* Don't set size hints during initialization; that apparently leads
1271 to a race condition. See the thread at
1272 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1273 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1278 memset (&size_hints
, 0, sizeof (size_hints
));
1279 f
->output_data
.x
->size_hints
= size_hints
;
1280 f
->output_data
.x
->hint_flags
= hint_flags
;
1283 flags
= f
->size_hint_flags
;
1285 size_hints
= f
->output_data
.x
->size_hints
;
1286 hint_flags
= f
->output_data
.x
->hint_flags
;
1288 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1289 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1290 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1292 hint_flags
|= GDK_HINT_BASE_SIZE
;
1293 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0) + FRAME_TOOLBAR_WIDTH (f
);
1294 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
1295 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1297 check_frame_size (f
, &min_rows
, &min_cols
);
1299 size_hints
.base_width
= base_width
;
1300 size_hints
.base_height
= base_height
;
1301 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1302 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1304 /* These currently have a one to one mapping with the X values, but I
1305 don't think we should rely on that. */
1306 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1307 size_hints
.win_gravity
= 0;
1308 if (win_gravity
== NorthWestGravity
)
1309 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1310 else if (win_gravity
== NorthGravity
)
1311 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1312 else if (win_gravity
== NorthEastGravity
)
1313 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1314 else if (win_gravity
== WestGravity
)
1315 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1316 else if (win_gravity
== CenterGravity
)
1317 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1318 else if (win_gravity
== EastGravity
)
1319 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1320 else if (win_gravity
== SouthWestGravity
)
1321 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1322 else if (win_gravity
== SouthGravity
)
1323 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1324 else if (win_gravity
== SouthEastGravity
)
1325 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1326 else if (win_gravity
== StaticGravity
)
1327 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1331 hint_flags
&= ~GDK_HINT_POS
;
1332 hint_flags
|= GDK_HINT_USER_POS
;
1335 if (hint_flags
!= f
->output_data
.x
->hint_flags
1336 || memcmp (&size_hints
,
1337 &f
->output_data
.x
->size_hints
,
1338 sizeof (size_hints
)) != 0)
1341 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1342 NULL
, &size_hints
, hint_flags
);
1343 f
->output_data
.x
->size_hints
= size_hints
;
1344 f
->output_data
.x
->hint_flags
= hint_flags
;
1349 /* Change background color of a frame.
1350 Since GTK uses the background color to clear the window, we must
1351 keep the GTK and X colors in sync.
1352 F is the frame to change,
1353 BG is the pixel value to change to. */
1356 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
1358 if (FRAME_GTK_WIDGET (f
))
1361 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1367 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1368 functions so GTK does not overwrite the icon. */
1371 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1373 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1377 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1382 /***********************************************************************
1384 ***********************************************************************/
1385 /* Return the dialog title to use for a dialog of type KEY.
1386 This is the encoding used by lwlib. We use the same for GTK. */
1389 get_dialog_title (char key
)
1391 const char *title
= "";
1399 title
= "Information";
1418 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1419 the dialog, but return TRUE so the event does not propagate further
1420 in GTK. This prevents GTK from destroying the dialog widget automatically
1421 and we can always destrou the widget manually, regardles of how
1422 it was popped down (button press or WM_DELETE_WINDOW).
1423 W is the dialog widget.
1424 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1425 user_data is NULL (not used).
1427 Returns TRUE to end propagation of event. */
1430 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1432 gtk_widget_unmap (w
);
1436 /* Create a popup dialog window. See also xg_create_widget below.
1437 WV is a widget_value describing the dialog.
1438 SELECT_CB is the callback to use when a button has been pressed.
1439 DEACTIVATE_CB is the callback to use when the dialog pops down.
1441 Returns the GTK dialog widget. */
1444 create_dialog (widget_value
*wv
,
1445 GCallback select_cb
,
1446 GCallback deactivate_cb
)
1448 const char *title
= get_dialog_title (wv
->name
[0]);
1449 int total_buttons
= wv
->name
[1] - '0';
1450 int right_buttons
= wv
->name
[4] - '0';
1453 int button_spacing
= 10;
1454 GtkWidget
*wdialog
= gtk_dialog_new ();
1455 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1456 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1458 GtkWidget
*whbox_down
;
1460 /* If the number of buttons is greater than 4, make two rows of buttons
1461 instead. This looks better. */
1462 int make_two_rows
= total_buttons
> 4;
1464 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1465 left_buttons
= total_buttons
- right_buttons
;
1467 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1468 gtk_widget_set_name (wdialog
, "emacs-dialog");
1473 GtkWidget
*wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1474 GtkWidget
*whbox_up
= gtk_hbox_new (FALSE
, 0);
1475 whbox_down
= gtk_hbox_new (FALSE
, 0);
1477 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1478 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1479 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1481 cur_box
= GTK_BOX (whbox_up
);
1484 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1485 G_CALLBACK (dialog_delete_callback
), 0);
1489 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1490 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1493 for (item
= wv
->contents
; item
; item
= item
->next
)
1495 char *utf8_label
= get_utf8_string (item
->value
);
1499 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1501 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1502 /* This is the text part of the dialog. */
1503 w
= gtk_label_new (utf8_label
);
1504 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1505 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1506 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1508 /* Try to make dialog look better. Must realize first so
1509 the widget can calculate the size it needs. */
1510 gtk_widget_realize (w
);
1511 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1512 gtk_box_set_spacing (wvbox
, req
.height
);
1513 if (item
->value
&& strlen (item
->value
) > 0)
1514 button_spacing
= 2*req
.width
/strlen (item
->value
);
1518 /* This is one button to add to the dialog. */
1519 w
= gtk_button_new_with_label (utf8_label
);
1520 if (! item
->enabled
)
1521 gtk_widget_set_sensitive (w
, FALSE
);
1523 g_signal_connect (G_OBJECT (w
), "clicked",
1524 select_cb
, item
->call_data
);
1526 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1527 if (++button_nr
== left_buttons
)
1530 cur_box
= GTK_BOX (whbox_down
);
1532 gtk_box_pack_start (cur_box
,
1540 g_free (utf8_label
);
1546 struct xg_dialog_data
1554 /* Function that is called when the file or font dialogs pop down.
1555 W is the dialog widget, RESPONSE is the response code.
1556 USER_DATA is what we passed in to g_signal_connect. */
1559 xg_dialog_response_cb (GtkDialog
*w
,
1563 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1564 dd
->response
= response
;
1565 g_main_loop_quit (dd
->loop
);
1569 /* Destroy the dialog. This makes it pop down. */
1572 pop_down_dialog (Lisp_Object arg
)
1574 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1575 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1578 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1579 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1581 g_main_loop_quit (dd
->loop
);
1582 g_main_loop_unref (dd
->loop
);
1589 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1590 We pass in DATA as gpointer* so we can use this as a callback. */
1593 xg_maybe_add_timer (gpointer data
)
1595 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1596 EMACS_TIME next_time
= timer_check ();
1597 long secs
= EMACS_SECS (next_time
);
1598 long usecs
= EMACS_USECS (next_time
);
1602 if (secs
>= 0 && usecs
>= 0 && secs
< ((guint
)-1)/1000)
1604 dd
->timerid
= g_timeout_add (secs
* 1000 + usecs
/1000,
1612 /* Pops up a modal dialog W and waits for response.
1613 We don't use gtk_dialog_run because we want to process emacs timers.
1614 The dialog W is not destroyed when this function returns. */
1617 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1619 int count
= SPECPDL_INDEX ();
1620 struct xg_dialog_data dd
;
1622 xg_set_screen (w
, f
);
1623 gtk_window_set_transient_for (GTK_WINDOW (w
),
1624 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1625 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1626 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1628 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1629 dd
.response
= GTK_RESPONSE_CANCEL
;
1633 g_signal_connect (G_OBJECT (w
),
1635 G_CALLBACK (xg_dialog_response_cb
),
1637 /* Don't destroy the widget if closed by the window manager close button. */
1638 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1639 gtk_widget_show (w
);
1641 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1643 (void) xg_maybe_add_timer (&dd
);
1644 g_main_loop_run (dd
.loop
);
1647 unbind_to (count
, Qnil
);
1653 /***********************************************************************
1654 File dialog functions
1655 ***********************************************************************/
1656 /* Return non-zero if the old file selection dialog is being used.
1657 Return zero if not. */
1660 xg_uses_old_file_dialog (void)
1662 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1663 return x_gtk_use_old_file_dialog
;
1670 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1672 /* Return the selected file for file chooser dialog W.
1673 The returned string must be free:d. */
1676 xg_get_file_name_from_chooser (GtkWidget
*w
)
1678 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1681 /* Callback called when the "Show hidden files" toggle is pressed.
1682 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1685 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1687 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1689 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1690 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1694 /* Callback called when a property changes in a file chooser.
1695 GOBJECT is the file chooser dialog, ARG1 describes the property.
1696 USER_DATA is the toggle widget in the file chooser dialog.
1697 We use this to update the "Show hidden files" toggle when the user
1698 changes that property by right clicking in the file list. */
1701 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1703 if (strcmp (arg1
->name
, "show-hidden") == 0)
1705 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1706 gboolean visible
, toggle_on
;
1708 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1709 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1711 if (!!visible
!= !!toggle_on
)
1713 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1714 G_CALLBACK (xg_toggle_visibility_cb
),
1716 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1717 g_signal_handlers_unblock_by_func
1718 (G_OBJECT (wtoggle
),
1719 G_CALLBACK (xg_toggle_visibility_cb
),
1722 x_gtk_show_hidden_files
= visible
;
1726 /* Read a file name from the user using a file chooser dialog.
1727 F is the current frame.
1728 PROMPT is a prompt to show to the user. May not be NULL.
1729 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1730 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1731 file. *FUNC is set to a function that can be used to retrieve the
1732 selected file name from the returned widget.
1734 Returns the created widget. */
1737 xg_get_file_with_chooser (FRAME_PTR f
,
1739 char *default_filename
,
1740 int mustmatch_p
, int only_dir_p
,
1741 xg_get_file_func
*func
)
1745 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1746 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1747 GtkFileChooserAction action
= (mustmatch_p
?
1748 GTK_FILE_CHOOSER_ACTION_OPEN
:
1749 GTK_FILE_CHOOSER_ACTION_SAVE
);
1752 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1754 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1755 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1756 (mustmatch_p
|| only_dir_p
?
1757 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1760 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1762 wbox
= gtk_vbox_new (FALSE
, 0);
1763 gtk_widget_show (wbox
);
1764 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1766 if (x_gtk_show_hidden_files
)
1768 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1769 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1771 gtk_widget_show (wtoggle
);
1772 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1773 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1774 g_signal_connect (G_OBJECT (filewin
), "notify",
1775 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1777 if (x_gtk_file_dialog_help_text
)
1780 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1781 Show the C-l help text only for versions < 2.10. */
1782 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1783 strcat (msgbuf
, "\nType C-l to display a file name text entry box.\n");
1784 strcat (msgbuf
, "\nIf you don't like this file selector, use the "
1785 "corresponding\nkey binding or customize "
1786 "use-file-dialog to turn it off.");
1788 wmessage
= gtk_label_new (msgbuf
);
1789 gtk_widget_show (wmessage
);
1792 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1793 if (x_gtk_file_dialog_help_text
)
1794 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1795 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1797 if (default_filename
)
1800 struct gcpro gcpro1
;
1801 char *utf8_filename
;
1804 file
= build_string (default_filename
);
1806 /* File chooser does not understand ~/... in the file name. It must be
1807 an absolute name starting with /. */
1808 if (default_filename
[0] != '/')
1809 file
= Fexpand_file_name (file
, Qnil
);
1811 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1812 if (! NILP (Ffile_directory_p (file
)))
1813 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1817 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1819 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1821 char *cp
= strrchr (utf8_filename
, '/');
1823 else cp
= utf8_filename
;
1824 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1831 *func
= xg_get_file_name_from_chooser
;
1835 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1837 /* Return the selected file for file selector dialog W.
1838 The returned string must be free:d. */
1841 xg_get_file_name_from_selector (GtkWidget
*w
)
1843 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1844 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1847 /* Create a file selection dialog.
1848 F is the current frame.
1849 PROMPT is a prompt to show to the user. May not be NULL.
1850 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1851 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1852 file. *FUNC is set to a function that can be used to retrieve the
1853 selected file name from the returned widget.
1855 Returns the created widget. */
1858 xg_get_file_with_selection (FRAME_PTR f
,
1860 char *default_filename
,
1861 int mustmatch_p
, int only_dir_p
,
1862 xg_get_file_func
*func
)
1865 GtkFileSelection
*filesel
;
1867 filewin
= gtk_file_selection_new (prompt
);
1868 filesel
= GTK_FILE_SELECTION (filewin
);
1870 if (default_filename
)
1871 gtk_file_selection_set_filename (filesel
, default_filename
);
1875 /* The selection_entry part of filesel is not documented. */
1876 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1877 gtk_file_selection_hide_fileop_buttons (filesel
);
1880 *func
= xg_get_file_name_from_selector
;
1884 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1886 /* Read a file name from the user using a file dialog, either the old
1887 file selection dialog, or the new file chooser dialog. Which to use
1888 depends on what the GTK version used has, and what the value of
1889 gtk-use-old-file-dialog.
1890 F is the current frame.
1891 PROMPT is a prompt to show to the user. May not be NULL.
1892 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1893 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1896 Returns a file name or NULL if no file was selected.
1897 The returned string must be freed by the caller. */
1900 xg_get_file_name (FRAME_PTR f
,
1902 char *default_filename
,
1908 int filesel_done
= 0;
1909 xg_get_file_func func
;
1911 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1912 /* I really don't know why this is needed, but without this the GLIBC add on
1913 library linuxthreads hangs when the Gnome file chooser backend creates
1915 sigblock (sigmask (__SIGRTMIN
));
1916 #endif /* HAVE_GTK_AND_PTHREAD */
1918 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1920 if (xg_uses_old_file_dialog ())
1921 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1922 mustmatch_p
, only_dir_p
, &func
);
1924 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1925 mustmatch_p
, only_dir_p
, &func
);
1927 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1928 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1929 mustmatch_p
, only_dir_p
, &func
);
1930 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1932 gtk_widget_set_name (w
, "emacs-filedialog");
1934 filesel_done
= xg_dialog_run (f
, w
);
1936 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1937 sigunblock (sigmask (__SIGRTMIN
));
1940 if (filesel_done
== GTK_RESPONSE_OK
)
1943 gtk_widget_destroy (w
);
1947 #ifdef HAVE_FREETYPE
1948 /* Pop up a GTK font selector and return the name of the font the user
1949 selects, as a C string. The returned font name follows GTK's own
1952 `FAMILY [VALUE1 VALUE2] SIZE'
1954 This can be parsed using font_parse_fcname in font.c.
1955 DEFAULT_NAME, if non-zero, is the default font name. */
1958 xg_get_font_name (FRAME_PTR f
, const char *default_name
)
1961 char *fontname
= NULL
;
1964 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1965 sigblock (sigmask (__SIGRTMIN
));
1966 #endif /* HAVE_GTK_AND_PTHREAD */
1968 w
= gtk_font_selection_dialog_new ("Pick a font");
1970 default_name
= "Monospace 10";
1971 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1974 gtk_widget_set_name (w
, "emacs-fontdialog");
1976 done
= xg_dialog_run (f
, w
);
1978 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1979 sigunblock (sigmask (__SIGRTMIN
));
1982 if (done
== GTK_RESPONSE_OK
)
1983 fontname
= gtk_font_selection_dialog_get_font_name
1984 (GTK_FONT_SELECTION_DIALOG (w
));
1986 gtk_widget_destroy (w
);
1989 #endif /* HAVE_FREETYPE */
1993 /***********************************************************************
1995 ***********************************************************************/
1997 /* The name of menu items that can be used for customization. Since GTK
1998 RC files are very crude and primitive, we have to set this on all
1999 menu item names so a user can easily customize menu items. */
2001 #define MENU_ITEM_NAME "emacs-menuitem"
2004 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2005 during GC. The next member points to the items. */
2006 static xg_list_node xg_menu_cb_list
;
2008 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2009 during GC. The next member points to the items. */
2010 static xg_list_node xg_menu_item_cb_list
;
2012 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2013 F is the frame CL_DATA will be initialized for.
2014 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2016 The menu bar and all sub menus under the menu bar in a frame
2017 share the same structure, hence the reference count.
2019 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2020 allocated xg_menu_cb_data if CL_DATA is NULL. */
2022 static xg_menu_cb_data
*
2023 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
2027 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
2029 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2030 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2031 cl_data
->highlight_cb
= highlight_cb
;
2032 cl_data
->ref_count
= 0;
2034 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2037 cl_data
->ref_count
++;
2042 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2043 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2045 When the menu bar is updated, menu items may have been added and/or
2046 removed, so menu_bar_vector and menu_bar_items_used change. We must
2047 then update CL_DATA since it is used to determine which menu
2048 item that is invoked in the menu.
2049 HIGHLIGHT_CB could change, there is no check that the same
2050 function is given when modifying a menu bar as was given when
2051 creating the menu bar. */
2054 update_cl_data (xg_menu_cb_data
*cl_data
,
2056 GCallback highlight_cb
)
2061 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2062 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2063 cl_data
->highlight_cb
= highlight_cb
;
2067 /* Decrease reference count for CL_DATA.
2068 If reference count is zero, free CL_DATA. */
2071 unref_cl_data (xg_menu_cb_data
*cl_data
)
2073 if (cl_data
&& cl_data
->ref_count
> 0)
2075 cl_data
->ref_count
--;
2076 if (cl_data
->ref_count
== 0)
2078 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2084 /* Function that marks all lisp data during GC. */
2091 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2092 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2094 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2096 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2098 if (! NILP (cb_data
->help
))
2099 mark_object (cb_data
->help
);
2104 /* Callback called when a menu item is destroyed. Used to free data.
2105 W is the widget that is being destroyed (not used).
2106 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2109 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2113 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
2114 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2119 /* Callback called when the pointer enters/leaves a menu item.
2120 W is the parent of the menu item.
2121 EVENT is either an enter event or leave event.
2122 CLIENT_DATA is not used.
2124 Returns FALSE to tell GTK to keep processing this event. */
2127 menuitem_highlight_callback (GtkWidget
*w
,
2128 GdkEventCrossing
*event
,
2129 gpointer client_data
)
2132 GtkWidget
*subwidget
;
2133 xg_menu_item_cb_data
*data
;
2135 ev
.crossing
= *event
;
2136 subwidget
= gtk_get_event_widget (&ev
);
2137 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
2141 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2143 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2144 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2145 (*func
) (subwidget
, call_data
);
2152 /* Callback called when a menu is destroyed. Used to free data.
2153 W is the widget that is being destroyed (not used).
2154 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2157 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2159 unref_cl_data ((xg_menu_cb_data
*) client_data
);
2162 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2163 must be non-NULL) and can be inserted into a menu item.
2165 Returns the GtkHBox. */
2168 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2174 wbox
= gtk_hbox_new (FALSE
, 0);
2175 wlbl
= gtk_label_new (utf8_label
);
2176 wkey
= gtk_label_new (utf8_key
);
2178 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2179 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2181 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2182 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2184 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2185 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2186 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2191 /* Make and return a menu item widget with the key to the right.
2192 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2193 UTF8_KEY is the text representing the key binding.
2194 ITEM is the widget_value describing the menu item.
2196 GROUP is an in/out parameter. If the menu item to be created is not
2197 part of any radio menu group, *GROUP contains NULL on entry and exit.
2198 If the menu item to be created is part of a radio menu group, on entry
2199 *GROUP contains the group to use, or NULL if this is the first item
2200 in the group. On exit, *GROUP contains the radio item group.
2202 Unfortunately, keys don't line up as nicely as in Motif,
2203 but the MacOS X version doesn't either, so I guess that is OK. */
2206 make_menu_item (const char *utf8_label
,
2207 const char *utf8_key
,
2212 GtkWidget
*wtoadd
= 0;
2214 /* It has been observed that some menu items have a NULL name field.
2215 This will lead to this function being called with a NULL utf8_label.
2216 GTK crashes on that so we set a blank label. Why there is a NULL
2217 name remains to be investigated. */
2218 if (! utf8_label
) utf8_label
= " ";
2221 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2223 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2226 if (utf8_key
) w
= gtk_check_menu_item_new ();
2227 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2228 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2230 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2232 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2233 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2234 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2236 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2241 if (utf8_key
) w
= gtk_menu_item_new ();
2242 else w
= gtk_menu_item_new_with_label (utf8_label
);
2245 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2246 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2251 static int xg_detached_menus
;
2253 /* Returns non-zero if there are detached menus. */
2256 xg_have_tear_offs (void)
2258 return xg_detached_menus
> 0;
2261 /* Callback invoked when a detached menu window is removed. Here we
2262 decrease the xg_detached_menus count.
2263 WIDGET is the top level window that is removed (the parent of the menu).
2264 CLIENT_DATA is not used. */
2267 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2269 if (xg_detached_menus
> 0) --xg_detached_menus
;
2272 /* Callback invoked when a menu is detached. It increases the
2273 xg_detached_menus count.
2274 WIDGET is the GtkTearoffMenuItem.
2275 CLIENT_DATA is not used. */
2278 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2280 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2281 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2283 ++xg_detached_menus
;
2284 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2286 G_CALLBACK (tearoff_remove
), 0);
2291 /* Create a menu item widget, and connect the callbacks.
2292 ITEM decribes the menu item.
2293 F is the frame the created menu belongs to.
2294 SELECT_CB is the callback to use when a menu item is selected.
2295 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2296 CL_DATA points to the callback data to be used for this menu.
2297 GROUP is an in/out parameter. If the menu item to be created is not
2298 part of any radio menu group, *GROUP contains NULL on entry and exit.
2299 If the menu item to be created is part of a radio menu group, on entry
2300 *GROUP contains the group to use, or NULL if this is the first item
2301 in the group. On exit, *GROUP contains the radio item group.
2303 Returns the created GtkWidget. */
2306 xg_create_one_menuitem (widget_value
*item
,
2308 GCallback select_cb
,
2309 GCallback highlight_cb
,
2310 xg_menu_cb_data
*cl_data
,
2316 xg_menu_item_cb_data
*cb_data
;
2318 utf8_label
= get_utf8_string (item
->name
);
2319 utf8_key
= get_utf8_string (item
->key
);
2321 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2323 if (utf8_label
) g_free (utf8_label
);
2324 if (utf8_key
) g_free (utf8_key
);
2326 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2328 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2330 cb_data
->select_id
= 0;
2331 cb_data
->help
= item
->help
;
2332 cb_data
->cl_data
= cl_data
;
2333 cb_data
->call_data
= item
->call_data
;
2335 g_signal_connect (G_OBJECT (w
),
2337 G_CALLBACK (menuitem_destroy_callback
),
2340 /* Put cb_data in widget, so we can get at it when modifying menubar */
2341 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2343 /* final item, not a submenu */
2344 if (item
->call_data
&& ! item
->contents
)
2348 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2354 /* Create a full menu tree specified by DATA.
2355 F is the frame the created menu belongs to.
2356 SELECT_CB is the callback to use when a menu item is selected.
2357 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2358 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2359 POP_UP_P is non-zero if we shall create a popup menu.
2360 MENU_BAR_P is non-zero if we shall create a menu bar.
2361 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2362 if MENU_BAR_P is non-zero.
2363 TOPMENU is the topmost GtkWidget that others shall be placed under.
2364 It may be NULL, in that case we create the appropriate widget
2365 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2366 CL_DATA is the callback data we shall use for this menu, or NULL
2367 if we haven't set the first callback yet.
2368 NAME is the name to give to the top level menu if this function
2369 creates it. May be NULL to not set any name.
2371 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2374 This function calls itself to create submenus. */
2377 create_menus (widget_value
*data
,
2379 GCallback select_cb
,
2380 GCallback deactivate_cb
,
2381 GCallback highlight_cb
,
2386 xg_menu_cb_data
*cl_data
,
2390 GtkWidget
*wmenu
= topmenu
;
2391 GSList
*group
= NULL
;
2397 wmenu
= gtk_menu_new ();
2398 xg_set_screen (wmenu
, f
);
2399 /* Connect this to the menu instead of items so we get enter/leave for
2400 disabled items also. TODO: Still does not get enter/leave for
2401 disabled items in detached menus. */
2402 g_signal_connect (G_OBJECT (wmenu
),
2403 "enter-notify-event",
2404 G_CALLBACK (menuitem_highlight_callback
),
2406 g_signal_connect (G_OBJECT (wmenu
),
2407 "leave-notify-event",
2408 G_CALLBACK (menuitem_highlight_callback
),
2413 wmenu
= gtk_menu_bar_new ();
2414 /* Set width of menu bar to a small value so it doesn't enlarge
2415 a small initial frame size. The width will be set to the
2416 width of the frame later on when it is added to a container.
2417 height -1: Natural height. */
2418 gtk_widget_set_size_request (wmenu
, 1, -1);
2421 /* Put cl_data on the top menu for easier access. */
2422 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2423 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2424 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2425 G_CALLBACK (menu_destroy_callback
), cl_data
);
2428 gtk_widget_set_name (wmenu
, name
);
2431 g_signal_connect (G_OBJECT (wmenu
),
2432 "selection-done", deactivate_cb
, 0);
2435 if (! menu_bar_p
&& add_tearoff_p
)
2437 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2438 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2440 g_signal_connect (G_OBJECT (tearoff
), "activate",
2441 G_CALLBACK (tearoff_activate
), 0);
2444 for (item
= data
; item
; item
= item
->next
)
2448 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2449 && !menu_separator_name_p (item
->name
))
2452 /* A title for a popup. We do the same as GTK does when
2453 creating titles, but it does not look good. */
2455 utf8_label
= get_utf8_string (item
->name
);
2457 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2458 w
= gtk_menu_item_new_with_label (utf8_label
);
2459 gtk_widget_set_sensitive (w
, FALSE
);
2460 if (utf8_label
) g_free (utf8_label
);
2462 else if (menu_separator_name_p (item
->name
))
2465 /* GTK only have one separator type. */
2466 w
= gtk_separator_menu_item_new ();
2470 w
= xg_create_one_menuitem (item
,
2472 item
->contents
? 0 : select_cb
,
2477 /* Create a possibly empty submenu for menu bar items, since some
2478 themes don't highlight items correctly without it. */
2479 if (item
->contents
|| menu_bar_p
)
2481 GtkWidget
*submenu
= create_menus (item
->contents
,
2492 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2496 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2497 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2503 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2504 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2505 with some text and buttons.
2506 F is the frame the created item belongs to.
2507 NAME is the name to use for the top widget.
2508 VAL is a widget_value structure describing items to be created.
2509 SELECT_CB is the callback to use when a menu item is selected or
2510 a dialog button is pressed.
2511 DEACTIVATE_CB is the callback to use when an item is deactivated.
2512 For a menu, when a sub menu is not shown anymore, for a dialog it is
2513 called when the dialog is popped down.
2514 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2516 Returns the widget created. */
2519 xg_create_widget (const char *type
, const char *name
, FRAME_PTR f
, widget_value
*val
,
2520 GCallback select_cb
, GCallback deactivate_cb
,
2521 GCallback highlight_cb
)
2524 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2525 int pop_up_p
= strcmp (type
, "popup") == 0;
2527 if (strcmp (type
, "dialog") == 0)
2529 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2530 xg_set_screen (w
, f
);
2531 gtk_window_set_transient_for (GTK_WINDOW (w
),
2532 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2533 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2534 gtk_widget_set_name (w
, "emacs-dialog");
2535 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2537 else if (menu_bar_p
|| pop_up_p
)
2539 w
= create_menus (val
->contents
,
2551 /* Set the cursor to an arrow for popup menus when they are mapped.
2552 This is done by default for menu bar menus. */
2555 /* Must realize so the GdkWindow inside the widget is created. */
2556 gtk_widget_realize (w
);
2557 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2562 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2569 /* Return the label for menu item WITEM. */
2572 xg_get_menu_item_label (GtkMenuItem
*witem
)
2574 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2575 return gtk_label_get_label (wlabel
);
2578 /* Return non-zero if the menu item WITEM has the text LABEL. */
2581 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2584 char *utf8_label
= get_utf8_string (label
);
2585 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2587 if (! old_label
&& ! utf8_label
)
2589 else if (old_label
&& utf8_label
)
2590 is_same
= strcmp (utf8_label
, old_label
) == 0;
2592 if (utf8_label
) g_free (utf8_label
);
2597 /* Destroy widgets in LIST. */
2600 xg_destroy_widgets (GList
*list
)
2604 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2606 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2608 /* Destroying the widget will remove it from the container it is in. */
2609 gtk_widget_destroy (w
);
2613 /* Update the top level names in MENUBAR (i.e. not submenus).
2614 F is the frame the menu bar belongs to.
2615 *LIST is a list with the current menu bar names (menu item widgets).
2616 ITER is the item within *LIST that shall be updated.
2617 POS is the numerical position, starting at 0, of ITER in *LIST.
2618 VAL describes what the menu bar shall look like after the update.
2619 SELECT_CB is the callback to use when a menu item is selected.
2620 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2621 CL_DATA points to the callback data to be used for this menu bar.
2623 This function calls itself to walk through the menu bar names. */
2626 xg_update_menubar (GtkWidget
*menubar
,
2632 GCallback select_cb
,
2633 GCallback deactivate_cb
,
2634 GCallback highlight_cb
,
2635 xg_menu_cb_data
*cl_data
)
2637 if (! iter
&& ! val
)
2639 else if (iter
&& ! val
)
2641 /* Item(s) have been removed. Remove all remaining items. */
2642 xg_destroy_widgets (iter
);
2644 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2645 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2646 gtk_menu_item_new_with_label (""),
2652 else if (! iter
&& val
)
2654 /* Item(s) added. Add all new items in one call. */
2655 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2656 0, 1, 0, menubar
, cl_data
, 0);
2662 /* Below this neither iter or val is NULL */
2663 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2665 /* This item is still the same, check next item. */
2667 iter
= g_list_next (iter
);
2670 else /* This item is changed. */
2672 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2673 GtkMenuItem
*witem2
= 0;
2674 int val_in_menubar
= 0;
2675 int iter_in_new_menubar
= 0;
2679 /* See if the changed entry (val) is present later in the menu bar */
2681 iter2
&& ! val_in_menubar
;
2682 iter2
= g_list_next (iter2
))
2684 witem2
= GTK_MENU_ITEM (iter2
->data
);
2685 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2688 /* See if the current entry (iter) is present later in the
2689 specification for the new menu bar. */
2690 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2691 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2693 if (val_in_menubar
&& ! iter_in_new_menubar
)
2697 /* This corresponds to:
2702 g_object_ref (G_OBJECT (witem
));
2703 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2704 gtk_widget_destroy (GTK_WIDGET (witem
));
2706 /* Must get new list since the old changed. */
2707 g_list_free (*list
);
2708 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2709 while (nr
-- > 0) iter
= g_list_next (iter
);
2711 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2713 /* This corresponds to:
2716 Rename B to X. This might seem to be a strange thing to do,
2717 since if there is a menu under B it will be totally wrong for X.
2718 But consider editing a C file. Then there is a C-mode menu
2719 (corresponds to B above).
2720 If then doing C-x C-f the minibuf menu (X above) replaces the
2721 C-mode menu. When returning from the minibuffer, we get
2722 back the C-mode menu. Thus we do:
2723 Rename B to X (C-mode to minibuf menu)
2724 Rename X to B (minibuf to C-mode menu).
2725 If the X menu hasn't been invoked, the menu under B
2726 is up to date when leaving the minibuffer. */
2727 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2728 char *utf8_label
= get_utf8_string (val
->name
);
2729 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2731 gtk_label_set_text (wlabel
, utf8_label
);
2733 /* If this item has a submenu that has been detached, change
2734 the title in the WM decorations also. */
2735 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2736 /* Set the title of the detached window. */
2737 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2739 if (utf8_label
) g_free (utf8_label
);
2740 iter
= g_list_next (iter
);
2744 else if (! val_in_menubar
&& iter_in_new_menubar
)
2746 /* This corresponds to:
2753 GtkWidget
*w
= xg_create_one_menuitem (val
,
2760 /* Create a possibly empty submenu for menu bar items, since some
2761 themes don't highlight items correctly without it. */
2762 GtkWidget
*submenu
= create_menus (NULL
, f
,
2763 select_cb
, deactivate_cb
,
2765 0, 0, 0, 0, cl_data
, 0);
2766 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2767 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2768 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2770 g_list_free (*list
);
2771 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2772 while (nr
-- > 0) iter
= g_list_next (iter
);
2773 iter
= g_list_next (iter
);
2777 else /* if (val_in_menubar && iter_in_new_menubar) */
2780 /* This corresponds to:
2785 g_object_ref (G_OBJECT (witem2
));
2786 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2787 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2788 GTK_WIDGET (witem2
), pos
);
2789 g_object_unref (G_OBJECT (witem2
));
2791 g_list_free (*list
);
2792 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2793 while (nr
-- > 0) iter
= g_list_next (iter
);
2794 if (iter
) iter
= g_list_next (iter
);
2800 /* Update the rest of the menu bar. */
2801 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2802 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2805 /* Update the menu item W so it corresponds to VAL.
2806 SELECT_CB is the callback to use when a menu item is selected.
2807 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2808 CL_DATA is the data to set in the widget for menu invocation. */
2811 xg_update_menu_item (widget_value
*val
,
2813 GCallback select_cb
,
2814 GCallback highlight_cb
,
2815 xg_menu_cb_data
*cl_data
)
2822 const char *old_label
= 0;
2823 const char *old_key
= 0;
2824 xg_menu_item_cb_data
*cb_data
;
2826 wchild
= XG_BIN_CHILD (w
);
2827 utf8_label
= get_utf8_string (val
->name
);
2828 utf8_key
= get_utf8_string (val
->key
);
2830 /* See if W is a menu item with a key. See make_menu_item above. */
2831 if (GTK_IS_HBOX (wchild
))
2833 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2835 wlbl
= GTK_LABEL (list
->data
);
2836 wkey
= GTK_LABEL (list
->next
->data
);
2841 /* Remove the key and keep just the label. */
2842 g_object_ref (G_OBJECT (wlbl
));
2843 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2844 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2845 g_object_unref (G_OBJECT (wlbl
));
2850 else /* Just a label. */
2852 wlbl
= GTK_LABEL (wchild
);
2854 /* Check if there is now a key. */
2857 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2858 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2860 wlbl
= GTK_LABEL (list
->data
);
2861 wkey
= GTK_LABEL (list
->next
->data
);
2864 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2865 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2870 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2871 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2873 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2874 gtk_label_set_text (wkey
, utf8_key
);
2876 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2877 gtk_label_set_text (wlbl
, utf8_label
);
2879 if (utf8_key
) g_free (utf8_key
);
2880 if (utf8_label
) g_free (utf8_label
);
2882 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2883 gtk_widget_set_sensitive (w
, FALSE
);
2884 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2885 gtk_widget_set_sensitive (w
, TRUE
);
2887 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2891 cb_data
->call_data
= val
->call_data
;
2892 cb_data
->help
= val
->help
;
2893 cb_data
->cl_data
= cl_data
;
2895 /* We assume the callback functions don't change. */
2896 if (val
->call_data
&& ! val
->contents
)
2898 /* This item shall have a select callback. */
2899 if (! cb_data
->select_id
)
2901 = g_signal_connect (G_OBJECT (w
), "activate",
2902 select_cb
, cb_data
);
2904 else if (cb_data
->select_id
)
2906 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2907 cb_data
->select_id
= 0;
2912 /* Update the toggle menu item W so it corresponds to VAL. */
2915 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
2917 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2920 /* Update the radio menu item W so it corresponds to VAL. */
2923 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
2925 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2928 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2929 SUBMENU may be NULL, in that case a new menu is created.
2930 F is the frame the menu bar belongs to.
2931 VAL describes the contents of the menu bar.
2932 SELECT_CB is the callback to use when a menu item is selected.
2933 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2934 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2935 CL_DATA is the call back data to use for any newly created items.
2937 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2941 xg_update_submenu (GtkWidget
*submenu
,
2944 GCallback select_cb
,
2945 GCallback deactivate_cb
,
2946 GCallback highlight_cb
,
2947 xg_menu_cb_data
*cl_data
)
2949 GtkWidget
*newsub
= submenu
;
2953 int has_tearoff_p
= 0;
2954 GList
*first_radio
= 0;
2957 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2959 for (cur
= val
, iter
= list
;
2961 iter
= g_list_next (iter
), cur
= cur
->next
)
2963 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2965 /* Skip tearoff items, they have no counterpart in val. */
2966 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2969 iter
= g_list_next (iter
);
2970 if (iter
) w
= GTK_WIDGET (iter
->data
);
2974 /* Remember first radio button in a group. If we get a mismatch in
2975 a radio group we must rebuild the whole group so that the connections
2976 in GTK becomes correct. */
2977 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2979 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2980 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2983 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2985 if (! menu_separator_name_p (cur
->name
))
2988 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2990 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2992 xg_update_toggle_item (cur
, w
);
2993 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2995 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2997 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2999 xg_update_radio_item (cur
, w
);
3000 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3002 else if (GTK_IS_MENU_ITEM (w
))
3004 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3007 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3008 menu_separator_name_p (cur
->name
))
3011 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3013 sub
= gtk_menu_item_get_submenu (witem
);
3014 if (sub
&& ! cur
->contents
)
3016 /* Not a submenu anymore. */
3017 g_object_ref (G_OBJECT (sub
));
3018 remove_submenu (witem
);
3019 gtk_widget_destroy (sub
);
3021 else if (cur
->contents
)
3025 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3026 select_cb
, deactivate_cb
,
3027 highlight_cb
, cl_data
);
3029 /* If this item just became a submenu, we must set it. */
3031 gtk_menu_item_set_submenu (witem
, nsub
);
3036 /* Structural difference. Remove everything from here and down
3042 /* Remove widgets from first structual change. */
3045 /* If we are adding new menu items below, we must remove from
3046 first radio button so that radio groups become correct. */
3047 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3048 else xg_destroy_widgets (iter
);
3053 /* More items added. Create them. */
3054 newsub
= create_menus (cur
,
3067 if (list
) g_list_free (list
);
3072 /* Update the MENUBAR.
3073 F is the frame the menu bar belongs to.
3074 VAL describes the contents of the menu bar.
3075 If DEEP_P is non-zero, rebuild all but the top level menu names in
3076 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3077 SELECT_CB is the callback to use when a menu item is selected.
3078 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3079 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3082 xg_modify_menubar_widgets (GtkWidget
*menubar
, FRAME_PTR f
, widget_value
*val
,
3084 GCallback select_cb
, GCallback deactivate_cb
,
3085 GCallback highlight_cb
)
3087 xg_menu_cb_data
*cl_data
;
3088 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3092 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
3095 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3096 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3102 /* Update all sub menus.
3103 We must keep the submenus (GTK menu item widgets) since the
3104 X Window in the XEvent that activates the menu are those widgets. */
3106 /* Update cl_data, menu_item things in F may have changed. */
3107 update_cl_data (cl_data
, f
, highlight_cb
);
3109 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3114 GtkMenuItem
*witem
= 0;
3116 /* Find sub menu that corresponds to val and update it. */
3117 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3119 witem
= GTK_MENU_ITEM (iter
->data
);
3120 if (xg_item_label_same_p (witem
, cur
->name
))
3122 sub
= gtk_menu_item_get_submenu (witem
);
3127 newsub
= xg_update_submenu (sub
,
3134 /* sub may still be NULL. If we just updated non deep and added
3135 a new menu bar item, it has no sub menu yet. So we set the
3136 newly created sub menu under witem. */
3137 if (newsub
!= sub
&& witem
!= 0)
3139 xg_set_screen (newsub
, f
);
3140 gtk_menu_item_set_submenu (witem
, newsub
);
3146 gtk_widget_show_all (menubar
);
3149 /* Callback called when the menu bar W is mapped.
3150 Used to find the height of the menu bar if we didn't get it
3151 after showing the widget. */
3154 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3157 FRAME_PTR f
= (FRAME_PTR
) user_data
;
3158 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3159 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3161 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3162 xg_height_or_width_changed (f
);
3166 /* Recompute all the widgets of frame F, when the menu bar has been
3167 changed. Value is non-zero if widgets were updated. */
3170 xg_update_frame_menubar (FRAME_PTR f
)
3172 struct x_output
*x
= f
->output_data
.x
;
3175 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3178 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3179 return 0; /* Already done this, happens for frames created invisible. */
3183 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3185 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3187 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3188 gtk_widget_show_all (x
->menubar_widget
);
3189 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3191 /* If menu bar doesn't know its height yet, cheat a little so the frame
3192 doesn't jump so much when resized later in menubar_map_cb. */
3193 if (req
.height
== 0)
3196 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3198 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3199 xg_height_or_width_changed (f
);
3206 /* Get rid of the menu bar of frame F, and free its storage.
3207 This is used when deleting a frame, and when turning off the menu bar. */
3210 free_frame_menubar (FRAME_PTR f
)
3212 struct x_output
*x
= f
->output_data
.x
;
3214 if (x
->menubar_widget
)
3218 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3219 /* The menubar and its children shall be deleted when removed from
3221 x
->menubar_widget
= 0;
3222 FRAME_MENUBAR_HEIGHT (f
) = 0;
3223 xg_height_or_width_changed (f
);
3229 xg_event_is_for_menubar (FRAME_PTR f
, XEvent
*event
)
3231 struct x_output
*x
= f
->output_data
.x
;
3240 if (! x
->menubar_widget
) return 0;
3242 if (! (event
->xbutton
.x
>= 0
3243 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3244 && event
->xbutton
.y
>= 0
3245 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3246 && event
->xbutton
.same_screen
))
3249 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3250 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3252 gevent
.any
.window
= gw
;
3253 gwdesc
= gtk_get_event_widget (&gevent
);
3254 if (! gwdesc
) return 0;
3255 if (! GTK_IS_MENU_BAR (gwdesc
)
3256 && ! GTK_IS_MENU_ITEM (gwdesc
)
3257 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3260 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3261 if (! list
) return 0;
3262 rec
.x
= event
->xbutton
.x
;
3263 rec
.y
= event
->xbutton
.y
;
3267 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3269 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3270 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3274 return iter
== 0 ? 0 : 1;
3279 /***********************************************************************
3280 Scroll bar functions
3281 ***********************************************************************/
3284 /* Setting scroll bar values invokes the callback. Use this variable
3285 to indicate that callback should do nothing. */
3287 int xg_ignore_gtk_scrollbar
;
3289 /* The width of the scroll bar for the current theme. */
3291 static int scroll_bar_width_for_theme
;
3293 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3294 may be larger than 32 bits. Keep a mapping from integer index to widget
3295 pointers to get around the 32 bit limitation. */
3299 GtkWidget
**widgets
;
3304 /* Grow this much every time we need to allocate more */
3306 #define ID_TO_WIDGET_INCR 32
3308 /* Store the widget pointer W in id_to_widget and return the integer index. */
3311 xg_store_widget_in_map (GtkWidget
*w
)
3315 if (id_to_widget
.max_size
== id_to_widget
.used
)
3317 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3319 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
3320 sizeof (GtkWidget
*)*new_size
);
3322 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3323 id_to_widget
.widgets
[i
] = 0;
3324 id_to_widget
.max_size
= new_size
;
3327 /* Just loop over the array and find a free place. After all,
3328 how many scroll bars are we creating? Should be a small number.
3329 The check above guarantees we will find a free place. */
3330 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3332 if (! id_to_widget
.widgets
[i
])
3334 id_to_widget
.widgets
[i
] = w
;
3335 ++id_to_widget
.used
;
3341 /* Should never end up here */
3345 /* Remove pointer at IDX from id_to_widget.
3346 Called when scroll bar is destroyed. */
3349 xg_remove_widget_from_map (int idx
)
3351 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3353 id_to_widget
.widgets
[idx
] = 0;
3354 --id_to_widget
.used
;
3358 /* Get the widget pointer at IDX from id_to_widget. */
3361 xg_get_widget_from_map (int idx
)
3363 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3364 return id_to_widget
.widgets
[idx
];
3370 update_theme_scrollbar_width (void)
3373 GtkAdjustment
*vadj
;
3380 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3381 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3382 g_object_ref_sink (G_OBJECT (wscroll
));
3383 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3384 gtk_widget_destroy (wscroll
);
3385 g_object_unref (G_OBJECT (wscroll
));
3388 scroll_bar_width_for_theme
= w
;
3392 xg_get_default_scrollbar_width (void)
3394 return scroll_bar_width_for_theme
;
3397 /* Return the scrollbar id for X Window WID on display DPY.
3398 Return -1 if WID not in id_to_widget. */
3401 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3406 w
= xg_win_to_widget (dpy
, wid
);
3410 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3411 if (id_to_widget
.widgets
[idx
] == w
)
3418 /* Callback invoked when scroll bar WIDGET is destroyed.
3419 DATA is the index into id_to_widget for WIDGET.
3420 We free pointer to last scroll bar values here and remove the index. */
3423 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3425 int id
= (intptr_t) data
;
3426 xg_remove_widget_from_map (id
);
3429 /* Create a scroll bar widget for frame F. Store the scroll bar
3431 SCROLL_CALLBACK is the callback to invoke when the value of the
3433 END_CALLBACK is the callback to invoke when scrolling ends.
3434 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3435 to set resources for the widget. */
3438 xg_create_scroll_bar (FRAME_PTR f
,
3439 struct scroll_bar
*bar
,
3440 GCallback scroll_callback
,
3441 GCallback end_callback
,
3442 const char *scroll_bar_name
)
3448 GtkAdjustment
*vadj
;
3453 /* Page, step increment values are not so important here, they
3454 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3455 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3458 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3459 webox
= gtk_event_box_new ();
3460 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3462 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3464 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3466 scroll_id
= xg_store_widget_in_map (wscroll
);
3468 g_signal_connect (G_OBJECT (wscroll
),
3470 G_CALLBACK (xg_gtk_scroll_destroy
),
3471 (gpointer
) scroll_id
);
3472 g_signal_connect (G_OBJECT (wscroll
),
3476 g_signal_connect (G_OBJECT (wscroll
),
3477 "button-release-event",
3481 /* The scroll bar widget does not draw on a window of its own. Instead
3482 it draws on the parent window, in this case the edit widget. So
3483 whenever the edit widget is cleared, the scroll bar needs to redraw
3484 also, which causes flicker. Put an event box between the edit widget
3485 and the scroll bar, so the scroll bar instead draws itself on the
3486 event box window. */
3487 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3488 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3491 /* Set the cursor to an arrow. */
3492 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3494 bar
->x_window
= scroll_id
;
3497 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3500 xg_remove_scroll_bar (FRAME_PTR f
, int scrollbar_id
)
3502 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3505 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3506 gtk_widget_destroy (w
);
3507 gtk_widget_destroy (wparent
);
3508 SET_FRAME_GARBAGED (f
);
3512 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3514 TOP/LEFT are the new pixel positions where the bar shall appear.
3515 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3518 xg_update_scrollbar_pos (FRAME_PTR f
,
3526 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3530 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3531 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3534 /* Clear out old position. */
3535 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3536 if (gtk_widget_get_parent (wparent
) == wfixed
)
3538 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3539 "x", &oldx
, "y", &oldy
, NULL
);
3540 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3543 /* Move and resize to new values. */
3544 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3545 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3548 /* No room. Hide scroll bar as some themes output a warning if
3549 the height is less than the min size. */
3550 gtk_widget_hide (wparent
);
3551 gtk_widget_hide (wscroll
);
3555 gtk_widget_show_all (wparent
);
3556 gtk_widget_set_size_request (wscroll
, width
, height
);
3558 gtk_widget_queue_draw (wfixed
);
3559 gdk_window_process_all_updates ();
3560 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3562 /* Clear under old scroll bar position. This must be done after
3563 the gtk_widget_queue_draw and gdk_window_process_all_updates
3565 x_clear_area (FRAME_X_DISPLAY (f
),
3567 oldx
, oldy
, oldw
, oldh
, 0);
3570 /* GTK does not redraw until the main loop is entered again, but
3571 if there are no X events pending we will not enter it. So we sync
3572 here to get some events. */
3575 SET_FRAME_GARBAGED (f
);
3576 cancel_mouse_face (f
);
3580 /* Get the current value of the range, truncated to an integer. */
3583 int_gtk_range_get_value (GtkRange
*range
)
3585 return gtk_range_get_value (range
);
3589 /* Set the thumb size and position of scroll bar BAR. We are currently
3590 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3593 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3598 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3600 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3602 if (wscroll
&& NILP (bar
->dragging
))
3612 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3614 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3615 rather than the real portion value. This makes the thumb less likely
3616 to resize and that looks better. */
3617 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3618 /* When the thumb is at the bottom, position == whole.
3619 So we need to increase `whole' to make space for the thumb. */
3626 top
= (gdouble
) position
/ whole
;
3627 shown
= (gdouble
) portion
/ whole
;
3630 size
= shown
* XG_SB_RANGE
;
3631 size
= min (size
, XG_SB_RANGE
);
3632 size
= max (size
, 1);
3634 value
= top
* XG_SB_RANGE
;
3635 value
= min (value
, XG_SB_MAX
- size
);
3636 value
= max (value
, XG_SB_MIN
);
3638 /* Assume all lines are of equal size. */
3639 new_step
= size
/ max (1, FRAME_LINES (f
));
3641 old_size
= gtk_adjustment_get_page_size (adj
);
3642 if (old_size
!= size
)
3644 int old_step
= gtk_adjustment_get_step_increment (adj
);
3645 if (old_step
!= new_step
)
3647 gtk_adjustment_set_page_size (adj
, size
);
3648 gtk_adjustment_set_step_increment (adj
, new_step
);
3649 /* Assume a page increment is about 95% of the page size */
3650 gtk_adjustment_set_page_increment (adj
,(int) (0.95*size
));
3655 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3659 /* gtk_range_set_value invokes the callback. Set
3660 ignore_gtk_scrollbar to make the callback do nothing */
3661 xg_ignore_gtk_scrollbar
= 1;
3663 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3664 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3666 gtk_adjustment_changed (adj
);
3668 xg_ignore_gtk_scrollbar
= 0;
3675 /* Return non-zero if EVENT is for a scroll bar in frame F.
3676 When the same X window is used for several Gtk+ widgets, we cannot
3677 say for sure based on the X window alone if an event is for the
3678 frame. This function does additional checks.
3680 Return non-zero if the event is for a scroll bar, zero otherwise. */
3683 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3687 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3689 /* Check if press occurred outside the edit widget. */
3690 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3691 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3692 != gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3695 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3696 || event
->type
== MotionNotify
))
3698 /* If we are releasing or moving the scroll bar, it has the grab. */
3699 GtkWidget
*w
= gtk_grab_get_current ();
3700 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3708 /***********************************************************************
3710 ***********************************************************************/
3711 /* The key for the data we put in the GtkImage widgets. The data is
3712 the image used by Emacs. We use this to see if we need to update
3713 the GtkImage with a new image. */
3714 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3716 /* The key for storing the latest modifiers so the activate callback can
3718 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3720 /* The key for storing the button widget in its proxy menu item. */
3721 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3723 /* The key for the data we put in the GtkImage widgets. The data is
3724 the stock name used by Emacs. We use this to see if we need to update
3725 the GtkImage with a new image. */
3726 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3728 /* As above, but this is used for named theme widgets, as opposed to
3730 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3732 /* Callback function invoked when a tool bar item is pressed.
3733 W is the button widget in the tool bar that got pressed,
3734 CLIENT_DATA is an integer that is the index of the button in the
3735 tool bar. 0 is the first button. */
3738 xg_tool_bar_button_cb (GtkWidget
*widget
,
3739 GdkEventButton
*event
,
3742 intptr_t state
= event
->state
;
3743 gpointer ptr
= (gpointer
) state
;
3744 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3749 /* Callback function invoked when a tool bar item is pressed.
3750 W is the button widget in the tool bar that got pressed,
3751 CLIENT_DATA is an integer that is the index of the button in the
3752 tool bar. 0 is the first button. */
3755 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3757 intptr_t idx
= (intptr_t) client_data
;
3758 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3759 intptr_t mod
= (intptr_t) gmod
;
3761 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3762 Lisp_Object key
, frame
;
3763 struct input_event event
;
3766 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3769 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3771 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3772 XSETFRAME (frame
, f
);
3774 /* We generate two events here. The first one is to set the prefix
3775 to `(tool_bar)', see keyboard.c. */
3776 event
.kind
= TOOL_BAR_EVENT
;
3777 event
.frame_or_window
= frame
;
3779 kbd_buffer_store_event (&event
);
3781 event
.kind
= TOOL_BAR_EVENT
;
3782 event
.frame_or_window
= frame
;
3784 /* Convert between the modifier bits GDK uses and the modifier bits
3785 Emacs uses. This assumes GDK and X masks are the same, which they are when
3787 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3788 kbd_buffer_store_event (&event
);
3790 /* Return focus to the frame after we have clicked on a detached
3792 Fx_focus_frame (frame
);
3795 /* Callback function invoked when a tool bar item is pressed in a detached
3796 tool bar or the overflow drop down menu.
3797 We just call xg_tool_bar_callback.
3798 W is the menu item widget that got pressed,
3799 CLIENT_DATA is an integer that is the index of the button in the
3800 tool bar. 0 is the first button. */
3803 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3805 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3806 XG_TOOL_BAR_PROXY_BUTTON
));
3807 xg_tool_bar_callback (wbutton
, client_data
);
3812 xg_tool_bar_help_callback (GtkWidget
*w
,
3813 GdkEventCrossing
*event
,
3814 gpointer client_data
);
3816 /* This callback is called when a help is to be shown for an item in
3817 the detached tool bar when the detached tool bar it is not expanded. */
3820 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3821 GdkEventCrossing
*event
,
3822 gpointer client_data
)
3824 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3825 XG_TOOL_BAR_PROXY_BUTTON
));
3827 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3831 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3833 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3834 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3835 GtkWidget
*c2
= clist
->next
? (GtkWidget
*) clist
->next
->data
: NULL
;
3837 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3838 g_list_free (clist
);
3839 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3843 /* This callback is called when a tool item should create a proxy item,
3844 such as for the overflow menu. Also called when the tool bar is detached.
3845 If we don't create a proxy menu item, the detached tool bar will be
3849 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3851 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
3852 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
3854 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3855 GtkImage
*wimage
= GTK_IMAGE (c1
);
3856 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3857 (wlbl
? gtk_label_get_text (wlbl
) : "");
3858 GtkWidget
*wmenuimage
;
3861 if (gtk_button_get_use_stock (wbutton
))
3862 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3863 GTK_ICON_SIZE_MENU
);
3866 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3867 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3869 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
3871 if (store_type
== GTK_IMAGE_STOCK
)
3874 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3875 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3877 else if (store_type
== GTK_IMAGE_ICON_SET
)
3879 GtkIconSet
*icon_set
;
3880 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3881 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3882 GTK_ICON_SIZE_MENU
);
3884 else if (store_type
== GTK_IMAGE_PIXBUF
)
3889 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3892 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3894 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3895 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3896 GDK_INTERP_BILINEAR
);
3898 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3902 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3906 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3908 const gchar
*icon_name
;
3909 GtkIconSize icon_size
;
3911 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3912 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3913 GTK_ICON_SIZE_MENU
);
3917 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3922 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3924 g_signal_connect (G_OBJECT (wmenuitem
),
3926 G_CALLBACK (xg_tool_bar_proxy_callback
),
3930 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3931 (gpointer
) wbutton
);
3932 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3933 gtk_widget_set_sensitive (wmenuitem
,
3934 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
3936 /* Use enter/leave notify to show help. We use the events
3937 rather than the GtkButton specific signals "enter" and
3938 "leave", so we can have only one callback. The event
3939 will tell us what kind of event it is. */
3940 g_signal_connect (G_OBJECT (wmenuitem
),
3941 "enter-notify-event",
3942 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3944 g_signal_connect (G_OBJECT (wmenuitem
),
3945 "leave-notify-event",
3946 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3952 /* This callback is called when a tool bar is detached. We must set
3953 the height of the tool bar to zero when this happens so frame sizes
3954 are correctly calculated.
3955 WBOX is the handle box widget that enables detach/attach of the tool bar.
3956 W is the tool bar widget.
3957 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3960 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
3962 gpointer client_data
)
3964 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3966 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3971 GtkRequisition req
, req2
;
3972 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3973 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
3974 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
3975 req
.width
-= req2
.width
;
3976 req
.height
-= req2
.height
;
3977 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
3978 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
3979 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
3980 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
3981 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
3982 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
3983 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
3984 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
3985 xg_height_or_width_changed (f
);
3989 /* This callback is called when a tool bar is reattached. We must set
3990 the height of the tool bar when this happens so frame sizes
3991 are correctly calculated.
3992 WBOX is the handle box widget that enables detach/attach of the tool bar.
3993 W is the tool bar widget.
3994 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3997 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
3999 gpointer client_data
)
4001 FRAME_PTR f
= (FRAME_PTR
) client_data
;
4002 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4006 GtkRequisition req
, req2
;
4007 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
4008 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4009 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4010 req
.width
+= req2
.width
;
4011 req
.height
+= req2
.height
;
4012 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4013 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4014 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4015 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4016 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4017 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4018 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4019 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4020 xg_height_or_width_changed (f
);
4024 /* This callback is called when the mouse enters or leaves a tool bar item.
4025 It is used for displaying and hiding the help text.
4026 W is the tool bar item, a button.
4027 EVENT is either an enter event or leave event.
4028 CLIENT_DATA is an integer that is the index of the button in the
4029 tool bar. 0 is the first button.
4031 Returns FALSE to tell GTK to keep processing this event. */
4034 xg_tool_bar_help_callback (GtkWidget
*w
,
4035 GdkEventCrossing
*event
,
4036 gpointer client_data
)
4038 intptr_t idx
= (intptr_t) client_data
;
4039 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4040 Lisp_Object help
, frame
;
4042 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4045 if (event
->type
== GDK_ENTER_NOTIFY
)
4047 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4048 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4051 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4056 XSETFRAME (frame
, f
);
4057 kbd_buffer_store_help_event (frame
, help
);
4063 /* This callback is called when a tool bar item shall be redrawn.
4064 It modifies the expose event so that the GtkImage widget redraws the
4065 whole image. This to overcome a bug that makes GtkImage draw the image
4066 in the wrong place when it tries to redraw just a part of the image.
4067 W is the GtkImage to be redrawn.
4068 EVENT is the expose event for W.
4069 CLIENT_DATA is unused.
4071 Returns FALSE to tell GTK to keep processing this event. */
4075 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4076 GdkEventExpose
*event
,
4077 gpointer client_data
)
4081 gdk_drawable_get_size (event
->window
, &width
, &height
);
4082 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4083 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4085 event
->area
.x
= max (0, event
->area
.x
);
4086 event
->area
.y
= max (0, event
->area
.y
);
4088 event
->area
.width
= max (width
, event
->area
.width
);
4089 event
->area
.height
= max (height
, event
->area
.height
);
4095 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4096 #define toolbar_set_orientation(w, o) \
4097 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4099 #define toolbar_set_orientation(w, o) \
4100 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4103 /* Attach a tool bar to frame F. */
4106 xg_pack_tool_bar (FRAME_PTR f
, Lisp_Object pos
)
4108 struct x_output
*x
= f
->output_data
.x
;
4109 int into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4111 toolbar_set_orientation (x
->toolbar_widget
,
4113 ? GTK_ORIENTATION_VERTICAL
4114 : GTK_ORIENTATION_HORIZONTAL
);
4115 if (!x
->handlebox_widget
)
4117 x
->handlebox_widget
= gtk_handle_box_new ();
4118 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4119 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4120 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4121 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4122 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4128 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4130 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), x
->handlebox_widget
,
4133 if (EQ (pos
, Qleft
))
4134 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4135 x
->handlebox_widget
,
4137 x
->toolbar_in_hbox
= 1;
4141 int vbox_pos
= x
->menubar_widget
? 1 : 0;
4142 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4144 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
4148 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4149 x
->handlebox_widget
,
4151 x
->toolbar_in_hbox
= 0;
4155 /* Create a tool bar for frame F. */
4158 xg_create_tool_bar (FRAME_PTR f
)
4160 struct x_output
*x
= f
->output_data
.x
;
4162 x
->toolbar_widget
= gtk_toolbar_new ();
4163 x
->toolbar_detached
= 0;
4165 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4167 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4168 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4172 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4174 /* Find the right-to-left image named by RTL in the tool bar images for F.
4175 Returns IMAGE if RTL is not found. */
4178 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
4181 Lisp_Object file
, rtl_name
;
4182 struct gcpro gcpro1
, gcpro2
;
4183 GCPRO2 (file
, rtl_name
);
4185 rtl_name
= Ffile_name_nondirectory (rtl
);
4187 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4189 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4190 if (!NILP (file
= file_for_image (rtl_image
)))
4192 file
= call1 (intern ("file-name-sans-extension"),
4193 Ffile_name_nondirectory (file
));
4194 if (EQ (Fequal (file
, rtl_name
), Qt
))
4205 static GtkToolItem
*
4206 xg_make_tool_item (FRAME_PTR f
,
4208 GtkWidget
**wbutton
,
4210 int i
, int horiz
, int text_image
)
4212 GtkToolItem
*ti
= gtk_tool_item_new ();
4213 GtkWidget
*vb
= horiz
? gtk_hbox_new (FALSE
, 0) : gtk_vbox_new (FALSE
, 0);
4214 GtkWidget
*wb
= gtk_button_new ();
4215 GtkWidget
*weventbox
= gtk_event_box_new ();
4217 if (wimage
&& !text_image
)
4218 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4220 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4221 if (wimage
&& text_image
)
4222 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4224 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4225 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4226 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4227 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4228 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4233 gpointer gi
= (gpointer
) ii
;
4235 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4236 G_CALLBACK (xg_tool_bar_menu_proxy
),
4239 g_signal_connect (G_OBJECT (wb
), "clicked",
4240 G_CALLBACK (xg_tool_bar_callback
),
4243 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4246 /* Catch expose events to overcome an annoying redraw bug, see
4247 comment for xg_tool_bar_item_expose_callback. */
4248 g_signal_connect (G_OBJECT (ti
),
4250 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4253 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4255 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
4256 no distinction based on modifiers in the activate callback,
4257 so we have to do it ourselves. */
4258 g_signal_connect (wb
, "button-release-event",
4259 G_CALLBACK (xg_tool_bar_button_cb
),
4262 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4264 /* Use enter/leave notify to show help. We use the events
4265 rather than the GtkButton specific signals "enter" and
4266 "leave", so we can have only one callback. The event
4267 will tell us what kind of event it is. */
4268 /* The EMACS_INT cast avoids a warning. */
4269 g_signal_connect (G_OBJECT (weventbox
),
4270 "enter-notify-event",
4271 G_CALLBACK (xg_tool_bar_help_callback
),
4273 g_signal_connect (G_OBJECT (weventbox
),
4274 "leave-notify-event",
4275 G_CALLBACK (xg_tool_bar_help_callback
),
4279 if (wbutton
) *wbutton
= wb
;
4285 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4286 const char *icon_name
, const struct image
*img
,
4287 const char *label
, int horiz
)
4291 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4292 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4294 /* Check if the tool icon matches. */
4297 old
= g_object_get_data (G_OBJECT (wimage
),
4298 XG_TOOL_BAR_STOCK_NAME
);
4299 if (!old
|| strcmp (old
, stock_name
))
4304 old
= g_object_get_data (G_OBJECT (wimage
),
4305 XG_TOOL_BAR_ICON_NAME
);
4306 if (!old
|| strcmp (old
, icon_name
))
4311 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4312 XG_TOOL_BAR_IMAGE_DATA
);
4313 Pixmap old_img
= (Pixmap
) gold_img
;
4314 if (old_img
!= img
->pixmap
)
4318 /* Check button configuration and label. */
4319 if ((horiz
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
))
4320 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4323 /* Ensure label is correct. */
4325 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4330 xg_update_tool_bar_sizes (FRAME_PTR f
)
4332 struct x_output
*x
= f
->output_data
.x
;
4334 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4336 gtk_widget_get_preferred_size (GTK_WIDGET (x
->handlebox_widget
), NULL
, &req
);
4337 if (x
->toolbar_in_hbox
)
4340 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4341 x
->handlebox_widget
,
4342 "position", &pos
, NULL
);
4343 if (pos
== 0) nl
= req
.width
;
4344 else nr
= req
.width
;
4349 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4350 x
->handlebox_widget
,
4351 "position", &pos
, NULL
);
4352 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4353 else nb
= req
.height
;
4356 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4357 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4358 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4359 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4361 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4362 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4363 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4364 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4365 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4366 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4374 /* Update the tool bar for frame F. Add new buttons and remove old. */
4377 update_frame_tool_bar (FRAME_PTR f
)
4380 struct x_output
*x
= f
->output_data
.x
;
4381 int hmargin
= 0, vmargin
= 0;
4382 GtkToolbar
*wtoolbar
;
4384 GtkTextDirection dir
;
4385 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
4387 int text_image
, horiz
;
4389 if (! FRAME_GTK_WIDGET (f
))
4394 if (INTEGERP (Vtool_bar_button_margin
)
4395 && XINT (Vtool_bar_button_margin
) > 0)
4397 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4398 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4400 else if (CONSP (Vtool_bar_button_margin
))
4402 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
4403 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
4404 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4406 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
4407 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
4408 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4411 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4412 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4413 i.e. zero. This means that margins less than
4414 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4415 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4416 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4418 if (! x
->toolbar_widget
)
4419 xg_create_tool_bar (f
);
4421 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4422 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4424 style
= Ftool_bar_get_system_style ();
4425 text_image
= EQ (style
, Qtext_image_horiz
);
4426 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4428 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4430 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4431 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4435 struct image
*img
= NULL
;
4437 Lisp_Object stock
= Qnil
;
4438 GtkStockItem stock_item
;
4439 char *stock_name
= NULL
;
4440 char *icon_name
= NULL
;
4442 GtkWidget
*wbutton
= NULL
;
4443 Lisp_Object specified_file
;
4444 int vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4446 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4447 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4448 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4451 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4453 /* If this is a separator, use a gtk separator item. */
4454 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4456 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4459 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4461 ti
= gtk_separator_tool_item_new ();
4462 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4468 /* Otherwise, the tool-bar item is an ordinary button. */
4470 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4472 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4476 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4478 /* Ignore invalid image specifications. */
4479 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4480 if (!valid_image_p (image
))
4483 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4488 specified_file
= file_for_image (image
);
4489 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4490 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4492 if (STRINGP (stock
))
4494 stock_name
= SSDATA (stock
);
4495 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4497 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4498 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4500 icon_name
= stock_name
+ 2;
4504 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4507 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4509 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4510 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4518 if (stock_name
== NULL
&& icon_name
== NULL
)
4520 /* No stock image, or stock item not known. Try regular
4521 image. If image is a vector, choose it according to the
4523 if (dir
== GTK_TEXT_DIR_RTL
4524 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4526 image
= find_rtl_image (f
, image
, rtl
);
4528 if (VECTORP (image
))
4532 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4533 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4536 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4537 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4539 xassert (ASIZE (image
) >= idx
);
4540 image
= AREF (image
, idx
);
4545 img_id
= lookup_image (f
, image
);
4546 img
= IMAGE_FROM_ID (f
, img_id
);
4547 prepare_image_for_display (f
, img
);
4549 if (img
->load_failed_p
|| img
->pixmap
== None
)
4552 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4558 /* If there is an existing widget, check if it's stale; if so,
4559 remove it and make a new tool item from scratch. */
4560 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4563 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4572 /* Save the image so we can see if an update is needed the
4573 next time we call xg_tool_item_match_p. */
4574 if (EQ (style
, Qtext
))
4576 else if (stock_name
)
4578 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4579 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4580 (gpointer
) xstrdup (stock_name
),
4581 (GDestroyNotify
) xfree
);
4585 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4586 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4587 (gpointer
) xstrdup (icon_name
),
4588 (GDestroyNotify
) xfree
);
4592 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4593 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4594 (gpointer
)img
->pixmap
);
4597 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4598 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4599 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4604 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4608 /* Remove buttons not longer needed. */
4611 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4613 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4614 } while (ti
!= NULL
);
4616 if (f
->n_tool_bar_items
!= 0)
4619 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4620 gtk_widget_show_all (GTK_WIDGET (x
->handlebox_widget
));
4621 if (xg_update_tool_bar_sizes (f
))
4622 xg_height_or_width_changed (f
);
4628 /* Deallocate all resources for the tool bar on frame F.
4629 Remove the tool bar. */
4632 free_frame_tool_bar (FRAME_PTR f
)
4634 struct x_output
*x
= f
->output_data
.x
;
4636 if (x
->toolbar_widget
)
4638 int is_packed
= x
->handlebox_widget
!= 0;
4640 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4641 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4644 if (x
->toolbar_in_hbox
)
4645 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4646 x
->handlebox_widget
);
4648 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4649 x
->handlebox_widget
);
4652 gtk_widget_destroy (x
->toolbar_widget
);
4654 x
->toolbar_widget
= 0;
4655 x
->handlebox_widget
= 0;
4656 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4657 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4659 xg_height_or_width_changed (f
);
4666 xg_change_toolbar_position (FRAME_PTR f
, Lisp_Object pos
)
4668 struct x_output
*x
= f
->output_data
.x
;
4670 if (! x
->toolbar_widget
|| ! x
->handlebox_widget
)
4674 g_object_ref (x
->handlebox_widget
);
4675 if (x
->toolbar_in_hbox
)
4676 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4677 x
->handlebox_widget
);
4679 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4680 x
->handlebox_widget
);
4681 xg_pack_tool_bar (f
, pos
);
4682 g_object_unref (x
->handlebox_widget
);
4683 if (xg_update_tool_bar_sizes (f
))
4684 xg_height_or_width_changed (f
);
4692 /***********************************************************************
4694 ***********************************************************************/
4696 xg_initialize (void)
4698 GtkBindingSet
*binding_set
;
4701 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4702 we keep it permanently linked in. */
4707 xg_ignore_gtk_scrollbar
= 0;
4708 xg_detached_menus
= 0;
4709 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4710 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4712 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4713 id_to_widget
.widgets
= 0;
4715 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4716 bindings. It doesn't seem to be any way to remove properties,
4717 so we set it to VoidSymbol which in X means "no key". */
4718 gtk_settings_set_string_property (gtk_settings_get_default (),
4719 "gtk-menu-bar-accel",
4723 /* Make GTK text input widgets use Emacs style keybindings. This is
4725 gtk_settings_set_string_property (gtk_settings_get_default (),
4726 "gtk-key-theme-name",
4730 /* Make dialogs close on C-g. Since file dialog inherits from
4731 dialog, this works for them also. */
4732 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4733 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4736 /* Make menus close on C-g. */
4737 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4738 (GTK_TYPE_MENU_SHELL
));
4739 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4741 update_theme_scrollbar_width ();
4744 #endif /* USE_GTK */