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. */
491 ptrdiff_t nr_bad
= 0;
494 unsigned char *p
= (unsigned char *)str
;
498 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
499 &bytes_written
, &err
))
500 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
503 p
+= bytes_written
+1;
516 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
517 memory_full (SIZE_MAX
);
518 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
519 p
= (unsigned char *)str
;
521 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
522 &bytes_written
, &err
))
523 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
525 strncpy (up
, (char *)p
, bytes_written
);
526 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
527 up
[bytes_written
+4] = '\0';
528 up
+= bytes_written
+4;
529 p
+= bytes_written
+1;
536 strcat (utf8_str
, cp
);
548 /* Check for special colors used in face spec for region face.
549 The colors are fetched from the Gtk+ theme.
550 Return 1 if color was found, 0 if not. */
553 xg_check_special_colors (struct frame
*f
,
554 const char *color_name
,
558 int get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
559 int get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
561 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
567 GtkStyleContext
*gsty
568 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
571 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
573 gtk_style_context_get_color (gsty
, state
, &col
);
575 gtk_style_context_get_background_color (gsty
, state
, &col
);
577 sprintf (buf
, "rgbi:%lf/%lf/%lf", col
.red
, col
.green
, col
.blue
);
578 success_p
= XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
581 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
582 GdkColor
*grgb
= get_bg
583 ? &gsty
->bg
[GTK_STATE_SELECTED
]
584 : &gsty
->fg
[GTK_STATE_SELECTED
];
586 color
->red
= grgb
->red
;
587 color
->green
= grgb
->green
;
588 color
->blue
= grgb
->blue
;
589 color
->pixel
= grgb
->pixel
;
600 /***********************************************************************
602 ***********************************************************************/
603 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
604 We use that to pop down the tooltip. This happens if Gtk+ for some
605 reason wants to change or hide the tooltip. */
607 #ifdef USE_GTK_TOOLTIP
610 hierarchy_ch_cb (GtkWidget
*widget
,
611 GtkWidget
*previous_toplevel
,
614 FRAME_PTR f
= (FRAME_PTR
) user_data
;
615 struct x_output
*x
= f
->output_data
.x
;
616 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
618 if (! top
|| ! GTK_IS_WINDOW (top
))
619 gtk_widget_hide (previous_toplevel
);
622 /* Callback called when Gtk+ thinks a tooltip should be displayed.
623 We use it to get the tooltip window and the tooltip widget so
624 we can manipulate the ourselves.
626 Return FALSE ensures that the tooltip is not shown. */
629 qttip_cb (GtkWidget
*widget
,
632 gboolean keyboard_mode
,
636 FRAME_PTR f
= (FRAME_PTR
) user_data
;
637 struct x_output
*x
= f
->output_data
.x
;
638 if (x
->ttip_widget
== NULL
)
643 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
644 x
->ttip_widget
= tooltip
;
645 g_object_ref (G_OBJECT (tooltip
));
646 x
->ttip_lbl
= gtk_label_new ("");
647 g_object_ref (G_OBJECT (x
->ttip_lbl
));
648 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
649 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
651 /* Change stupid Gtk+ default line wrapping. */
652 p
= gtk_widget_get_parent (x
->ttip_lbl
);
653 list
= gtk_container_get_children (GTK_CONTAINER (p
));
654 for (iter
= list
; iter
; iter
= g_list_next (iter
))
656 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
657 if (GTK_IS_LABEL (w
))
658 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
662 /* ATK needs an empty title for some reason. */
663 gtk_window_set_title (x
->ttip_window
, "");
664 /* Realize so we can safely get screen later on. */
665 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
666 gtk_widget_realize (x
->ttip_lbl
);
668 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
669 G_CALLBACK (hierarchy_ch_cb
), f
);
674 #endif /* USE_GTK_TOOLTIP */
676 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
677 Return zero if no system tooltip available, non-zero otherwise. */
680 xg_prepare_tooltip (FRAME_PTR f
,
685 #ifndef USE_GTK_TOOLTIP
688 struct x_output
*x
= f
->output_data
.x
;
692 GtkSettings
*settings
;
693 gboolean tt_enabled
= TRUE
;
695 Lisp_Object encoded_string
;
697 if (!x
->ttip_lbl
) return 0;
700 encoded_string
= ENCODE_UTF_8 (string
);
701 widget
= GTK_WIDGET (x
->ttip_lbl
);
702 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
703 screen
= gdk_window_get_screen (gwin
);
704 settings
= gtk_settings_get_for_screen (screen
);
705 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
708 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
709 /* Record that we disabled it so it can be enabled again. */
710 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
714 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
715 g_object_set_data (G_OBJECT
716 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
717 "gdk-display-current-tooltip", NULL
);
719 /* Put our dummy widget in so we can get callbacks for unrealize and
720 hierarchy-changed. */
721 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
722 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
723 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
724 if (width
) *width
= req
.width
;
725 if (height
) *height
= req
.height
;
730 #endif /* USE_GTK_TOOLTIP */
733 /* Show the tooltip at ROOT_X and ROOT_Y.
734 xg_prepare_tooltip must have been called before this function. */
737 xg_show_tooltip (FRAME_PTR f
, int root_x
, int root_y
)
739 #ifdef USE_GTK_TOOLTIP
740 struct x_output
*x
= f
->output_data
.x
;
744 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
745 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
751 /* Hide tooltip if shown. Do nothing if not shown.
752 Return non-zero if tip was hidden, non-zero if not (i.e. not using
756 xg_hide_tooltip (FRAME_PTR f
)
759 #ifdef USE_GTK_TOOLTIP
760 if (f
->output_data
.x
->ttip_window
)
762 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
764 gtk_widget_hide (GTK_WIDGET (win
));
766 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
768 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
769 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
770 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
771 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
782 /***********************************************************************
783 General functions for creating widgets, resizing, events, e.t.c.
784 ***********************************************************************/
786 /* Make a geometry string and pass that to GTK. It seems this is the
787 only way to get geometry position right if the user explicitly
788 asked for a position when starting Emacs.
789 F is the frame we shall set geometry for. */
792 xg_set_geometry (FRAME_PTR f
)
794 if (f
->size_hint_flags
& (USPosition
| PPosition
))
796 int left
= f
->left_pos
;
797 int xneg
= f
->size_hint_flags
& XNegative
;
798 int top
= f
->top_pos
;
799 int yneg
= f
->size_hint_flags
& YNegative
;
807 sprintf (geom_str
, "=%dx%d%c%d%c%d",
808 FRAME_PIXEL_WIDTH (f
),
809 FRAME_PIXEL_HEIGHT (f
),
810 (xneg
? '-' : '+'), left
,
811 (yneg
? '-' : '+'), top
);
813 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
815 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
819 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
820 and use a GtkFixed widget, this doesn't happen automatically. */
823 xg_clear_under_internal_border (FRAME_PTR f
)
825 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
827 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
828 gtk_widget_queue_draw (wfixed
);
829 gdk_window_process_all_updates ();
830 x_clear_area (FRAME_X_DISPLAY (f
),
833 FRAME_PIXEL_WIDTH (f
),
834 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
835 x_clear_area (FRAME_X_DISPLAY (f
),
838 FRAME_INTERNAL_BORDER_WIDTH (f
),
839 FRAME_PIXEL_HEIGHT (f
), 0);
840 x_clear_area (FRAME_X_DISPLAY (f
),
842 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
843 FRAME_PIXEL_WIDTH (f
),
844 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
845 x_clear_area (FRAME_X_DISPLAY (f
),
847 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
849 FRAME_INTERNAL_BORDER_WIDTH (f
),
850 FRAME_PIXEL_HEIGHT (f
), 0);
854 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
855 and a Gtk+ menu bar, we get resize events for the edit part of the
856 frame only. We let Gtk+ deal with the Gtk+ parts.
857 F is the frame to resize.
858 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
861 xg_frame_resized (FRAME_PTR f
, int pixelwidth
, int pixelheight
)
865 if (pixelwidth
== -1 && pixelheight
== -1)
867 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
868 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
870 &pixelwidth
, &pixelheight
);
875 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
876 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
878 if (columns
!= FRAME_COLS (f
)
879 || rows
!= FRAME_LINES (f
)
880 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
881 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
883 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
884 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
886 xg_clear_under_internal_border (f
);
887 change_frame_size (f
, rows
, columns
, 0, 1, 0);
888 SET_FRAME_GARBAGED (f
);
889 cancel_mouse_face (f
);
893 /* Resize the outer window of frame F after chainging the height.
894 COLUMNS/ROWS is the size the edit area shall have after the resize. */
897 xg_frame_set_char_size (FRAME_PTR f
, int cols
, int rows
)
899 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
900 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
903 if (FRAME_PIXEL_HEIGHT (f
) == 0)
906 /* Take into account the size of the scroll bar. Always use the
907 number of columns occupied by the scroll bar here otherwise we
908 might end up with a frame width that is not a multiple of the
909 frame's character width which is bad for vertically split
911 f
->scroll_bar_actual_width
912 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
914 compute_fringe_widths (f
, 0);
916 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
917 after calculating that value. */
918 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
919 + FRAME_TOOLBAR_WIDTH (f
);
922 /* Do this before resize, as we don't know yet if we will be resized. */
923 xg_clear_under_internal_border (f
);
925 /* Must resize our top level widget. Font size may have changed,
926 but not rows/cols. */
927 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
928 pixelwidth
, pixelheight
);
929 x_wm_set_size_hint (f
, 0, 0);
931 SET_FRAME_GARBAGED (f
);
932 cancel_mouse_face (f
);
934 /* We can not call change_frame_size for a mapped frame,
935 we can not set pixel width/height either. The window manager may
936 override our resize request, XMonad does this all the time.
937 The best we can do is try to sync, so lisp code sees the updated
938 size as fast as possible.
939 For unmapped windows, we can set rows/cols. When
940 the frame is mapped again we will (hopefully) get the correct size. */
941 if (f
->async_visible
)
943 /* Must call this to flush out events */
944 (void)gtk_events_pending ();
946 x_wait_for_event (f
, ConfigureNotify
);
950 change_frame_size (f
, rows
, cols
, 0, 1, 0);
951 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
952 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
956 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
957 The policy is to keep the number of editable lines. */
960 xg_height_or_width_changed (FRAME_PTR f
)
962 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
963 FRAME_TOTAL_PIXEL_WIDTH (f
),
964 FRAME_TOTAL_PIXEL_HEIGHT (f
));
965 f
->output_data
.x
->hint_flags
= 0;
966 x_wm_set_size_hint (f
, 0, 0);
969 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
970 Must be done like this, because GtkWidget:s can have "hidden"
971 X Window that aren't accessible.
973 Return 0 if no widget match WDESC. */
976 xg_win_to_widget (Display
*dpy
, Window wdesc
)
979 GtkWidget
*gwdesc
= 0;
983 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
988 event
.any
.window
= gdkwin
;
989 gwdesc
= gtk_get_event_widget (&event
);
996 /* Set the background of widget W to PIXEL. */
999 xg_set_widget_bg (FRAME_PTR f
, GtkWidget
*w
, long unsigned int pixel
)
1005 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1007 bg
.red
= (double)xbg
.red
/65536.0;
1008 bg
.green
= (double)xbg
.green
/65536.0;
1009 bg
.blue
= (double)xbg
.blue
/65536.0;
1011 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1015 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1016 gdk_colormap_query_color (map
, pixel
, &bg
);
1017 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1021 /* Callback called when the gtk theme changes.
1022 We notify lisp code so it can fix faces used for region for example. */
1025 style_changed_cb (GObject
*go
,
1029 struct input_event event
;
1030 GdkDisplay
*gdpy
= (GdkDisplay
*) user_data
;
1031 const char *display_name
= gdk_display_get_name (gdpy
);
1032 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1035 event
.kind
= CONFIG_CHANGED_EVENT
;
1036 event
.frame_or_window
= build_string (display_name
);
1037 /* Theme doesn't change often, so intern is called seldom. */
1038 event
.arg
= intern ("theme-name");
1039 kbd_buffer_store_event (&event
);
1041 update_theme_scrollbar_width ();
1043 /* If scroll bar width changed, we need set the new size on all frames
1047 Lisp_Object rest
, frame
;
1048 FOR_EACH_FRAME (rest
, frame
)
1050 FRAME_PTR f
= XFRAME (frame
);
1051 if (FRAME_X_DISPLAY (f
) == dpy
)
1053 x_set_scroll_bar_default_width (f
);
1054 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
1060 /* Called when a delete-event occurs on WIDGET. */
1063 delete_cb (GtkWidget
*widget
,
1068 /* The event doesn't arrive in the normal event loop. Send event
1070 FRAME_PTR f
= (FRAME_PTR
) user_data
;
1071 struct input_event ie
;
1074 ie
.kind
= DELETE_WINDOW_EVENT
;
1075 XSETFRAME (ie
.frame_or_window
, f
);
1076 kbd_buffer_store_event (&ie
);
1082 /* Create and set up the GTK widgets for frame F.
1083 Return 0 if creation failed, non-zero otherwise. */
1086 xg_create_frame_widgets (FRAME_PTR f
)
1089 GtkWidget
*wvbox
, *whbox
;
1096 if (FRAME_X_EMBEDDED_P (f
))
1097 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
1099 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1101 xg_set_screen (wtop
, f
);
1103 wvbox
= gtk_vbox_new (FALSE
, 0);
1104 whbox
= gtk_hbox_new (FALSE
, 0);
1107 wfixed
= emacs_fixed_new (f
);
1109 wfixed
= gtk_fixed_new ();
1112 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1114 if (wtop
) gtk_widget_destroy (wtop
);
1115 if (wvbox
) gtk_widget_destroy (wvbox
);
1116 if (whbox
) gtk_widget_destroy (whbox
);
1117 if (wfixed
) gtk_widget_destroy (wfixed
);
1123 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1124 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1125 gtk_widget_set_name (wvbox
, "pane");
1126 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1128 /* If this frame has a title or name, set it in the title bar. */
1129 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1130 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1132 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1134 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1135 FRAME_GTK_WIDGET (f
) = wfixed
;
1136 f
->output_data
.x
->vbox_widget
= wvbox
;
1137 f
->output_data
.x
->hbox_widget
= whbox
;
1139 gtk_widget_set_has_window (wfixed
, TRUE
);
1141 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1142 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1143 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1145 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1146 update_frame_tool_bar (f
);
1148 /* We don't want this widget double buffered, because we draw on it
1149 with regular X drawing primitives, so from a GTK/GDK point of
1150 view, the widget is totally blank. When an expose comes, this
1151 will make the widget blank, and then Emacs redraws it. This flickers
1152 a lot, so we turn off double buffering. */
1153 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1155 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1156 SSDATA (Vx_resource_name
),
1157 SSDATA (Vx_resource_class
));
1159 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1160 GTK is to destroy the widget. We want Emacs to do that instead. */
1161 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1162 G_CALLBACK (delete_cb
), f
);
1164 /* Convert our geometry parameters into a geometry string
1166 GTK will itself handle calculating the real position this way. */
1167 xg_set_geometry (f
);
1169 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1171 gtk_widget_add_events (wfixed
,
1172 GDK_POINTER_MOTION_MASK
1174 | GDK_BUTTON_PRESS_MASK
1175 | GDK_BUTTON_RELEASE_MASK
1176 | GDK_KEY_PRESS_MASK
1177 | GDK_ENTER_NOTIFY_MASK
1178 | GDK_LEAVE_NOTIFY_MASK
1179 | GDK_FOCUS_CHANGE_MASK
1180 | GDK_STRUCTURE_MASK
1181 | GDK_VISIBILITY_NOTIFY_MASK
);
1183 /* Must realize the windows so the X window gets created. It is used
1184 by callers of this function. */
1185 gtk_widget_realize (wfixed
);
1186 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1188 /* Since GTK clears its window by filling with the background color,
1189 we must keep X and GTK background in sync. */
1190 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1193 /* Also, do not let any background pixmap to be set, this looks very
1194 bad as Emacs overwrites the background pixmap with its own idea
1195 of background color. */
1196 style
= gtk_widget_get_modifier_style (wfixed
);
1198 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1199 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1200 gtk_widget_modify_style (wfixed
, style
);
1202 gtk_widget_set_can_focus (wfixed
, TRUE
);
1203 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1206 #ifdef USE_GTK_TOOLTIP
1207 /* Steal a tool tip window we can move ourselves. */
1208 f
->output_data
.x
->ttip_widget
= 0;
1209 f
->output_data
.x
->ttip_lbl
= 0;
1210 f
->output_data
.x
->ttip_window
= 0;
1211 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1212 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1216 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1217 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1218 /* Only connect this signal once per screen. */
1219 if (! g_signal_handler_find (G_OBJECT (gs
),
1220 G_SIGNAL_MATCH_FUNC
,
1222 G_CALLBACK (style_changed_cb
),
1225 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1226 G_CALLBACK (style_changed_cb
),
1227 gdk_screen_get_display (screen
));
1237 xg_free_frame_widgets (FRAME_PTR f
)
1239 if (FRAME_GTK_OUTER_WIDGET (f
))
1241 #ifdef USE_GTK_TOOLTIP
1242 struct x_output
*x
= f
->output_data
.x
;
1244 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1245 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1246 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1247 #ifdef USE_GTK_TOOLTIP
1249 gtk_widget_destroy (x
->ttip_lbl
);
1251 g_object_unref (G_OBJECT (x
->ttip_widget
));
1256 /* Set the normal size hints for the window manager, for frame F.
1257 FLAGS is the flags word to use--or 0 meaning preserve the flags
1258 that the window now has.
1259 If USER_POSITION is nonzero, we set the User Position
1260 flag (this is useful when FLAGS is 0). */
1263 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
1265 /* Must use GTK routines here, otherwise GTK resets the size hints
1266 to its own defaults. */
1267 GdkGeometry size_hints
;
1268 gint hint_flags
= 0;
1269 int base_width
, base_height
;
1270 int min_rows
= 0, min_cols
= 0;
1271 int win_gravity
= f
->win_gravity
;
1273 /* Don't set size hints during initialization; that apparently leads
1274 to a race condition. See the thread at
1275 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1276 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1281 memset (&size_hints
, 0, sizeof (size_hints
));
1282 f
->output_data
.x
->size_hints
= size_hints
;
1283 f
->output_data
.x
->hint_flags
= hint_flags
;
1286 flags
= f
->size_hint_flags
;
1288 size_hints
= f
->output_data
.x
->size_hints
;
1289 hint_flags
= f
->output_data
.x
->hint_flags
;
1291 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1292 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1293 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1295 hint_flags
|= GDK_HINT_BASE_SIZE
;
1296 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0) + FRAME_TOOLBAR_WIDTH (f
);
1297 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
1298 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1300 check_frame_size (f
, &min_rows
, &min_cols
);
1302 size_hints
.base_width
= base_width
;
1303 size_hints
.base_height
= base_height
;
1304 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1305 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1307 /* These currently have a one to one mapping with the X values, but I
1308 don't think we should rely on that. */
1309 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1310 size_hints
.win_gravity
= 0;
1311 if (win_gravity
== NorthWestGravity
)
1312 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1313 else if (win_gravity
== NorthGravity
)
1314 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1315 else if (win_gravity
== NorthEastGravity
)
1316 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1317 else if (win_gravity
== WestGravity
)
1318 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1319 else if (win_gravity
== CenterGravity
)
1320 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1321 else if (win_gravity
== EastGravity
)
1322 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1323 else if (win_gravity
== SouthWestGravity
)
1324 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1325 else if (win_gravity
== SouthGravity
)
1326 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1327 else if (win_gravity
== SouthEastGravity
)
1328 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1329 else if (win_gravity
== StaticGravity
)
1330 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1334 hint_flags
&= ~GDK_HINT_POS
;
1335 hint_flags
|= GDK_HINT_USER_POS
;
1338 if (hint_flags
!= f
->output_data
.x
->hint_flags
1339 || memcmp (&size_hints
,
1340 &f
->output_data
.x
->size_hints
,
1341 sizeof (size_hints
)) != 0)
1344 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1345 NULL
, &size_hints
, hint_flags
);
1346 f
->output_data
.x
->size_hints
= size_hints
;
1347 f
->output_data
.x
->hint_flags
= hint_flags
;
1352 /* Change background color of a frame.
1353 Since GTK uses the background color to clear the window, we must
1354 keep the GTK and X colors in sync.
1355 F is the frame to change,
1356 BG is the pixel value to change to. */
1359 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
1361 if (FRAME_GTK_WIDGET (f
))
1364 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1370 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1371 functions so GTK does not overwrite the icon. */
1374 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1376 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1380 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1385 /***********************************************************************
1387 ***********************************************************************/
1388 /* Return the dialog title to use for a dialog of type KEY.
1389 This is the encoding used by lwlib. We use the same for GTK. */
1392 get_dialog_title (char key
)
1394 const char *title
= "";
1402 title
= "Information";
1421 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1422 the dialog, but return TRUE so the event does not propagate further
1423 in GTK. This prevents GTK from destroying the dialog widget automatically
1424 and we can always destrou the widget manually, regardles of how
1425 it was popped down (button press or WM_DELETE_WINDOW).
1426 W is the dialog widget.
1427 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1428 user_data is NULL (not used).
1430 Returns TRUE to end propagation of event. */
1433 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1435 gtk_widget_unmap (w
);
1439 /* Create a popup dialog window. See also xg_create_widget below.
1440 WV is a widget_value describing the dialog.
1441 SELECT_CB is the callback to use when a button has been pressed.
1442 DEACTIVATE_CB is the callback to use when the dialog pops down.
1444 Returns the GTK dialog widget. */
1447 create_dialog (widget_value
*wv
,
1448 GCallback select_cb
,
1449 GCallback deactivate_cb
)
1451 const char *title
= get_dialog_title (wv
->name
[0]);
1452 int total_buttons
= wv
->name
[1] - '0';
1453 int right_buttons
= wv
->name
[4] - '0';
1456 int button_spacing
= 10;
1457 GtkWidget
*wdialog
= gtk_dialog_new ();
1458 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1459 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1461 GtkWidget
*whbox_down
;
1463 /* If the number of buttons is greater than 4, make two rows of buttons
1464 instead. This looks better. */
1465 int make_two_rows
= total_buttons
> 4;
1467 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1468 left_buttons
= total_buttons
- right_buttons
;
1470 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1471 gtk_widget_set_name (wdialog
, "emacs-dialog");
1476 GtkWidget
*wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1477 GtkWidget
*whbox_up
= gtk_hbox_new (FALSE
, 0);
1478 whbox_down
= gtk_hbox_new (FALSE
, 0);
1480 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1481 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1482 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1484 cur_box
= GTK_BOX (whbox_up
);
1487 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1488 G_CALLBACK (dialog_delete_callback
), 0);
1492 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1493 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1496 for (item
= wv
->contents
; item
; item
= item
->next
)
1498 char *utf8_label
= get_utf8_string (item
->value
);
1502 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1504 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1505 /* This is the text part of the dialog. */
1506 w
= gtk_label_new (utf8_label
);
1507 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1508 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1509 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1511 /* Try to make dialog look better. Must realize first so
1512 the widget can calculate the size it needs. */
1513 gtk_widget_realize (w
);
1514 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1515 gtk_box_set_spacing (wvbox
, req
.height
);
1516 if (item
->value
&& strlen (item
->value
) > 0)
1517 button_spacing
= 2*req
.width
/strlen (item
->value
);
1521 /* This is one button to add to the dialog. */
1522 w
= gtk_button_new_with_label (utf8_label
);
1523 if (! item
->enabled
)
1524 gtk_widget_set_sensitive (w
, FALSE
);
1526 g_signal_connect (G_OBJECT (w
), "clicked",
1527 select_cb
, item
->call_data
);
1529 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1530 if (++button_nr
== left_buttons
)
1533 cur_box
= GTK_BOX (whbox_down
);
1535 gtk_box_pack_start (cur_box
,
1543 g_free (utf8_label
);
1549 struct xg_dialog_data
1557 /* Function that is called when the file or font dialogs pop down.
1558 W is the dialog widget, RESPONSE is the response code.
1559 USER_DATA is what we passed in to g_signal_connect. */
1562 xg_dialog_response_cb (GtkDialog
*w
,
1566 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1567 dd
->response
= response
;
1568 g_main_loop_quit (dd
->loop
);
1572 /* Destroy the dialog. This makes it pop down. */
1575 pop_down_dialog (Lisp_Object arg
)
1577 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1578 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1581 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1582 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1584 g_main_loop_quit (dd
->loop
);
1585 g_main_loop_unref (dd
->loop
);
1592 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1593 We pass in DATA as gpointer* so we can use this as a callback. */
1596 xg_maybe_add_timer (gpointer data
)
1598 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1599 EMACS_TIME next_time
= timer_check ();
1600 long secs
= EMACS_SECS (next_time
);
1601 long usecs
= EMACS_USECS (next_time
);
1605 if (secs
>= 0 && usecs
>= 0 && secs
< ((guint
)-1)/1000)
1607 dd
->timerid
= g_timeout_add (secs
* 1000 + usecs
/1000,
1615 /* Pops up a modal dialog W and waits for response.
1616 We don't use gtk_dialog_run because we want to process emacs timers.
1617 The dialog W is not destroyed when this function returns. */
1620 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1622 int count
= SPECPDL_INDEX ();
1623 struct xg_dialog_data dd
;
1625 xg_set_screen (w
, f
);
1626 gtk_window_set_transient_for (GTK_WINDOW (w
),
1627 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1628 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1629 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1631 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1632 dd
.response
= GTK_RESPONSE_CANCEL
;
1636 g_signal_connect (G_OBJECT (w
),
1638 G_CALLBACK (xg_dialog_response_cb
),
1640 /* Don't destroy the widget if closed by the window manager close button. */
1641 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1642 gtk_widget_show (w
);
1644 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1646 (void) xg_maybe_add_timer (&dd
);
1647 g_main_loop_run (dd
.loop
);
1650 unbind_to (count
, Qnil
);
1656 /***********************************************************************
1657 File dialog functions
1658 ***********************************************************************/
1659 /* Return non-zero if the old file selection dialog is being used.
1660 Return zero if not. */
1663 xg_uses_old_file_dialog (void)
1665 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1666 return x_gtk_use_old_file_dialog
;
1673 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1675 /* Return the selected file for file chooser dialog W.
1676 The returned string must be free:d. */
1679 xg_get_file_name_from_chooser (GtkWidget
*w
)
1681 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1684 /* Callback called when the "Show hidden files" toggle is pressed.
1685 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1688 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1690 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1692 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1693 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1697 /* Callback called when a property changes in a file chooser.
1698 GOBJECT is the file chooser dialog, ARG1 describes the property.
1699 USER_DATA is the toggle widget in the file chooser dialog.
1700 We use this to update the "Show hidden files" toggle when the user
1701 changes that property by right clicking in the file list. */
1704 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1706 if (strcmp (arg1
->name
, "show-hidden") == 0)
1708 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1709 gboolean visible
, toggle_on
;
1711 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1712 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1714 if (!!visible
!= !!toggle_on
)
1716 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1717 G_CALLBACK (xg_toggle_visibility_cb
),
1719 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1720 g_signal_handlers_unblock_by_func
1721 (G_OBJECT (wtoggle
),
1722 G_CALLBACK (xg_toggle_visibility_cb
),
1725 x_gtk_show_hidden_files
= visible
;
1729 /* Read a file name from the user using a file chooser dialog.
1730 F is the current frame.
1731 PROMPT is a prompt to show to the user. May not be NULL.
1732 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1733 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1734 file. *FUNC is set to a function that can be used to retrieve the
1735 selected file name from the returned widget.
1737 Returns the created widget. */
1740 xg_get_file_with_chooser (FRAME_PTR f
,
1742 char *default_filename
,
1743 int mustmatch_p
, int only_dir_p
,
1744 xg_get_file_func
*func
)
1748 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1749 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1750 GtkFileChooserAction action
= (mustmatch_p
?
1751 GTK_FILE_CHOOSER_ACTION_OPEN
:
1752 GTK_FILE_CHOOSER_ACTION_SAVE
);
1755 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1757 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1758 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1759 (mustmatch_p
|| only_dir_p
?
1760 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1763 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1765 wbox
= gtk_vbox_new (FALSE
, 0);
1766 gtk_widget_show (wbox
);
1767 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1769 if (x_gtk_show_hidden_files
)
1771 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1772 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1774 gtk_widget_show (wtoggle
);
1775 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1776 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1777 g_signal_connect (G_OBJECT (filewin
), "notify",
1778 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1780 if (x_gtk_file_dialog_help_text
)
1783 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1784 Show the C-l help text only for versions < 2.10. */
1785 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1786 strcat (msgbuf
, "\nType C-l to display a file name text entry box.\n");
1787 strcat (msgbuf
, "\nIf you don't like this file selector, use the "
1788 "corresponding\nkey binding or customize "
1789 "use-file-dialog to turn it off.");
1791 wmessage
= gtk_label_new (msgbuf
);
1792 gtk_widget_show (wmessage
);
1795 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1796 if (x_gtk_file_dialog_help_text
)
1797 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1798 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1800 if (default_filename
)
1803 struct gcpro gcpro1
;
1804 char *utf8_filename
;
1807 file
= build_string (default_filename
);
1809 /* File chooser does not understand ~/... in the file name. It must be
1810 an absolute name starting with /. */
1811 if (default_filename
[0] != '/')
1812 file
= Fexpand_file_name (file
, Qnil
);
1814 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1815 if (! NILP (Ffile_directory_p (file
)))
1816 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1820 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1822 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1824 char *cp
= strrchr (utf8_filename
, '/');
1826 else cp
= utf8_filename
;
1827 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1834 *func
= xg_get_file_name_from_chooser
;
1838 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1840 /* Return the selected file for file selector dialog W.
1841 The returned string must be free:d. */
1844 xg_get_file_name_from_selector (GtkWidget
*w
)
1846 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1847 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1850 /* Create a file selection dialog.
1851 F is the current frame.
1852 PROMPT is a prompt to show to the user. May not be NULL.
1853 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1854 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1855 file. *FUNC is set to a function that can be used to retrieve the
1856 selected file name from the returned widget.
1858 Returns the created widget. */
1861 xg_get_file_with_selection (FRAME_PTR f
,
1863 char *default_filename
,
1864 int mustmatch_p
, int only_dir_p
,
1865 xg_get_file_func
*func
)
1868 GtkFileSelection
*filesel
;
1870 filewin
= gtk_file_selection_new (prompt
);
1871 filesel
= GTK_FILE_SELECTION (filewin
);
1873 if (default_filename
)
1874 gtk_file_selection_set_filename (filesel
, default_filename
);
1878 /* The selection_entry part of filesel is not documented. */
1879 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1880 gtk_file_selection_hide_fileop_buttons (filesel
);
1883 *func
= xg_get_file_name_from_selector
;
1887 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1889 /* Read a file name from the user using a file dialog, either the old
1890 file selection dialog, or the new file chooser dialog. Which to use
1891 depends on what the GTK version used has, and what the value of
1892 gtk-use-old-file-dialog.
1893 F is the current frame.
1894 PROMPT is a prompt to show to the user. May not be NULL.
1895 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1896 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1899 Returns a file name or NULL if no file was selected.
1900 The returned string must be freed by the caller. */
1903 xg_get_file_name (FRAME_PTR f
,
1905 char *default_filename
,
1911 int filesel_done
= 0;
1912 xg_get_file_func func
;
1914 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
1915 /* I really don't know why this is needed, but without this the GLIBC add on
1916 library linuxthreads hangs when the Gnome file chooser backend creates
1918 sigblock (sigmask (__SIGRTMIN
));
1919 #endif /* HAVE_PTHREAD */
1921 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1923 if (xg_uses_old_file_dialog ())
1924 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1925 mustmatch_p
, only_dir_p
, &func
);
1927 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1928 mustmatch_p
, only_dir_p
, &func
);
1930 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1931 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1932 mustmatch_p
, only_dir_p
, &func
);
1933 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1935 gtk_widget_set_name (w
, "emacs-filedialog");
1937 filesel_done
= xg_dialog_run (f
, w
);
1939 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
1940 sigunblock (sigmask (__SIGRTMIN
));
1943 if (filesel_done
== GTK_RESPONSE_OK
)
1946 gtk_widget_destroy (w
);
1950 #ifdef HAVE_FREETYPE
1951 /* Pop up a GTK font selector and return the name of the font the user
1952 selects, as a C string. The returned font name follows GTK's own
1955 `FAMILY [VALUE1 VALUE2] SIZE'
1957 This can be parsed using font_parse_fcname in font.c.
1958 DEFAULT_NAME, if non-zero, is the default font name. */
1961 xg_get_font_name (FRAME_PTR f
, const char *default_name
)
1964 char *fontname
= NULL
;
1967 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
1968 sigblock (sigmask (__SIGRTMIN
));
1969 #endif /* HAVE_PTHREAD */
1971 w
= gtk_font_selection_dialog_new ("Pick a font");
1973 default_name
= "Monospace 10";
1974 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1977 gtk_widget_set_name (w
, "emacs-fontdialog");
1979 done
= xg_dialog_run (f
, w
);
1981 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
1982 sigunblock (sigmask (__SIGRTMIN
));
1985 if (done
== GTK_RESPONSE_OK
)
1986 fontname
= gtk_font_selection_dialog_get_font_name
1987 (GTK_FONT_SELECTION_DIALOG (w
));
1989 gtk_widget_destroy (w
);
1992 #endif /* HAVE_FREETYPE */
1996 /***********************************************************************
1998 ***********************************************************************/
2000 /* The name of menu items that can be used for customization. Since GTK
2001 RC files are very crude and primitive, we have to set this on all
2002 menu item names so a user can easily customize menu items. */
2004 #define MENU_ITEM_NAME "emacs-menuitem"
2007 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2008 during GC. The next member points to the items. */
2009 static xg_list_node xg_menu_cb_list
;
2011 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2012 during GC. The next member points to the items. */
2013 static xg_list_node xg_menu_item_cb_list
;
2015 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2016 F is the frame CL_DATA will be initialized for.
2017 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2019 The menu bar and all sub menus under the menu bar in a frame
2020 share the same structure, hence the reference count.
2022 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2023 allocated xg_menu_cb_data if CL_DATA is NULL. */
2025 static xg_menu_cb_data
*
2026 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
2030 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
2032 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2033 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2034 cl_data
->highlight_cb
= highlight_cb
;
2035 cl_data
->ref_count
= 0;
2037 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2040 cl_data
->ref_count
++;
2045 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2046 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2048 When the menu bar is updated, menu items may have been added and/or
2049 removed, so menu_bar_vector and menu_bar_items_used change. We must
2050 then update CL_DATA since it is used to determine which menu
2051 item that is invoked in the menu.
2052 HIGHLIGHT_CB could change, there is no check that the same
2053 function is given when modifying a menu bar as was given when
2054 creating the menu bar. */
2057 update_cl_data (xg_menu_cb_data
*cl_data
,
2059 GCallback highlight_cb
)
2064 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2065 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2066 cl_data
->highlight_cb
= highlight_cb
;
2070 /* Decrease reference count for CL_DATA.
2071 If reference count is zero, free CL_DATA. */
2074 unref_cl_data (xg_menu_cb_data
*cl_data
)
2076 if (cl_data
&& cl_data
->ref_count
> 0)
2078 cl_data
->ref_count
--;
2079 if (cl_data
->ref_count
== 0)
2081 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2087 /* Function that marks all lisp data during GC. */
2094 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2095 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2097 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2099 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2101 if (! NILP (cb_data
->help
))
2102 mark_object (cb_data
->help
);
2107 /* Callback called when a menu item is destroyed. Used to free data.
2108 W is the widget that is being destroyed (not used).
2109 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2112 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2116 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
2117 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2122 /* Callback called when the pointer enters/leaves a menu item.
2123 W is the parent of the menu item.
2124 EVENT is either an enter event or leave event.
2125 CLIENT_DATA is not used.
2127 Returns FALSE to tell GTK to keep processing this event. */
2130 menuitem_highlight_callback (GtkWidget
*w
,
2131 GdkEventCrossing
*event
,
2132 gpointer client_data
)
2135 GtkWidget
*subwidget
;
2136 xg_menu_item_cb_data
*data
;
2138 ev
.crossing
= *event
;
2139 subwidget
= gtk_get_event_widget (&ev
);
2140 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
2144 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2146 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2147 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2148 (*func
) (subwidget
, call_data
);
2155 /* Callback called when a menu is destroyed. Used to free data.
2156 W is the widget that is being destroyed (not used).
2157 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2160 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2162 unref_cl_data ((xg_menu_cb_data
*) client_data
);
2165 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2166 must be non-NULL) and can be inserted into a menu item.
2168 Returns the GtkHBox. */
2171 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2177 wbox
= gtk_hbox_new (FALSE
, 0);
2178 wlbl
= gtk_label_new (utf8_label
);
2179 wkey
= gtk_label_new (utf8_key
);
2181 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2182 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2184 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2185 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2187 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2188 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2189 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2194 /* Make and return a menu item widget with the key to the right.
2195 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2196 UTF8_KEY is the text representing the key binding.
2197 ITEM is the widget_value describing the menu item.
2199 GROUP is an in/out parameter. If the menu item to be created is not
2200 part of any radio menu group, *GROUP contains NULL on entry and exit.
2201 If the menu item to be created is part of a radio menu group, on entry
2202 *GROUP contains the group to use, or NULL if this is the first item
2203 in the group. On exit, *GROUP contains the radio item group.
2205 Unfortunately, keys don't line up as nicely as in Motif,
2206 but the MacOS X version doesn't either, so I guess that is OK. */
2209 make_menu_item (const char *utf8_label
,
2210 const char *utf8_key
,
2215 GtkWidget
*wtoadd
= 0;
2217 /* It has been observed that some menu items have a NULL name field.
2218 This will lead to this function being called with a NULL utf8_label.
2219 GTK crashes on that so we set a blank label. Why there is a NULL
2220 name remains to be investigated. */
2221 if (! utf8_label
) utf8_label
= " ";
2224 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2226 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2229 if (utf8_key
) w
= gtk_check_menu_item_new ();
2230 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2231 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2233 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2235 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2236 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2237 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2239 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2244 if (utf8_key
) w
= gtk_menu_item_new ();
2245 else w
= gtk_menu_item_new_with_label (utf8_label
);
2248 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2249 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2254 static int xg_detached_menus
;
2256 /* Returns non-zero if there are detached menus. */
2259 xg_have_tear_offs (void)
2261 return xg_detached_menus
> 0;
2264 /* Callback invoked when a detached menu window is removed. Here we
2265 decrease the xg_detached_menus count.
2266 WIDGET is the top level window that is removed (the parent of the menu).
2267 CLIENT_DATA is not used. */
2270 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2272 if (xg_detached_menus
> 0) --xg_detached_menus
;
2275 /* Callback invoked when a menu is detached. It increases the
2276 xg_detached_menus count.
2277 WIDGET is the GtkTearoffMenuItem.
2278 CLIENT_DATA is not used. */
2281 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2283 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2284 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2286 ++xg_detached_menus
;
2287 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2289 G_CALLBACK (tearoff_remove
), 0);
2294 /* Create a menu item widget, and connect the callbacks.
2295 ITEM decribes the menu item.
2296 F is the frame the created menu belongs to.
2297 SELECT_CB is the callback to use when a menu item is selected.
2298 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2299 CL_DATA points to the callback data to be used for this menu.
2300 GROUP is an in/out parameter. If the menu item to be created is not
2301 part of any radio menu group, *GROUP contains NULL on entry and exit.
2302 If the menu item to be created is part of a radio menu group, on entry
2303 *GROUP contains the group to use, or NULL if this is the first item
2304 in the group. On exit, *GROUP contains the radio item group.
2306 Returns the created GtkWidget. */
2309 xg_create_one_menuitem (widget_value
*item
,
2311 GCallback select_cb
,
2312 GCallback highlight_cb
,
2313 xg_menu_cb_data
*cl_data
,
2319 xg_menu_item_cb_data
*cb_data
;
2321 utf8_label
= get_utf8_string (item
->name
);
2322 utf8_key
= get_utf8_string (item
->key
);
2324 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2326 if (utf8_label
) g_free (utf8_label
);
2327 if (utf8_key
) g_free (utf8_key
);
2329 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2331 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2333 cb_data
->select_id
= 0;
2334 cb_data
->help
= item
->help
;
2335 cb_data
->cl_data
= cl_data
;
2336 cb_data
->call_data
= item
->call_data
;
2338 g_signal_connect (G_OBJECT (w
),
2340 G_CALLBACK (menuitem_destroy_callback
),
2343 /* Put cb_data in widget, so we can get at it when modifying menubar */
2344 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2346 /* final item, not a submenu */
2347 if (item
->call_data
&& ! item
->contents
)
2351 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2357 /* Create a full menu tree specified by DATA.
2358 F is the frame the created menu belongs to.
2359 SELECT_CB is the callback to use when a menu item is selected.
2360 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2361 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2362 POP_UP_P is non-zero if we shall create a popup menu.
2363 MENU_BAR_P is non-zero if we shall create a menu bar.
2364 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2365 if MENU_BAR_P is non-zero.
2366 TOPMENU is the topmost GtkWidget that others shall be placed under.
2367 It may be NULL, in that case we create the appropriate widget
2368 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2369 CL_DATA is the callback data we shall use for this menu, or NULL
2370 if we haven't set the first callback yet.
2371 NAME is the name to give to the top level menu if this function
2372 creates it. May be NULL to not set any name.
2374 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2377 This function calls itself to create submenus. */
2380 create_menus (widget_value
*data
,
2382 GCallback select_cb
,
2383 GCallback deactivate_cb
,
2384 GCallback highlight_cb
,
2389 xg_menu_cb_data
*cl_data
,
2393 GtkWidget
*wmenu
= topmenu
;
2394 GSList
*group
= NULL
;
2400 wmenu
= gtk_menu_new ();
2401 xg_set_screen (wmenu
, f
);
2402 /* Connect this to the menu instead of items so we get enter/leave for
2403 disabled items also. TODO: Still does not get enter/leave for
2404 disabled items in detached menus. */
2405 g_signal_connect (G_OBJECT (wmenu
),
2406 "enter-notify-event",
2407 G_CALLBACK (menuitem_highlight_callback
),
2409 g_signal_connect (G_OBJECT (wmenu
),
2410 "leave-notify-event",
2411 G_CALLBACK (menuitem_highlight_callback
),
2416 wmenu
= gtk_menu_bar_new ();
2417 /* Set width of menu bar to a small value so it doesn't enlarge
2418 a small initial frame size. The width will be set to the
2419 width of the frame later on when it is added to a container.
2420 height -1: Natural height. */
2421 gtk_widget_set_size_request (wmenu
, 1, -1);
2424 /* Put cl_data on the top menu for easier access. */
2425 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2426 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2427 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2428 G_CALLBACK (menu_destroy_callback
), cl_data
);
2431 gtk_widget_set_name (wmenu
, name
);
2434 g_signal_connect (G_OBJECT (wmenu
),
2435 "selection-done", deactivate_cb
, 0);
2438 if (! menu_bar_p
&& add_tearoff_p
)
2440 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2441 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2443 g_signal_connect (G_OBJECT (tearoff
), "activate",
2444 G_CALLBACK (tearoff_activate
), 0);
2447 for (item
= data
; item
; item
= item
->next
)
2451 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2452 && !menu_separator_name_p (item
->name
))
2455 /* A title for a popup. We do the same as GTK does when
2456 creating titles, but it does not look good. */
2458 utf8_label
= get_utf8_string (item
->name
);
2460 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2461 w
= gtk_menu_item_new_with_label (utf8_label
);
2462 gtk_widget_set_sensitive (w
, FALSE
);
2463 if (utf8_label
) g_free (utf8_label
);
2465 else if (menu_separator_name_p (item
->name
))
2468 /* GTK only have one separator type. */
2469 w
= gtk_separator_menu_item_new ();
2473 w
= xg_create_one_menuitem (item
,
2475 item
->contents
? 0 : select_cb
,
2480 /* Create a possibly empty submenu for menu bar items, since some
2481 themes don't highlight items correctly without it. */
2482 if (item
->contents
|| menu_bar_p
)
2484 GtkWidget
*submenu
= create_menus (item
->contents
,
2495 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2499 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2500 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2506 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2507 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2508 with some text and buttons.
2509 F is the frame the created item belongs to.
2510 NAME is the name to use for the top widget.
2511 VAL is a widget_value structure describing items to be created.
2512 SELECT_CB is the callback to use when a menu item is selected or
2513 a dialog button is pressed.
2514 DEACTIVATE_CB is the callback to use when an item is deactivated.
2515 For a menu, when a sub menu is not shown anymore, for a dialog it is
2516 called when the dialog is popped down.
2517 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2519 Returns the widget created. */
2522 xg_create_widget (const char *type
, const char *name
, FRAME_PTR f
, widget_value
*val
,
2523 GCallback select_cb
, GCallback deactivate_cb
,
2524 GCallback highlight_cb
)
2527 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2528 int pop_up_p
= strcmp (type
, "popup") == 0;
2530 if (strcmp (type
, "dialog") == 0)
2532 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2533 xg_set_screen (w
, f
);
2534 gtk_window_set_transient_for (GTK_WINDOW (w
),
2535 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2536 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2537 gtk_widget_set_name (w
, "emacs-dialog");
2538 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2540 else if (menu_bar_p
|| pop_up_p
)
2542 w
= create_menus (val
->contents
,
2554 /* Set the cursor to an arrow for popup menus when they are mapped.
2555 This is done by default for menu bar menus. */
2558 /* Must realize so the GdkWindow inside the widget is created. */
2559 gtk_widget_realize (w
);
2560 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2565 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2572 /* Return the label for menu item WITEM. */
2575 xg_get_menu_item_label (GtkMenuItem
*witem
)
2577 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2578 return gtk_label_get_label (wlabel
);
2581 /* Return non-zero if the menu item WITEM has the text LABEL. */
2584 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2587 char *utf8_label
= get_utf8_string (label
);
2588 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2590 if (! old_label
&& ! utf8_label
)
2592 else if (old_label
&& utf8_label
)
2593 is_same
= strcmp (utf8_label
, old_label
) == 0;
2595 if (utf8_label
) g_free (utf8_label
);
2600 /* Destroy widgets in LIST. */
2603 xg_destroy_widgets (GList
*list
)
2607 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2609 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2611 /* Destroying the widget will remove it from the container it is in. */
2612 gtk_widget_destroy (w
);
2616 /* Update the top level names in MENUBAR (i.e. not submenus).
2617 F is the frame the menu bar belongs to.
2618 *LIST is a list with the current menu bar names (menu item widgets).
2619 ITER is the item within *LIST that shall be updated.
2620 POS is the numerical position, starting at 0, of ITER in *LIST.
2621 VAL describes what the menu bar shall look like after the update.
2622 SELECT_CB is the callback to use when a menu item is selected.
2623 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2624 CL_DATA points to the callback data to be used for this menu bar.
2626 This function calls itself to walk through the menu bar names. */
2629 xg_update_menubar (GtkWidget
*menubar
,
2635 GCallback select_cb
,
2636 GCallback deactivate_cb
,
2637 GCallback highlight_cb
,
2638 xg_menu_cb_data
*cl_data
)
2640 if (! iter
&& ! val
)
2642 else if (iter
&& ! val
)
2644 /* Item(s) have been removed. Remove all remaining items. */
2645 xg_destroy_widgets (iter
);
2647 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2648 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2649 gtk_menu_item_new_with_label (""),
2655 else if (! iter
&& val
)
2657 /* Item(s) added. Add all new items in one call. */
2658 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2659 0, 1, 0, menubar
, cl_data
, 0);
2665 /* Below this neither iter or val is NULL */
2666 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2668 /* This item is still the same, check next item. */
2670 iter
= g_list_next (iter
);
2673 else /* This item is changed. */
2675 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2676 GtkMenuItem
*witem2
= 0;
2677 int val_in_menubar
= 0;
2678 int iter_in_new_menubar
= 0;
2682 /* See if the changed entry (val) is present later in the menu bar */
2684 iter2
&& ! val_in_menubar
;
2685 iter2
= g_list_next (iter2
))
2687 witem2
= GTK_MENU_ITEM (iter2
->data
);
2688 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2691 /* See if the current entry (iter) is present later in the
2692 specification for the new menu bar. */
2693 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2694 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2696 if (val_in_menubar
&& ! iter_in_new_menubar
)
2700 /* This corresponds to:
2705 g_object_ref (G_OBJECT (witem
));
2706 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2707 gtk_widget_destroy (GTK_WIDGET (witem
));
2709 /* Must get new list since the old changed. */
2710 g_list_free (*list
);
2711 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2712 while (nr
-- > 0) iter
= g_list_next (iter
);
2714 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2716 /* This corresponds to:
2719 Rename B to X. This might seem to be a strange thing to do,
2720 since if there is a menu under B it will be totally wrong for X.
2721 But consider editing a C file. Then there is a C-mode menu
2722 (corresponds to B above).
2723 If then doing C-x C-f the minibuf menu (X above) replaces the
2724 C-mode menu. When returning from the minibuffer, we get
2725 back the C-mode menu. Thus we do:
2726 Rename B to X (C-mode to minibuf menu)
2727 Rename X to B (minibuf to C-mode menu).
2728 If the X menu hasn't been invoked, the menu under B
2729 is up to date when leaving the minibuffer. */
2730 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2731 char *utf8_label
= get_utf8_string (val
->name
);
2732 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2734 gtk_label_set_text (wlabel
, utf8_label
);
2736 /* If this item has a submenu that has been detached, change
2737 the title in the WM decorations also. */
2738 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2739 /* Set the title of the detached window. */
2740 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2742 if (utf8_label
) g_free (utf8_label
);
2743 iter
= g_list_next (iter
);
2747 else if (! val_in_menubar
&& iter_in_new_menubar
)
2749 /* This corresponds to:
2756 GtkWidget
*w
= xg_create_one_menuitem (val
,
2763 /* Create a possibly empty submenu for menu bar items, since some
2764 themes don't highlight items correctly without it. */
2765 GtkWidget
*submenu
= create_menus (NULL
, f
,
2766 select_cb
, deactivate_cb
,
2768 0, 0, 0, 0, cl_data
, 0);
2769 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2770 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2771 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2773 g_list_free (*list
);
2774 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2775 while (nr
-- > 0) iter
= g_list_next (iter
);
2776 iter
= g_list_next (iter
);
2780 else /* if (val_in_menubar && iter_in_new_menubar) */
2783 /* This corresponds to:
2788 g_object_ref (G_OBJECT (witem2
));
2789 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2790 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2791 GTK_WIDGET (witem2
), pos
);
2792 g_object_unref (G_OBJECT (witem2
));
2794 g_list_free (*list
);
2795 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2796 while (nr
-- > 0) iter
= g_list_next (iter
);
2797 if (iter
) iter
= g_list_next (iter
);
2803 /* Update the rest of the menu bar. */
2804 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2805 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2808 /* Update the menu item W so it corresponds to VAL.
2809 SELECT_CB is the callback to use when a menu item is selected.
2810 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2811 CL_DATA is the data to set in the widget for menu invocation. */
2814 xg_update_menu_item (widget_value
*val
,
2816 GCallback select_cb
,
2817 GCallback highlight_cb
,
2818 xg_menu_cb_data
*cl_data
)
2825 const char *old_label
= 0;
2826 const char *old_key
= 0;
2827 xg_menu_item_cb_data
*cb_data
;
2829 wchild
= XG_BIN_CHILD (w
);
2830 utf8_label
= get_utf8_string (val
->name
);
2831 utf8_key
= get_utf8_string (val
->key
);
2833 /* See if W is a menu item with a key. See make_menu_item above. */
2834 if (GTK_IS_HBOX (wchild
))
2836 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2838 wlbl
= GTK_LABEL (list
->data
);
2839 wkey
= GTK_LABEL (list
->next
->data
);
2844 /* Remove the key and keep just the label. */
2845 g_object_ref (G_OBJECT (wlbl
));
2846 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2847 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2848 g_object_unref (G_OBJECT (wlbl
));
2853 else /* Just a label. */
2855 wlbl
= GTK_LABEL (wchild
);
2857 /* Check if there is now a key. */
2860 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2861 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2863 wlbl
= GTK_LABEL (list
->data
);
2864 wkey
= GTK_LABEL (list
->next
->data
);
2867 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2868 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2873 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2874 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2876 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2877 gtk_label_set_text (wkey
, utf8_key
);
2879 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2880 gtk_label_set_text (wlbl
, utf8_label
);
2882 if (utf8_key
) g_free (utf8_key
);
2883 if (utf8_label
) g_free (utf8_label
);
2885 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2886 gtk_widget_set_sensitive (w
, FALSE
);
2887 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2888 gtk_widget_set_sensitive (w
, TRUE
);
2890 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2894 cb_data
->call_data
= val
->call_data
;
2895 cb_data
->help
= val
->help
;
2896 cb_data
->cl_data
= cl_data
;
2898 /* We assume the callback functions don't change. */
2899 if (val
->call_data
&& ! val
->contents
)
2901 /* This item shall have a select callback. */
2902 if (! cb_data
->select_id
)
2904 = g_signal_connect (G_OBJECT (w
), "activate",
2905 select_cb
, cb_data
);
2907 else if (cb_data
->select_id
)
2909 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2910 cb_data
->select_id
= 0;
2915 /* Update the toggle menu item W so it corresponds to VAL. */
2918 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
2920 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2923 /* Update the radio menu item W so it corresponds to VAL. */
2926 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
2928 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2931 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2932 SUBMENU may be NULL, in that case a new menu is created.
2933 F is the frame the menu bar belongs to.
2934 VAL describes the contents of the menu bar.
2935 SELECT_CB is the callback to use when a menu item is selected.
2936 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2937 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2938 CL_DATA is the call back data to use for any newly created items.
2940 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2944 xg_update_submenu (GtkWidget
*submenu
,
2947 GCallback select_cb
,
2948 GCallback deactivate_cb
,
2949 GCallback highlight_cb
,
2950 xg_menu_cb_data
*cl_data
)
2952 GtkWidget
*newsub
= submenu
;
2956 int has_tearoff_p
= 0;
2957 GList
*first_radio
= 0;
2960 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2962 for (cur
= val
, iter
= list
;
2964 iter
= g_list_next (iter
), cur
= cur
->next
)
2966 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2968 /* Skip tearoff items, they have no counterpart in val. */
2969 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2972 iter
= g_list_next (iter
);
2973 if (iter
) w
= GTK_WIDGET (iter
->data
);
2977 /* Remember first radio button in a group. If we get a mismatch in
2978 a radio group we must rebuild the whole group so that the connections
2979 in GTK becomes correct. */
2980 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2982 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2983 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2986 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2988 if (! menu_separator_name_p (cur
->name
))
2991 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2993 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2995 xg_update_toggle_item (cur
, w
);
2996 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2998 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3000 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3002 xg_update_radio_item (cur
, w
);
3003 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3005 else if (GTK_IS_MENU_ITEM (w
))
3007 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3010 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3011 menu_separator_name_p (cur
->name
))
3014 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3016 sub
= gtk_menu_item_get_submenu (witem
);
3017 if (sub
&& ! cur
->contents
)
3019 /* Not a submenu anymore. */
3020 g_object_ref (G_OBJECT (sub
));
3021 remove_submenu (witem
);
3022 gtk_widget_destroy (sub
);
3024 else if (cur
->contents
)
3028 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3029 select_cb
, deactivate_cb
,
3030 highlight_cb
, cl_data
);
3032 /* If this item just became a submenu, we must set it. */
3034 gtk_menu_item_set_submenu (witem
, nsub
);
3039 /* Structural difference. Remove everything from here and down
3045 /* Remove widgets from first structual change. */
3048 /* If we are adding new menu items below, we must remove from
3049 first radio button so that radio groups become correct. */
3050 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3051 else xg_destroy_widgets (iter
);
3056 /* More items added. Create them. */
3057 newsub
= create_menus (cur
,
3070 if (list
) g_list_free (list
);
3075 /* Update the MENUBAR.
3076 F is the frame the menu bar belongs to.
3077 VAL describes the contents of the menu bar.
3078 If DEEP_P is non-zero, rebuild all but the top level menu names in
3079 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3080 SELECT_CB is the callback to use when a menu item is selected.
3081 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3082 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3085 xg_modify_menubar_widgets (GtkWidget
*menubar
, FRAME_PTR f
, widget_value
*val
,
3087 GCallback select_cb
, GCallback deactivate_cb
,
3088 GCallback highlight_cb
)
3090 xg_menu_cb_data
*cl_data
;
3091 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3095 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
3098 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3099 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3105 /* Update all sub menus.
3106 We must keep the submenus (GTK menu item widgets) since the
3107 X Window in the XEvent that activates the menu are those widgets. */
3109 /* Update cl_data, menu_item things in F may have changed. */
3110 update_cl_data (cl_data
, f
, highlight_cb
);
3112 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3117 GtkMenuItem
*witem
= 0;
3119 /* Find sub menu that corresponds to val and update it. */
3120 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3122 witem
= GTK_MENU_ITEM (iter
->data
);
3123 if (xg_item_label_same_p (witem
, cur
->name
))
3125 sub
= gtk_menu_item_get_submenu (witem
);
3130 newsub
= xg_update_submenu (sub
,
3137 /* sub may still be NULL. If we just updated non deep and added
3138 a new menu bar item, it has no sub menu yet. So we set the
3139 newly created sub menu under witem. */
3140 if (newsub
!= sub
&& witem
!= 0)
3142 xg_set_screen (newsub
, f
);
3143 gtk_menu_item_set_submenu (witem
, newsub
);
3149 gtk_widget_show_all (menubar
);
3152 /* Callback called when the menu bar W is mapped.
3153 Used to find the height of the menu bar if we didn't get it
3154 after showing the widget. */
3157 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3160 FRAME_PTR f
= (FRAME_PTR
) user_data
;
3161 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3162 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3164 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3165 xg_height_or_width_changed (f
);
3169 /* Recompute all the widgets of frame F, when the menu bar has been
3170 changed. Value is non-zero if widgets were updated. */
3173 xg_update_frame_menubar (FRAME_PTR f
)
3175 struct x_output
*x
= f
->output_data
.x
;
3178 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3181 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3182 return 0; /* Already done this, happens for frames created invisible. */
3186 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3188 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3190 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3191 gtk_widget_show_all (x
->menubar_widget
);
3192 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3194 /* If menu bar doesn't know its height yet, cheat a little so the frame
3195 doesn't jump so much when resized later in menubar_map_cb. */
3196 if (req
.height
== 0)
3199 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3201 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3202 xg_height_or_width_changed (f
);
3209 /* Get rid of the menu bar of frame F, and free its storage.
3210 This is used when deleting a frame, and when turning off the menu bar. */
3213 free_frame_menubar (FRAME_PTR f
)
3215 struct x_output
*x
= f
->output_data
.x
;
3217 if (x
->menubar_widget
)
3221 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3222 /* The menubar and its children shall be deleted when removed from
3224 x
->menubar_widget
= 0;
3225 FRAME_MENUBAR_HEIGHT (f
) = 0;
3226 xg_height_or_width_changed (f
);
3232 xg_event_is_for_menubar (FRAME_PTR f
, XEvent
*event
)
3234 struct x_output
*x
= f
->output_data
.x
;
3243 if (! x
->menubar_widget
) return 0;
3245 if (! (event
->xbutton
.x
>= 0
3246 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3247 && event
->xbutton
.y
>= 0
3248 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3249 && event
->xbutton
.same_screen
))
3252 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3253 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3255 gevent
.any
.window
= gw
;
3256 gwdesc
= gtk_get_event_widget (&gevent
);
3257 if (! gwdesc
) return 0;
3258 if (! GTK_IS_MENU_BAR (gwdesc
)
3259 && ! GTK_IS_MENU_ITEM (gwdesc
)
3260 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3263 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3264 if (! list
) return 0;
3265 rec
.x
= event
->xbutton
.x
;
3266 rec
.y
= event
->xbutton
.y
;
3270 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3272 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3273 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3277 return iter
== 0 ? 0 : 1;
3282 /***********************************************************************
3283 Scroll bar functions
3284 ***********************************************************************/
3287 /* Setting scroll bar values invokes the callback. Use this variable
3288 to indicate that callback should do nothing. */
3290 int xg_ignore_gtk_scrollbar
;
3292 /* The width of the scroll bar for the current theme. */
3294 static int scroll_bar_width_for_theme
;
3296 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3297 may be larger than 32 bits. Keep a mapping from integer index to widget
3298 pointers to get around the 32 bit limitation. */
3302 GtkWidget
**widgets
;
3307 /* Grow this much every time we need to allocate more */
3309 #define ID_TO_WIDGET_INCR 32
3311 /* Store the widget pointer W in id_to_widget and return the integer index. */
3314 xg_store_widget_in_map (GtkWidget
*w
)
3318 if (id_to_widget
.max_size
== id_to_widget
.used
)
3321 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3322 memory_full (SIZE_MAX
);
3324 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3325 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3326 new_size
, sizeof (GtkWidget
*));
3328 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3329 id_to_widget
.widgets
[i
] = 0;
3330 id_to_widget
.max_size
= new_size
;
3333 /* Just loop over the array and find a free place. After all,
3334 how many scroll bars are we creating? Should be a small number.
3335 The check above guarantees we will find a free place. */
3336 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3338 if (! id_to_widget
.widgets
[i
])
3340 id_to_widget
.widgets
[i
] = w
;
3341 ++id_to_widget
.used
;
3347 /* Should never end up here */
3351 /* Remove pointer at IDX from id_to_widget.
3352 Called when scroll bar is destroyed. */
3355 xg_remove_widget_from_map (ptrdiff_t idx
)
3357 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3359 id_to_widget
.widgets
[idx
] = 0;
3360 --id_to_widget
.used
;
3364 /* Get the widget pointer at IDX from id_to_widget. */
3367 xg_get_widget_from_map (ptrdiff_t idx
)
3369 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3370 return id_to_widget
.widgets
[idx
];
3376 update_theme_scrollbar_width (void)
3379 GtkAdjustment
*vadj
;
3386 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3387 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3388 g_object_ref_sink (G_OBJECT (wscroll
));
3389 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3390 gtk_widget_destroy (wscroll
);
3391 g_object_unref (G_OBJECT (wscroll
));
3394 scroll_bar_width_for_theme
= w
;
3398 xg_get_default_scrollbar_width (void)
3400 return scroll_bar_width_for_theme
;
3403 /* Return the scrollbar id for X Window WID on display DPY.
3404 Return -1 if WID not in id_to_widget. */
3407 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3412 w
= xg_win_to_widget (dpy
, wid
);
3416 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3417 if (id_to_widget
.widgets
[idx
] == w
)
3424 /* Callback invoked when scroll bar WIDGET is destroyed.
3425 DATA is the index into id_to_widget for WIDGET.
3426 We free pointer to last scroll bar values here and remove the index. */
3429 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3431 intptr_t id
= (intptr_t) data
;
3432 xg_remove_widget_from_map (id
);
3435 /* Create a scroll bar widget for frame F. Store the scroll bar
3437 SCROLL_CALLBACK is the callback to invoke when the value of the
3439 END_CALLBACK is the callback to invoke when scrolling ends.
3440 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3441 to set resources for the widget. */
3444 xg_create_scroll_bar (FRAME_PTR f
,
3445 struct scroll_bar
*bar
,
3446 GCallback scroll_callback
,
3447 GCallback end_callback
,
3448 const char *scroll_bar_name
)
3454 GtkAdjustment
*vadj
;
3459 /* Page, step increment values are not so important here, they
3460 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3461 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3464 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3465 webox
= gtk_event_box_new ();
3466 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3468 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3470 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3472 scroll_id
= xg_store_widget_in_map (wscroll
);
3474 g_signal_connect (G_OBJECT (wscroll
),
3476 G_CALLBACK (xg_gtk_scroll_destroy
),
3477 (gpointer
) scroll_id
);
3478 g_signal_connect (G_OBJECT (wscroll
),
3482 g_signal_connect (G_OBJECT (wscroll
),
3483 "button-release-event",
3487 /* The scroll bar widget does not draw on a window of its own. Instead
3488 it draws on the parent window, in this case the edit widget. So
3489 whenever the edit widget is cleared, the scroll bar needs to redraw
3490 also, which causes flicker. Put an event box between the edit widget
3491 and the scroll bar, so the scroll bar instead draws itself on the
3492 event box window. */
3493 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3494 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3497 /* Set the cursor to an arrow. */
3498 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3500 bar
->x_window
= scroll_id
;
3503 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3506 xg_remove_scroll_bar (FRAME_PTR f
, ptrdiff_t scrollbar_id
)
3508 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3511 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3512 gtk_widget_destroy (w
);
3513 gtk_widget_destroy (wparent
);
3514 SET_FRAME_GARBAGED (f
);
3518 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3520 TOP/LEFT are the new pixel positions where the bar shall appear.
3521 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3524 xg_update_scrollbar_pos (FRAME_PTR f
,
3525 ptrdiff_t scrollbar_id
,
3532 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3536 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3537 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3540 /* Clear out old position. */
3541 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3542 if (gtk_widget_get_parent (wparent
) == wfixed
)
3544 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3545 "x", &oldx
, "y", &oldy
, NULL
);
3546 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3549 /* Move and resize to new values. */
3550 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3551 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3554 /* No room. Hide scroll bar as some themes output a warning if
3555 the height is less than the min size. */
3556 gtk_widget_hide (wparent
);
3557 gtk_widget_hide (wscroll
);
3561 gtk_widget_show_all (wparent
);
3562 gtk_widget_set_size_request (wscroll
, width
, height
);
3564 gtk_widget_queue_draw (wfixed
);
3565 gdk_window_process_all_updates ();
3566 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3568 /* Clear under old scroll bar position. This must be done after
3569 the gtk_widget_queue_draw and gdk_window_process_all_updates
3571 x_clear_area (FRAME_X_DISPLAY (f
),
3573 oldx
, oldy
, oldw
, oldh
, 0);
3576 /* GTK does not redraw until the main loop is entered again, but
3577 if there are no X events pending we will not enter it. So we sync
3578 here to get some events. */
3581 SET_FRAME_GARBAGED (f
);
3582 cancel_mouse_face (f
);
3586 /* Get the current value of the range, truncated to an integer. */
3589 int_gtk_range_get_value (GtkRange
*range
)
3591 return gtk_range_get_value (range
);
3595 /* Set the thumb size and position of scroll bar BAR. We are currently
3596 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3599 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3604 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3606 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3608 if (wscroll
&& NILP (bar
->dragging
))
3618 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3620 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3621 rather than the real portion value. This makes the thumb less likely
3622 to resize and that looks better. */
3623 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3624 /* When the thumb is at the bottom, position == whole.
3625 So we need to increase `whole' to make space for the thumb. */
3632 top
= (gdouble
) position
/ whole
;
3633 shown
= (gdouble
) portion
/ whole
;
3636 size
= shown
* XG_SB_RANGE
;
3637 size
= min (size
, XG_SB_RANGE
);
3638 size
= max (size
, 1);
3640 value
= top
* XG_SB_RANGE
;
3641 value
= min (value
, XG_SB_MAX
- size
);
3642 value
= max (value
, XG_SB_MIN
);
3644 /* Assume all lines are of equal size. */
3645 new_step
= size
/ max (1, FRAME_LINES (f
));
3647 old_size
= gtk_adjustment_get_page_size (adj
);
3648 if (old_size
!= size
)
3650 int old_step
= gtk_adjustment_get_step_increment (adj
);
3651 if (old_step
!= new_step
)
3653 gtk_adjustment_set_page_size (adj
, size
);
3654 gtk_adjustment_set_step_increment (adj
, new_step
);
3655 /* Assume a page increment is about 95% of the page size */
3656 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3661 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3665 /* gtk_range_set_value invokes the callback. Set
3666 ignore_gtk_scrollbar to make the callback do nothing */
3667 xg_ignore_gtk_scrollbar
= 1;
3669 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3670 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3672 gtk_adjustment_changed (adj
);
3674 xg_ignore_gtk_scrollbar
= 0;
3681 /* Return non-zero if EVENT is for a scroll bar in frame F.
3682 When the same X window is used for several Gtk+ widgets, we cannot
3683 say for sure based on the X window alone if an event is for the
3684 frame. This function does additional checks.
3686 Return non-zero if the event is for a scroll bar, zero otherwise. */
3689 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3693 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3695 /* Check if press occurred outside the edit widget. */
3696 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3697 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3698 != gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3701 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3702 || event
->type
== MotionNotify
))
3704 /* If we are releasing or moving the scroll bar, it has the grab. */
3705 GtkWidget
*w
= gtk_grab_get_current ();
3706 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3714 /***********************************************************************
3716 ***********************************************************************/
3717 /* The key for the data we put in the GtkImage widgets. The data is
3718 the image used by Emacs. We use this to see if we need to update
3719 the GtkImage with a new image. */
3720 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3722 /* The key for storing the latest modifiers so the activate callback can
3724 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3726 /* The key for storing the button widget in its proxy menu item. */
3727 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3729 /* The key for the data we put in the GtkImage widgets. The data is
3730 the stock name used by Emacs. We use this to see if we need to update
3731 the GtkImage with a new image. */
3732 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3734 /* As above, but this is used for named theme widgets, as opposed to
3736 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3738 /* Callback function invoked when a tool bar item is pressed.
3739 W is the button widget in the tool bar that got pressed,
3740 CLIENT_DATA is an integer that is the index of the button in the
3741 tool bar. 0 is the first button. */
3744 xg_tool_bar_button_cb (GtkWidget
*widget
,
3745 GdkEventButton
*event
,
3748 intptr_t state
= event
->state
;
3749 gpointer ptr
= (gpointer
) state
;
3750 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3755 /* Callback function invoked when a tool bar item is pressed.
3756 W is the button widget in the tool bar that got pressed,
3757 CLIENT_DATA is an integer that is the index of the button in the
3758 tool bar. 0 is the first button. */
3761 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3763 intptr_t idx
= (intptr_t) client_data
;
3764 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3765 intptr_t mod
= (intptr_t) gmod
;
3767 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3768 Lisp_Object key
, frame
;
3769 struct input_event event
;
3772 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3775 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3777 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3778 XSETFRAME (frame
, f
);
3780 /* We generate two events here. The first one is to set the prefix
3781 to `(tool_bar)', see keyboard.c. */
3782 event
.kind
= TOOL_BAR_EVENT
;
3783 event
.frame_or_window
= frame
;
3785 kbd_buffer_store_event (&event
);
3787 event
.kind
= TOOL_BAR_EVENT
;
3788 event
.frame_or_window
= frame
;
3790 /* Convert between the modifier bits GDK uses and the modifier bits
3791 Emacs uses. This assumes GDK and X masks are the same, which they are when
3793 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3794 kbd_buffer_store_event (&event
);
3796 /* Return focus to the frame after we have clicked on a detached
3798 Fx_focus_frame (frame
);
3801 /* Callback function invoked when a tool bar item is pressed in a detached
3802 tool bar or the overflow drop down menu.
3803 We just call xg_tool_bar_callback.
3804 W is the menu item widget that got pressed,
3805 CLIENT_DATA is an integer that is the index of the button in the
3806 tool bar. 0 is the first button. */
3809 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3811 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3812 XG_TOOL_BAR_PROXY_BUTTON
));
3813 xg_tool_bar_callback (wbutton
, client_data
);
3818 xg_tool_bar_help_callback (GtkWidget
*w
,
3819 GdkEventCrossing
*event
,
3820 gpointer client_data
);
3822 /* This callback is called when a help is to be shown for an item in
3823 the detached tool bar when the detached tool bar it is not expanded. */
3826 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3827 GdkEventCrossing
*event
,
3828 gpointer client_data
)
3830 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3831 XG_TOOL_BAR_PROXY_BUTTON
));
3833 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3837 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3839 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3840 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3841 GtkWidget
*c2
= clist
->next
? (GtkWidget
*) clist
->next
->data
: NULL
;
3843 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3844 g_list_free (clist
);
3845 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3849 /* This callback is called when a tool item should create a proxy item,
3850 such as for the overflow menu. Also called when the tool bar is detached.
3851 If we don't create a proxy menu item, the detached tool bar will be
3855 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3857 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
3858 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
3860 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3861 GtkImage
*wimage
= GTK_IMAGE (c1
);
3862 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3863 (wlbl
? gtk_label_get_text (wlbl
) : "");
3864 GtkWidget
*wmenuimage
;
3867 if (gtk_button_get_use_stock (wbutton
))
3868 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3869 GTK_ICON_SIZE_MENU
);
3872 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3873 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3875 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
3877 if (store_type
== GTK_IMAGE_STOCK
)
3880 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3881 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3883 else if (store_type
== GTK_IMAGE_ICON_SET
)
3885 GtkIconSet
*icon_set
;
3886 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3887 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3888 GTK_ICON_SIZE_MENU
);
3890 else if (store_type
== GTK_IMAGE_PIXBUF
)
3895 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3898 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3900 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3901 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3902 GDK_INTERP_BILINEAR
);
3904 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3908 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3912 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3914 const gchar
*icon_name
;
3915 GtkIconSize icon_size
;
3917 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3918 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3919 GTK_ICON_SIZE_MENU
);
3923 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3928 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3930 g_signal_connect (G_OBJECT (wmenuitem
),
3932 G_CALLBACK (xg_tool_bar_proxy_callback
),
3936 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3937 (gpointer
) wbutton
);
3938 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3939 gtk_widget_set_sensitive (wmenuitem
,
3940 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
3942 /* Use enter/leave notify to show help. We use the events
3943 rather than the GtkButton specific signals "enter" and
3944 "leave", so we can have only one callback. The event
3945 will tell us what kind of event it is. */
3946 g_signal_connect (G_OBJECT (wmenuitem
),
3947 "enter-notify-event",
3948 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3950 g_signal_connect (G_OBJECT (wmenuitem
),
3951 "leave-notify-event",
3952 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3958 /* This callback is called when a tool bar is detached. We must set
3959 the height of the tool bar to zero when this happens so frame sizes
3960 are correctly calculated.
3961 WBOX is the handle box widget that enables detach/attach of the tool bar.
3962 W is the tool bar widget.
3963 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3966 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
3968 gpointer client_data
)
3970 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3972 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3977 GtkRequisition req
, req2
;
3978 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3979 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
3980 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
3981 req
.width
-= req2
.width
;
3982 req
.height
-= req2
.height
;
3983 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
3984 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
3985 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
3986 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
3987 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
3988 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
3989 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
3990 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
3991 xg_height_or_width_changed (f
);
3995 /* This callback is called when a tool bar is reattached. We must set
3996 the height of the tool bar when this happens so frame sizes
3997 are correctly calculated.
3998 WBOX is the handle box widget that enables detach/attach of the tool bar.
3999 W is the tool bar widget.
4000 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4003 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
4005 gpointer client_data
)
4007 FRAME_PTR f
= (FRAME_PTR
) client_data
;
4008 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4012 GtkRequisition req
, req2
;
4013 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
4014 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4015 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4016 req
.width
+= req2
.width
;
4017 req
.height
+= req2
.height
;
4018 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4019 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4020 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4021 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4022 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4023 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4024 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4025 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4026 xg_height_or_width_changed (f
);
4030 /* This callback is called when the mouse enters or leaves a tool bar item.
4031 It is used for displaying and hiding the help text.
4032 W is the tool bar item, a button.
4033 EVENT is either an enter event or leave event.
4034 CLIENT_DATA is an integer that is the index of the button in the
4035 tool bar. 0 is the first button.
4037 Returns FALSE to tell GTK to keep processing this event. */
4040 xg_tool_bar_help_callback (GtkWidget
*w
,
4041 GdkEventCrossing
*event
,
4042 gpointer client_data
)
4044 intptr_t idx
= (intptr_t) client_data
;
4045 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4046 Lisp_Object help
, frame
;
4048 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4051 if (event
->type
== GDK_ENTER_NOTIFY
)
4053 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4054 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4057 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4062 XSETFRAME (frame
, f
);
4063 kbd_buffer_store_help_event (frame
, help
);
4069 /* This callback is called when a tool bar item shall be redrawn.
4070 It modifies the expose event so that the GtkImage widget redraws the
4071 whole image. This to overcome a bug that makes GtkImage draw the image
4072 in the wrong place when it tries to redraw just a part of the image.
4073 W is the GtkImage to be redrawn.
4074 EVENT is the expose event for W.
4075 CLIENT_DATA is unused.
4077 Returns FALSE to tell GTK to keep processing this event. */
4081 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4082 GdkEventExpose
*event
,
4083 gpointer client_data
)
4087 gdk_drawable_get_size (event
->window
, &width
, &height
);
4088 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4089 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4091 event
->area
.x
= max (0, event
->area
.x
);
4092 event
->area
.y
= max (0, event
->area
.y
);
4094 event
->area
.width
= max (width
, event
->area
.width
);
4095 event
->area
.height
= max (height
, event
->area
.height
);
4101 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4102 #define toolbar_set_orientation(w, o) \
4103 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4105 #define toolbar_set_orientation(w, o) \
4106 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4109 /* Attach a tool bar to frame F. */
4112 xg_pack_tool_bar (FRAME_PTR f
, Lisp_Object pos
)
4114 struct x_output
*x
= f
->output_data
.x
;
4115 int into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4117 toolbar_set_orientation (x
->toolbar_widget
,
4119 ? GTK_ORIENTATION_VERTICAL
4120 : GTK_ORIENTATION_HORIZONTAL
);
4121 if (!x
->handlebox_widget
)
4123 x
->handlebox_widget
= gtk_handle_box_new ();
4124 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4125 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4126 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4127 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4128 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4134 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4136 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), x
->handlebox_widget
,
4139 if (EQ (pos
, Qleft
))
4140 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4141 x
->handlebox_widget
,
4143 x
->toolbar_in_hbox
= 1;
4147 int vbox_pos
= x
->menubar_widget
? 1 : 0;
4148 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4150 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
4154 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4155 x
->handlebox_widget
,
4157 x
->toolbar_in_hbox
= 0;
4161 /* Create a tool bar for frame F. */
4164 xg_create_tool_bar (FRAME_PTR f
)
4166 struct x_output
*x
= f
->output_data
.x
;
4168 x
->toolbar_widget
= gtk_toolbar_new ();
4169 x
->toolbar_detached
= 0;
4171 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4173 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4174 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4178 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4180 /* Find the right-to-left image named by RTL in the tool bar images for F.
4181 Returns IMAGE if RTL is not found. */
4184 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
4187 Lisp_Object file
, rtl_name
;
4188 struct gcpro gcpro1
, gcpro2
;
4189 GCPRO2 (file
, rtl_name
);
4191 rtl_name
= Ffile_name_nondirectory (rtl
);
4193 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4195 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4196 if (!NILP (file
= file_for_image (rtl_image
)))
4198 file
= call1 (intern ("file-name-sans-extension"),
4199 Ffile_name_nondirectory (file
));
4200 if (EQ (Fequal (file
, rtl_name
), Qt
))
4211 static GtkToolItem
*
4212 xg_make_tool_item (FRAME_PTR f
,
4214 GtkWidget
**wbutton
,
4216 int i
, int horiz
, int text_image
)
4218 GtkToolItem
*ti
= gtk_tool_item_new ();
4219 GtkWidget
*vb
= horiz
? gtk_hbox_new (FALSE
, 0) : gtk_vbox_new (FALSE
, 0);
4220 GtkWidget
*wb
= gtk_button_new ();
4221 GtkWidget
*weventbox
= gtk_event_box_new ();
4223 if (wimage
&& !text_image
)
4224 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4226 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4227 if (wimage
&& text_image
)
4228 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4230 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4231 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4232 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4233 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4234 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4239 gpointer gi
= (gpointer
) ii
;
4241 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4242 G_CALLBACK (xg_tool_bar_menu_proxy
),
4245 g_signal_connect (G_OBJECT (wb
), "clicked",
4246 G_CALLBACK (xg_tool_bar_callback
),
4249 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4252 /* Catch expose events to overcome an annoying redraw bug, see
4253 comment for xg_tool_bar_item_expose_callback. */
4254 g_signal_connect (G_OBJECT (ti
),
4256 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4259 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4261 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
4262 no distinction based on modifiers in the activate callback,
4263 so we have to do it ourselves. */
4264 g_signal_connect (wb
, "button-release-event",
4265 G_CALLBACK (xg_tool_bar_button_cb
),
4268 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4270 /* Use enter/leave notify to show help. We use the events
4271 rather than the GtkButton specific signals "enter" and
4272 "leave", so we can have only one callback. The event
4273 will tell us what kind of event it is. */
4274 /* The EMACS_INT cast avoids a warning. */
4275 g_signal_connect (G_OBJECT (weventbox
),
4276 "enter-notify-event",
4277 G_CALLBACK (xg_tool_bar_help_callback
),
4279 g_signal_connect (G_OBJECT (weventbox
),
4280 "leave-notify-event",
4281 G_CALLBACK (xg_tool_bar_help_callback
),
4285 if (wbutton
) *wbutton
= wb
;
4291 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4292 const char *icon_name
, const struct image
*img
,
4293 const char *label
, int horiz
)
4297 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4298 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4300 /* Check if the tool icon matches. */
4303 old
= g_object_get_data (G_OBJECT (wimage
),
4304 XG_TOOL_BAR_STOCK_NAME
);
4305 if (!old
|| strcmp (old
, stock_name
))
4310 old
= g_object_get_data (G_OBJECT (wimage
),
4311 XG_TOOL_BAR_ICON_NAME
);
4312 if (!old
|| strcmp (old
, icon_name
))
4317 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4318 XG_TOOL_BAR_IMAGE_DATA
);
4319 Pixmap old_img
= (Pixmap
) gold_img
;
4320 if (old_img
!= img
->pixmap
)
4324 /* Check button configuration and label. */
4325 if ((horiz
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
))
4326 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4329 /* Ensure label is correct. */
4331 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4336 xg_update_tool_bar_sizes (FRAME_PTR f
)
4338 struct x_output
*x
= f
->output_data
.x
;
4340 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4342 gtk_widget_get_preferred_size (GTK_WIDGET (x
->handlebox_widget
), NULL
, &req
);
4343 if (x
->toolbar_in_hbox
)
4346 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4347 x
->handlebox_widget
,
4348 "position", &pos
, NULL
);
4349 if (pos
== 0) nl
= req
.width
;
4350 else nr
= req
.width
;
4355 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4356 x
->handlebox_widget
,
4357 "position", &pos
, NULL
);
4358 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4359 else nb
= req
.height
;
4362 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4363 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4364 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4365 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4367 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4368 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4369 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4370 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4371 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4372 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4380 /* Update the tool bar for frame F. Add new buttons and remove old. */
4383 update_frame_tool_bar (FRAME_PTR f
)
4386 struct x_output
*x
= f
->output_data
.x
;
4387 int hmargin
= 0, vmargin
= 0;
4388 GtkToolbar
*wtoolbar
;
4390 GtkTextDirection dir
;
4391 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
4393 int text_image
, horiz
;
4395 if (! FRAME_GTK_WIDGET (f
))
4400 if (INTEGERP (Vtool_bar_button_margin
)
4401 && XINT (Vtool_bar_button_margin
) > 0)
4403 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4404 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4406 else if (CONSP (Vtool_bar_button_margin
))
4408 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
4409 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
4410 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4412 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
4413 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
4414 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4417 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4418 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4419 i.e. zero. This means that margins less than
4420 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4421 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4422 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4424 if (! x
->toolbar_widget
)
4425 xg_create_tool_bar (f
);
4427 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4428 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4430 style
= Ftool_bar_get_system_style ();
4431 text_image
= EQ (style
, Qtext_image_horiz
);
4432 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4434 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4436 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4437 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4441 struct image
*img
= NULL
;
4443 Lisp_Object stock
= Qnil
;
4444 GtkStockItem stock_item
;
4445 char *stock_name
= NULL
;
4446 char *icon_name
= NULL
;
4448 GtkWidget
*wbutton
= NULL
;
4449 Lisp_Object specified_file
;
4450 int vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4452 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4453 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4454 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4457 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4459 /* If this is a separator, use a gtk separator item. */
4460 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4462 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4465 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4467 ti
= gtk_separator_tool_item_new ();
4468 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4474 /* Otherwise, the tool-bar item is an ordinary button. */
4476 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4478 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4482 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4484 /* Ignore invalid image specifications. */
4485 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4486 if (!valid_image_p (image
))
4489 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4494 specified_file
= file_for_image (image
);
4495 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4496 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4498 if (STRINGP (stock
))
4500 stock_name
= SSDATA (stock
);
4501 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4503 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4504 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4506 icon_name
= stock_name
+ 2;
4510 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4513 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4515 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4516 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4524 if (stock_name
== NULL
&& icon_name
== NULL
)
4526 /* No stock image, or stock item not known. Try regular
4527 image. If image is a vector, choose it according to the
4529 if (dir
== GTK_TEXT_DIR_RTL
4530 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4532 image
= find_rtl_image (f
, image
, rtl
);
4534 if (VECTORP (image
))
4538 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4539 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4542 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4543 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4545 xassert (ASIZE (image
) >= idx
);
4546 image
= AREF (image
, idx
);
4551 img_id
= lookup_image (f
, image
);
4552 img
= IMAGE_FROM_ID (f
, img_id
);
4553 prepare_image_for_display (f
, img
);
4555 if (img
->load_failed_p
|| img
->pixmap
== None
)
4558 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4564 /* If there is an existing widget, check if it's stale; if so,
4565 remove it and make a new tool item from scratch. */
4566 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4569 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4578 /* Save the image so we can see if an update is needed the
4579 next time we call xg_tool_item_match_p. */
4580 if (EQ (style
, Qtext
))
4582 else if (stock_name
)
4584 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4585 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4586 (gpointer
) xstrdup (stock_name
),
4587 (GDestroyNotify
) xfree
);
4591 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4592 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4593 (gpointer
) xstrdup (icon_name
),
4594 (GDestroyNotify
) xfree
);
4598 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4599 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4600 (gpointer
)img
->pixmap
);
4603 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4604 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4605 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4610 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4614 /* Remove buttons not longer needed. */
4617 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4619 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4620 } while (ti
!= NULL
);
4622 if (f
->n_tool_bar_items
!= 0)
4625 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4626 gtk_widget_show_all (GTK_WIDGET (x
->handlebox_widget
));
4627 if (xg_update_tool_bar_sizes (f
))
4628 xg_height_or_width_changed (f
);
4634 /* Deallocate all resources for the tool bar on frame F.
4635 Remove the tool bar. */
4638 free_frame_tool_bar (FRAME_PTR f
)
4640 struct x_output
*x
= f
->output_data
.x
;
4642 if (x
->toolbar_widget
)
4644 int is_packed
= x
->handlebox_widget
!= 0;
4646 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4647 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4650 if (x
->toolbar_in_hbox
)
4651 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4652 x
->handlebox_widget
);
4654 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4655 x
->handlebox_widget
);
4658 gtk_widget_destroy (x
->toolbar_widget
);
4660 x
->toolbar_widget
= 0;
4661 x
->handlebox_widget
= 0;
4662 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4663 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4665 xg_height_or_width_changed (f
);
4672 xg_change_toolbar_position (FRAME_PTR f
, Lisp_Object pos
)
4674 struct x_output
*x
= f
->output_data
.x
;
4676 if (! x
->toolbar_widget
|| ! x
->handlebox_widget
)
4680 g_object_ref (x
->handlebox_widget
);
4681 if (x
->toolbar_in_hbox
)
4682 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4683 x
->handlebox_widget
);
4685 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4686 x
->handlebox_widget
);
4687 xg_pack_tool_bar (f
, pos
);
4688 g_object_unref (x
->handlebox_widget
);
4689 if (xg_update_tool_bar_sizes (f
))
4690 xg_height_or_width_changed (f
);
4698 /***********************************************************************
4700 ***********************************************************************/
4702 xg_initialize (void)
4704 GtkBindingSet
*binding_set
;
4707 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4708 we keep it permanently linked in. */
4713 xg_ignore_gtk_scrollbar
= 0;
4714 xg_detached_menus
= 0;
4715 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4716 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4718 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4719 id_to_widget
.widgets
= 0;
4721 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4722 bindings. It doesn't seem to be any way to remove properties,
4723 so we set it to VoidSymbol which in X means "no key". */
4724 gtk_settings_set_string_property (gtk_settings_get_default (),
4725 "gtk-menu-bar-accel",
4729 /* Make GTK text input widgets use Emacs style keybindings. This is
4731 gtk_settings_set_string_property (gtk_settings_get_default (),
4732 "gtk-key-theme-name",
4736 /* Make dialogs close on C-g. Since file dialog inherits from
4737 dialog, this works for them also. */
4738 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4739 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4742 /* Make menus close on C-g. */
4743 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4744 (GTK_TYPE_MENU_SHELL
));
4745 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4747 update_theme_scrollbar_width ();
4750 #endif /* USE_GTK */