1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2012 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
29 #include "blockinput.h"
30 #include "syssignal.h"
33 #include "termhooks.h"
37 #include <gdk/gdkkeysyms.h>
38 #include "xsettings.h"
41 #include <X11/Xft/Xft.h>
46 #include "emacsgtkfixed.h"
49 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
50 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
52 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
53 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
55 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
56 #define gtk_widget_set_has_window(w, b) \
57 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
59 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
60 #define gtk_dialog_get_action_area(w) ((w)->action_area)
61 #define gtk_dialog_get_content_area(w) ((w)->vbox)
63 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
64 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
66 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
67 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
68 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
69 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
70 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
72 #if GTK_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 11
73 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
75 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
79 #ifdef USE_GTK_TOOLTIP
80 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
82 #define gdk_window_get_geometry(w, a, b, c, d) \
83 gdk_window_get_geometry (w, a, b, c, d, 0)
84 #define gdk_x11_window_lookup_for_display(d, w) \
85 gdk_xid_table_lookup_for_display (d, w)
87 #define GDK_KEY_g GDK_g
91 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
93 static void update_theme_scrollbar_width (void);
96 /***********************************************************************
97 Display handling functions
98 ***********************************************************************/
100 /* Keep track of the default display, or NULL if there is none. Emacs
101 may close all its displays. */
103 static GdkDisplay
*gdpy_def
;
105 /* When the GTK widget W is to be created on a display for F that
106 is not the default display, set the display for W.
107 W can be a GtkMenu or a GtkWindow widget. */
110 xg_set_screen (GtkWidget
*w
, FRAME_PTR f
)
112 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
114 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
115 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
118 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
120 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
125 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
126 *DPY is set to NULL if the display can't be opened.
128 Returns non-zero if display could be opened, zero if display could not
129 be opened, and less than zero if the GTK version doesn't support
130 multiple displays. */
133 xg_display_open (char *display_name
, Display
**dpy
)
137 gdpy
= gdk_display_open (display_name
);
138 if (!gdpy_def
&& gdpy
)
141 gdk_display_manager_set_default_display (gdk_display_manager_get (),
145 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
149 /* Close display DPY. */
152 xg_display_close (Display
*dpy
)
154 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
156 /* If this is the default display, try to change it before closing.
157 If there is no other display to use, gdpy_def is set to NULL, and
158 the next call to xg_display_open resets the default display. */
159 if (gdk_display_get_default () == gdpy
)
161 struct x_display_info
*dpyinfo
;
162 GdkDisplay
*gdpy_new
= NULL
;
164 /* Find another display. */
165 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
166 if (dpyinfo
->display
!= dpy
)
168 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
169 gdk_display_manager_set_default_display (gdk_display_manager_get (),
176 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
177 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
178 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
179 can continue running, but there will be memory leaks. */
180 g_object_run_dispose (G_OBJECT (gdpy
));
182 /* This seems to be fixed in GTK 2.10. */
183 gdk_display_close (gdpy
);
188 /***********************************************************************
190 ***********************************************************************/
191 /* The next two variables and functions are taken from lwlib. */
192 static widget_value
*widget_value_free_list
;
193 static int malloc_cpt
;
195 /* Allocate a widget_value structure, either by taking one from the
196 widget_value_free_list or by malloc:ing a new one.
198 Return a pointer to the allocated structure. */
201 malloc_widget_value (void)
204 if (widget_value_free_list
)
206 wv
= widget_value_free_list
;
207 widget_value_free_list
= wv
->free_list
;
212 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
215 memset (wv
, 0, sizeof (widget_value
));
219 /* This is analogous to free. It frees only what was allocated
220 by malloc_widget_value, and no substructures. */
223 free_widget_value (widget_value
*wv
)
230 /* When the number of already allocated cells is too big,
237 wv
->free_list
= widget_value_free_list
;
238 widget_value_free_list
= wv
;
243 /* Create and return the cursor to be used for popup menus and
244 scroll bars on display DPY. */
247 xg_create_default_cursor (Display
*dpy
)
249 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
250 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
254 xg_get_pixbuf_from_pixmap (FRAME_PTR f
, Pixmap pix
)
259 unsigned int width
, height
, uunused
;
262 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
263 &width
, &height
, &uunused
, &uunused
);
265 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
269 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
282 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
285 xg_get_pixbuf_from_pix_and_mask (FRAME_PTR f
,
290 GdkPixbuf
*icon_buf
, *tmp_buf
;
292 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
293 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
294 g_object_unref (G_OBJECT (tmp_buf
));
296 width
= gdk_pixbuf_get_width (icon_buf
);
297 height
= gdk_pixbuf_get_height (icon_buf
);
301 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
302 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
303 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
304 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
305 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
308 for (y
= 0; y
< height
; ++y
)
310 guchar
*iconptr
, *maskptr
;
313 iconptr
= pixels
+ y
* rowstride
;
314 maskptr
= mask_pixels
+ y
* mask_rowstride
;
316 for (x
= 0; x
< width
; ++x
)
318 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
319 just R is sufficient. */
321 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
323 iconptr
+= rowstride
/width
;
324 maskptr
+= mask_rowstride
/width
;
328 g_object_unref (G_OBJECT (mask_buf
));
335 file_for_image (Lisp_Object image
)
337 Lisp_Object specified_file
= Qnil
;
340 for (tail
= XCDR (image
);
341 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
342 tail
= XCDR (XCDR (tail
)))
343 if (EQ (XCAR (tail
), QCfile
))
344 specified_file
= XCAR (XCDR (tail
));
346 return specified_file
;
349 /* For the image defined in IMG, make and return a GtkImage. For displays with
350 8 planes or less we must make a GdkPixbuf and apply the mask manually.
351 Otherwise the highlighting and dimming the tool bar code in GTK does
352 will look bad. For display with more than 8 planes we just use the
353 pixmap and mask directly. For monochrome displays, GTK doesn't seem
354 able to use external pixmaps, it looks bad whatever we do.
355 The image is defined on the display where frame F is.
356 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
357 If OLD_WIDGET is NULL, a new widget is constructed and returned.
358 If OLD_WIDGET is not NULL, that widget is modified. */
361 xg_get_image_for_pixmap (FRAME_PTR f
,
364 GtkImage
*old_widget
)
368 /* If we have a file, let GTK do all the image handling.
369 This seems to be the only way to make insensitive and activated icons
370 look good in all cases. */
371 Lisp_Object specified_file
= file_for_image (img
->spec
);
374 /* We already loaded the image once before calling this
375 function, so this only fails if the image file has been removed.
376 In that case, use the pixmap already loaded. */
378 if (STRINGP (specified_file
)
379 && STRINGP (file
= x_find_image_file (specified_file
)))
382 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
384 gtk_image_set_from_file (old_widget
, SSDATA (file
));
386 return GTK_WIDGET (old_widget
);
389 /* No file, do the image handling ourselves. This will look very bad
390 on a monochrome display, and sometimes bad on all displays with
393 /* This is a workaround to make icons look good on pseudo color
394 displays. Apparently GTK expects the images to have an alpha
395 channel. If they don't, insensitive and activated icons will
396 look bad. This workaround does not work on monochrome displays,
397 and is strictly not needed on true color/static color displays (i.e.
398 16 bits and higher). But we do it anyway so we get a pixbuf that is
399 not associated with the img->pixmap. The img->pixmap may be removed
400 by clearing the image cache and then the tool bar redraw fails, since
401 Gtk+ assumes the pixmap is always there. */
402 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
407 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
409 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
411 g_object_unref (G_OBJECT (icon_buf
));
414 return GTK_WIDGET (old_widget
);
418 /* Set CURSOR on W and all widgets W contain. We must do like this
419 for scroll bars and menu because they create widgets internally,
420 and it is those widgets that are visible. */
423 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
425 GdkWindow
*window
= gtk_widget_get_window (w
);
426 GList
*children
= gdk_window_peek_children (window
);
428 gdk_window_set_cursor (window
, cursor
);
430 /* The scroll bar widget has more than one GDK window (had to look at
431 the source to figure this out), and there is no way to set cursor
432 on widgets in GTK. So we must set the cursor for all GDK windows.
435 for ( ; children
; children
= g_list_next (children
))
436 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
439 /* Insert NODE into linked LIST. */
442 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
444 xg_list_node
*list_start
= list
->next
;
446 if (list_start
) list_start
->prev
= node
;
447 node
->next
= list_start
;
452 /* Remove NODE from linked LIST. */
455 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
457 xg_list_node
*list_start
= list
->next
;
458 if (node
== list_start
)
460 list
->next
= node
->next
;
461 if (list
->next
) list
->next
->prev
= 0;
465 node
->prev
->next
= node
->next
;
466 if (node
->next
) node
->next
->prev
= node
->prev
;
470 /* Allocate and return a utf8 version of STR. If STR is already
471 utf8 or NULL, just return a copy of STR.
472 A new string is allocated and the caller must free the result
476 get_utf8_string (const char *str
)
480 if (!str
) return NULL
;
482 /* If not UTF-8, try current locale. */
483 if (!g_utf8_validate (str
, -1, NULL
))
484 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
486 return g_strdup (str
);
490 /* Probably some control characters in str. Escape them. */
492 ptrdiff_t nr_bad
= 0;
495 unsigned char *p
= (unsigned char *)str
;
499 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
500 &bytes_written
, &err
))
501 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
504 p
+= bytes_written
+1;
517 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
518 memory_full (SIZE_MAX
);
519 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
520 p
= (unsigned char *)str
;
522 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
523 &bytes_written
, &err
))
524 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
526 strncpy (up
, (char *)p
, bytes_written
);
527 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
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
));
570 char buf
[sizeof "rgbi://" + 3 * (DBL_MAX_10_EXP
+ sizeof "-1.000000" - 1)];
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
;
800 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
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 changing 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 event
.any
.type
= GDK_NOTHING
;
990 gwdesc
= gtk_get_event_widget (&event
);
997 /* Set the background of widget W to PIXEL. */
1000 xg_set_widget_bg (FRAME_PTR f
, GtkWidget
*w
, long unsigned int pixel
)
1006 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1008 bg
.red
= (double)xbg
.red
/65536.0;
1009 bg
.green
= (double)xbg
.green
/65536.0;
1010 bg
.blue
= (double)xbg
.blue
/65536.0;
1012 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1016 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1017 gdk_colormap_query_color (map
, pixel
, &bg
);
1018 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1022 /* Callback called when the gtk theme changes.
1023 We notify lisp code so it can fix faces used for region for example. */
1026 style_changed_cb (GObject
*go
,
1030 struct input_event event
;
1031 GdkDisplay
*gdpy
= (GdkDisplay
*) user_data
;
1032 const char *display_name
= gdk_display_get_name (gdpy
);
1033 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1036 event
.kind
= CONFIG_CHANGED_EVENT
;
1037 event
.frame_or_window
= build_string (display_name
);
1038 /* Theme doesn't change often, so intern is called seldom. */
1039 event
.arg
= intern ("theme-name");
1040 kbd_buffer_store_event (&event
);
1042 update_theme_scrollbar_width ();
1044 /* If scroll bar width changed, we need set the new size on all frames
1048 Lisp_Object rest
, frame
;
1049 FOR_EACH_FRAME (rest
, frame
)
1051 FRAME_PTR f
= XFRAME (frame
);
1052 if (FRAME_X_DISPLAY (f
) == dpy
)
1054 x_set_scroll_bar_default_width (f
);
1055 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
1061 /* Called when a delete-event occurs on WIDGET. */
1064 delete_cb (GtkWidget
*widget
,
1069 /* The event doesn't arrive in the normal event loop. Send event
1071 FRAME_PTR f
= (FRAME_PTR
) user_data
;
1072 struct input_event ie
;
1075 ie
.kind
= DELETE_WINDOW_EVENT
;
1076 XSETFRAME (ie
.frame_or_window
, f
);
1077 kbd_buffer_store_event (&ie
);
1083 /* Create and set up the GTK widgets for frame F.
1084 Return 0 if creation failed, non-zero otherwise. */
1087 xg_create_frame_widgets (FRAME_PTR f
)
1090 GtkWidget
*wvbox
, *whbox
;
1099 if (FRAME_X_EMBEDDED_P (f
))
1100 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
1102 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1104 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1105 has backported it to Gtk+ 2.0 and they add the resize grip for
1106 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1107 forever, so disable the grip. */
1108 #if GTK_MAJOR_VERSION < 3 && defined (HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1109 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1112 xg_set_screen (wtop
, f
);
1114 wvbox
= gtk_vbox_new (FALSE
, 0);
1115 whbox
= gtk_hbox_new (FALSE
, 0);
1118 wfixed
= emacs_fixed_new (f
);
1120 wfixed
= gtk_fixed_new ();
1123 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1125 if (wtop
) gtk_widget_destroy (wtop
);
1126 if (wvbox
) gtk_widget_destroy (wvbox
);
1127 if (whbox
) gtk_widget_destroy (whbox
);
1128 if (wfixed
) gtk_widget_destroy (wfixed
);
1134 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1135 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1136 gtk_widget_set_name (wvbox
, "pane");
1137 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1139 /* If this frame has a title or name, set it in the title bar. */
1140 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1141 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1143 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1145 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1146 FRAME_GTK_WIDGET (f
) = wfixed
;
1147 f
->output_data
.x
->vbox_widget
= wvbox
;
1148 f
->output_data
.x
->hbox_widget
= whbox
;
1150 gtk_widget_set_has_window (wfixed
, TRUE
);
1152 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1153 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1154 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1156 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1157 update_frame_tool_bar (f
);
1159 /* We don't want this widget double buffered, because we draw on it
1160 with regular X drawing primitives, so from a GTK/GDK point of
1161 view, the widget is totally blank. When an expose comes, this
1162 will make the widget blank, and then Emacs redraws it. This flickers
1163 a lot, so we turn off double buffering. */
1164 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1166 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1167 SSDATA (Vx_resource_name
),
1168 SSDATA (Vx_resource_class
));
1170 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1171 GTK is to destroy the widget. We want Emacs to do that instead. */
1172 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1173 G_CALLBACK (delete_cb
), f
);
1175 /* Convert our geometry parameters into a geometry string
1177 GTK will itself handle calculating the real position this way. */
1178 xg_set_geometry (f
);
1180 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1182 gtk_widget_add_events (wfixed
,
1183 GDK_POINTER_MOTION_MASK
1185 | GDK_BUTTON_PRESS_MASK
1186 | GDK_BUTTON_RELEASE_MASK
1187 | GDK_KEY_PRESS_MASK
1188 | GDK_ENTER_NOTIFY_MASK
1189 | GDK_LEAVE_NOTIFY_MASK
1190 | GDK_FOCUS_CHANGE_MASK
1191 | GDK_STRUCTURE_MASK
1192 | GDK_VISIBILITY_NOTIFY_MASK
);
1194 /* Must realize the windows so the X window gets created. It is used
1195 by callers of this function. */
1196 gtk_widget_realize (wfixed
);
1197 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1199 /* Since GTK clears its window by filling with the background color,
1200 we must keep X and GTK background in sync. */
1201 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1204 /* Also, do not let any background pixmap to be set, this looks very
1205 bad as Emacs overwrites the background pixmap with its own idea
1206 of background color. */
1207 style
= gtk_widget_get_modifier_style (wfixed
);
1209 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1210 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1211 gtk_widget_modify_style (wfixed
, style
);
1213 gtk_widget_set_can_focus (wfixed
, TRUE
);
1214 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1217 #ifdef USE_GTK_TOOLTIP
1218 /* Steal a tool tip window we can move ourselves. */
1219 f
->output_data
.x
->ttip_widget
= 0;
1220 f
->output_data
.x
->ttip_lbl
= 0;
1221 f
->output_data
.x
->ttip_window
= 0;
1222 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1223 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1227 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1228 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1229 /* Only connect this signal once per screen. */
1230 if (! g_signal_handler_find (G_OBJECT (gs
),
1231 G_SIGNAL_MATCH_FUNC
,
1233 G_CALLBACK (style_changed_cb
),
1236 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1237 G_CALLBACK (style_changed_cb
),
1238 gdk_screen_get_display (screen
));
1248 xg_free_frame_widgets (FRAME_PTR f
)
1250 if (FRAME_GTK_OUTER_WIDGET (f
))
1252 #ifdef USE_GTK_TOOLTIP
1253 struct x_output
*x
= f
->output_data
.x
;
1255 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1256 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1257 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1258 #ifdef USE_GTK_TOOLTIP
1260 gtk_widget_destroy (x
->ttip_lbl
);
1262 g_object_unref (G_OBJECT (x
->ttip_widget
));
1267 /* Set the normal size hints for the window manager, for frame F.
1268 FLAGS is the flags word to use--or 0 meaning preserve the flags
1269 that the window now has.
1270 If USER_POSITION is nonzero, we set the User Position
1271 flag (this is useful when FLAGS is 0). */
1274 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
1276 /* Must use GTK routines here, otherwise GTK resets the size hints
1277 to its own defaults. */
1278 GdkGeometry size_hints
;
1279 gint hint_flags
= 0;
1280 int base_width
, base_height
;
1281 int min_rows
= 0, min_cols
= 0;
1282 int win_gravity
= f
->win_gravity
;
1284 /* Don't set size hints during initialization; that apparently leads
1285 to a race condition. See the thread at
1286 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1287 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1292 memset (&size_hints
, 0, sizeof (size_hints
));
1293 f
->output_data
.x
->size_hints
= size_hints
;
1294 f
->output_data
.x
->hint_flags
= hint_flags
;
1297 flags
= f
->size_hint_flags
;
1299 size_hints
= f
->output_data
.x
->size_hints
;
1300 hint_flags
= f
->output_data
.x
->hint_flags
;
1302 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1303 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1304 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1306 hint_flags
|= GDK_HINT_BASE_SIZE
;
1307 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0) + FRAME_TOOLBAR_WIDTH (f
);
1308 /* Use one row here so base_height does not become zero.
1309 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1310 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1311 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1313 check_frame_size (f
, &min_rows
, &min_cols
);
1314 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1316 size_hints
.base_width
= base_width
;
1317 size_hints
.base_height
= base_height
;
1318 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1319 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1321 /* These currently have a one to one mapping with the X values, but I
1322 don't think we should rely on that. */
1323 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1324 size_hints
.win_gravity
= 0;
1325 if (win_gravity
== NorthWestGravity
)
1326 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1327 else if (win_gravity
== NorthGravity
)
1328 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1329 else if (win_gravity
== NorthEastGravity
)
1330 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1331 else if (win_gravity
== WestGravity
)
1332 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1333 else if (win_gravity
== CenterGravity
)
1334 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1335 else if (win_gravity
== EastGravity
)
1336 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1337 else if (win_gravity
== SouthWestGravity
)
1338 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1339 else if (win_gravity
== SouthGravity
)
1340 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1341 else if (win_gravity
== SouthEastGravity
)
1342 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1343 else if (win_gravity
== StaticGravity
)
1344 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1348 hint_flags
&= ~GDK_HINT_POS
;
1349 hint_flags
|= GDK_HINT_USER_POS
;
1352 if (hint_flags
!= f
->output_data
.x
->hint_flags
1353 || memcmp (&size_hints
,
1354 &f
->output_data
.x
->size_hints
,
1355 sizeof (size_hints
)) != 0)
1358 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1359 NULL
, &size_hints
, hint_flags
);
1360 f
->output_data
.x
->size_hints
= size_hints
;
1361 f
->output_data
.x
->hint_flags
= hint_flags
;
1366 /* Change background color of a frame.
1367 Since GTK uses the background color to clear the window, we must
1368 keep the GTK and X colors in sync.
1369 F is the frame to change,
1370 BG is the pixel value to change to. */
1373 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
1375 if (FRAME_GTK_WIDGET (f
))
1378 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1384 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1385 functions so GTK does not overwrite the icon. */
1388 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1390 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1394 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1399 /***********************************************************************
1401 ***********************************************************************/
1402 /* Return the dialog title to use for a dialog of type KEY.
1403 This is the encoding used by lwlib. We use the same for GTK. */
1406 get_dialog_title (char key
)
1408 const char *title
= "";
1416 title
= "Information";
1435 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1436 the dialog, but return TRUE so the event does not propagate further
1437 in GTK. This prevents GTK from destroying the dialog widget automatically
1438 and we can always destroy the widget manually, regardless of how
1439 it was popped down (button press or WM_DELETE_WINDOW).
1440 W is the dialog widget.
1441 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1442 user_data is NULL (not used).
1444 Returns TRUE to end propagation of event. */
1447 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1449 gtk_widget_unmap (w
);
1453 /* Create a popup dialog window. See also xg_create_widget below.
1454 WV is a widget_value describing the dialog.
1455 SELECT_CB is the callback to use when a button has been pressed.
1456 DEACTIVATE_CB is the callback to use when the dialog pops down.
1458 Returns the GTK dialog widget. */
1461 create_dialog (widget_value
*wv
,
1462 GCallback select_cb
,
1463 GCallback deactivate_cb
)
1465 const char *title
= get_dialog_title (wv
->name
[0]);
1466 int total_buttons
= wv
->name
[1] - '0';
1467 int right_buttons
= wv
->name
[4] - '0';
1470 int button_spacing
= 10;
1471 GtkWidget
*wdialog
= gtk_dialog_new ();
1472 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1473 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1475 GtkWidget
*whbox_down
;
1477 /* If the number of buttons is greater than 4, make two rows of buttons
1478 instead. This looks better. */
1479 int make_two_rows
= total_buttons
> 4;
1481 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1482 left_buttons
= total_buttons
- right_buttons
;
1484 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1485 gtk_widget_set_name (wdialog
, "emacs-dialog");
1490 GtkWidget
*wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1491 GtkWidget
*whbox_up
= gtk_hbox_new (FALSE
, 0);
1492 whbox_down
= gtk_hbox_new (FALSE
, 0);
1494 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1495 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1496 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1498 cur_box
= GTK_BOX (whbox_up
);
1501 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1502 G_CALLBACK (dialog_delete_callback
), 0);
1506 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1507 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1510 for (item
= wv
->contents
; item
; item
= item
->next
)
1512 char *utf8_label
= get_utf8_string (item
->value
);
1516 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1518 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1519 /* This is the text part of the dialog. */
1520 w
= gtk_label_new (utf8_label
);
1521 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1522 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1523 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1525 /* Try to make dialog look better. Must realize first so
1526 the widget can calculate the size it needs. */
1527 gtk_widget_realize (w
);
1528 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1529 gtk_box_set_spacing (wvbox
, req
.height
);
1530 if (item
->value
&& strlen (item
->value
) > 0)
1531 button_spacing
= 2*req
.width
/strlen (item
->value
);
1535 /* This is one button to add to the dialog. */
1536 w
= gtk_button_new_with_label (utf8_label
);
1537 if (! item
->enabled
)
1538 gtk_widget_set_sensitive (w
, FALSE
);
1540 g_signal_connect (G_OBJECT (w
), "clicked",
1541 select_cb
, item
->call_data
);
1543 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1544 if (++button_nr
== left_buttons
)
1547 cur_box
= GTK_BOX (whbox_down
);
1549 gtk_box_pack_start (cur_box
,
1557 g_free (utf8_label
);
1563 struct xg_dialog_data
1571 /* Function that is called when the file or font dialogs pop down.
1572 W is the dialog widget, RESPONSE is the response code.
1573 USER_DATA is what we passed in to g_signal_connect. */
1576 xg_dialog_response_cb (GtkDialog
*w
,
1580 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1581 dd
->response
= response
;
1582 g_main_loop_quit (dd
->loop
);
1586 /* Destroy the dialog. This makes it pop down. */
1589 pop_down_dialog (Lisp_Object arg
)
1591 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1592 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1595 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1596 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1598 g_main_loop_quit (dd
->loop
);
1599 g_main_loop_unref (dd
->loop
);
1606 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1607 We pass in DATA as gpointer* so we can use this as a callback. */
1610 xg_maybe_add_timer (gpointer data
)
1612 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1613 EMACS_TIME next_time
= timer_check ();
1617 if (EMACS_TIME_VALID_P (next_time
))
1619 time_t s
= EMACS_SECS (next_time
);
1620 int per_ms
= EMACS_TIME_RESOLUTION
/ 1000;
1621 int ms
= (EMACS_NSECS (next_time
) + per_ms
- 1) / per_ms
;
1622 if (s
<= ((guint
) -1 - ms
) / 1000)
1623 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1629 /* Pops up a modal dialog W and waits for response.
1630 We don't use gtk_dialog_run because we want to process emacs timers.
1631 The dialog W is not destroyed when this function returns. */
1634 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1636 ptrdiff_t count
= SPECPDL_INDEX ();
1637 struct xg_dialog_data dd
;
1639 xg_set_screen (w
, f
);
1640 gtk_window_set_transient_for (GTK_WINDOW (w
),
1641 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1642 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1643 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1645 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1646 dd
.response
= GTK_RESPONSE_CANCEL
;
1650 g_signal_connect (G_OBJECT (w
),
1652 G_CALLBACK (xg_dialog_response_cb
),
1654 /* Don't destroy the widget if closed by the window manager close button. */
1655 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1656 gtk_widget_show (w
);
1658 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1660 (void) xg_maybe_add_timer (&dd
);
1661 g_main_loop_run (dd
.loop
);
1664 unbind_to (count
, Qnil
);
1670 /***********************************************************************
1671 File dialog functions
1672 ***********************************************************************/
1673 /* Return non-zero if the old file selection dialog is being used.
1674 Return zero if not. */
1677 xg_uses_old_file_dialog (void)
1679 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1680 return x_gtk_use_old_file_dialog
;
1687 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1689 /* Return the selected file for file chooser dialog W.
1690 The returned string must be free:d. */
1693 xg_get_file_name_from_chooser (GtkWidget
*w
)
1695 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1698 /* Callback called when the "Show hidden files" toggle is pressed.
1699 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1702 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1704 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1706 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1707 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1711 /* Callback called when a property changes in a file chooser.
1712 GOBJECT is the file chooser dialog, ARG1 describes the property.
1713 USER_DATA is the toggle widget in the file chooser dialog.
1714 We use this to update the "Show hidden files" toggle when the user
1715 changes that property by right clicking in the file list. */
1718 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1720 if (strcmp (arg1
->name
, "show-hidden") == 0)
1722 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1723 gboolean visible
, toggle_on
;
1725 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1726 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1728 if (!!visible
!= !!toggle_on
)
1730 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1731 G_CALLBACK (xg_toggle_visibility_cb
),
1733 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1734 g_signal_handlers_unblock_by_func
1735 (G_OBJECT (wtoggle
),
1736 G_CALLBACK (xg_toggle_visibility_cb
),
1739 x_gtk_show_hidden_files
= visible
;
1743 /* Read a file name from the user using a file chooser dialog.
1744 F is the current frame.
1745 PROMPT is a prompt to show to the user. May not be NULL.
1746 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1747 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1748 file. (Actually, this only has cosmetic effects, the user can
1749 still enter a non-existing file.) *FUNC is set to a function that
1750 can be used to retrieve the selected file name from the returned widget.
1752 Returns the created widget. */
1755 xg_get_file_with_chooser (FRAME_PTR f
,
1757 char *default_filename
,
1758 int mustmatch_p
, int only_dir_p
,
1759 xg_get_file_func
*func
)
1763 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1764 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1765 GtkFileChooserAction action
= (mustmatch_p
?
1766 GTK_FILE_CHOOSER_ACTION_OPEN
:
1767 GTK_FILE_CHOOSER_ACTION_SAVE
);
1770 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1772 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1773 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1774 (mustmatch_p
|| only_dir_p
?
1775 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1778 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1780 wbox
= gtk_vbox_new (FALSE
, 0);
1781 gtk_widget_show (wbox
);
1782 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1784 if (x_gtk_show_hidden_files
)
1786 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1787 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1789 gtk_widget_show (wtoggle
);
1790 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1791 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1792 g_signal_connect (G_OBJECT (filewin
), "notify",
1793 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1795 if (x_gtk_file_dialog_help_text
)
1798 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1799 Show the C-l help text only for versions < 2.10. */
1800 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1801 strcat (msgbuf
, "\nType C-l to display a file name text entry box.\n");
1802 strcat (msgbuf
, "\nIf you don't like this file selector, use the "
1803 "corresponding\nkey binding or customize "
1804 "use-file-dialog to turn it off.");
1806 wmessage
= gtk_label_new (msgbuf
);
1807 gtk_widget_show (wmessage
);
1810 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1811 if (x_gtk_file_dialog_help_text
)
1812 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1813 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1815 if (default_filename
)
1818 struct gcpro gcpro1
;
1819 char *utf8_filename
;
1822 file
= build_string (default_filename
);
1824 /* File chooser does not understand ~/... in the file name. It must be
1825 an absolute name starting with /. */
1826 if (default_filename
[0] != '/')
1827 file
= Fexpand_file_name (file
, Qnil
);
1829 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1830 if (! NILP (Ffile_directory_p (file
)))
1831 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1835 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1837 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1839 char *cp
= strrchr (utf8_filename
, '/');
1841 else cp
= utf8_filename
;
1842 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1849 *func
= xg_get_file_name_from_chooser
;
1853 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1855 /* Return the selected file for file selector dialog W.
1856 The returned string must be free:d. */
1859 xg_get_file_name_from_selector (GtkWidget
*w
)
1861 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1862 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1865 /* Create a file selection dialog.
1866 F is the current frame.
1867 PROMPT is a prompt to show to the user. May not be NULL.
1868 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1869 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1870 file. *FUNC is set to a function that can be used to retrieve the
1871 selected file name from the returned widget.
1873 Returns the created widget. */
1876 xg_get_file_with_selection (FRAME_PTR f
,
1878 char *default_filename
,
1879 int mustmatch_p
, int only_dir_p
,
1880 xg_get_file_func
*func
)
1883 GtkFileSelection
*filesel
;
1885 filewin
= gtk_file_selection_new (prompt
);
1886 filesel
= GTK_FILE_SELECTION (filewin
);
1888 if (default_filename
)
1889 gtk_file_selection_set_filename (filesel
, default_filename
);
1893 /* The selection_entry part of filesel is not documented. */
1894 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1895 gtk_file_selection_hide_fileop_buttons (filesel
);
1898 *func
= xg_get_file_name_from_selector
;
1902 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1904 /* Read a file name from the user using a file dialog, either the old
1905 file selection dialog, or the new file chooser dialog. Which to use
1906 depends on what the GTK version used has, and what the value of
1907 gtk-use-old-file-dialog.
1908 F is the current frame.
1909 PROMPT is a prompt to show to the user. May not be NULL.
1910 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1911 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1914 Returns a file name or NULL if no file was selected.
1915 The returned string must be freed by the caller. */
1918 xg_get_file_name (FRAME_PTR f
,
1920 char *default_filename
,
1926 int filesel_done
= 0;
1927 xg_get_file_func func
;
1929 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
1930 /* I really don't know why this is needed, but without this the GLIBC add on
1931 library linuxthreads hangs when the Gnome file chooser backend creates
1933 sigblock (sigmask (__SIGRTMIN
));
1934 #endif /* HAVE_PTHREAD */
1936 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1938 if (xg_uses_old_file_dialog ())
1939 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1940 mustmatch_p
, only_dir_p
, &func
);
1942 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1943 mustmatch_p
, only_dir_p
, &func
);
1945 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1946 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1947 mustmatch_p
, only_dir_p
, &func
);
1948 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1950 gtk_widget_set_name (w
, "emacs-filedialog");
1952 filesel_done
= xg_dialog_run (f
, w
);
1954 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
1955 sigunblock (sigmask (__SIGRTMIN
));
1958 if (filesel_done
== GTK_RESPONSE_OK
)
1961 gtk_widget_destroy (w
);
1965 #ifdef HAVE_FREETYPE
1966 /* Pop up a GTK font selector and return the name of the font the user
1967 selects, as a C string. The returned font name follows GTK's own
1970 `FAMILY [VALUE1 VALUE2] SIZE'
1972 This can be parsed using font_parse_fcname in font.c.
1973 DEFAULT_NAME, if non-zero, is the default font name. */
1976 xg_get_font_name (FRAME_PTR f
, const char *default_name
)
1979 char *fontname
= NULL
;
1982 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
1983 sigblock (sigmask (__SIGRTMIN
));
1984 #endif /* HAVE_PTHREAD */
1986 w
= gtk_font_selection_dialog_new ("Pick a font");
1988 default_name
= "Monospace 10";
1989 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1992 gtk_widget_set_name (w
, "emacs-fontdialog");
1994 done
= xg_dialog_run (f
, w
);
1996 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
1997 sigunblock (sigmask (__SIGRTMIN
));
2000 if (done
== GTK_RESPONSE_OK
)
2001 fontname
= gtk_font_selection_dialog_get_font_name
2002 (GTK_FONT_SELECTION_DIALOG (w
));
2004 gtk_widget_destroy (w
);
2007 #endif /* HAVE_FREETYPE */
2011 /***********************************************************************
2013 ***********************************************************************/
2015 /* The name of menu items that can be used for customization. Since GTK
2016 RC files are very crude and primitive, we have to set this on all
2017 menu item names so a user can easily customize menu items. */
2019 #define MENU_ITEM_NAME "emacs-menuitem"
2022 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2023 during GC. The next member points to the items. */
2024 static xg_list_node xg_menu_cb_list
;
2026 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2027 during GC. The next member points to the items. */
2028 static xg_list_node xg_menu_item_cb_list
;
2030 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2031 F is the frame CL_DATA will be initialized for.
2032 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2034 The menu bar and all sub menus under the menu bar in a frame
2035 share the same structure, hence the reference count.
2037 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2038 allocated xg_menu_cb_data if CL_DATA is NULL. */
2040 static xg_menu_cb_data
*
2041 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
2045 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
2047 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2048 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2049 cl_data
->highlight_cb
= highlight_cb
;
2050 cl_data
->ref_count
= 0;
2052 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2055 cl_data
->ref_count
++;
2060 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2061 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2063 When the menu bar is updated, menu items may have been added and/or
2064 removed, so menu_bar_vector and menu_bar_items_used change. We must
2065 then update CL_DATA since it is used to determine which menu
2066 item that is invoked in the menu.
2067 HIGHLIGHT_CB could change, there is no check that the same
2068 function is given when modifying a menu bar as was given when
2069 creating the menu bar. */
2072 update_cl_data (xg_menu_cb_data
*cl_data
,
2074 GCallback highlight_cb
)
2079 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2080 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2081 cl_data
->highlight_cb
= highlight_cb
;
2085 /* Decrease reference count for CL_DATA.
2086 If reference count is zero, free CL_DATA. */
2089 unref_cl_data (xg_menu_cb_data
*cl_data
)
2091 if (cl_data
&& cl_data
->ref_count
> 0)
2093 cl_data
->ref_count
--;
2094 if (cl_data
->ref_count
== 0)
2096 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2102 /* Function that marks all lisp data during GC. */
2109 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2110 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2112 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2114 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2116 if (! NILP (cb_data
->help
))
2117 mark_object (cb_data
->help
);
2122 /* Callback called when a menu item is destroyed. Used to free data.
2123 W is the widget that is being destroyed (not used).
2124 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2127 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2131 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
2132 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2137 /* Callback called when the pointer enters/leaves a menu item.
2138 W is the parent of the menu item.
2139 EVENT is either an enter event or leave event.
2140 CLIENT_DATA is not used.
2142 Returns FALSE to tell GTK to keep processing this event. */
2145 menuitem_highlight_callback (GtkWidget
*w
,
2146 GdkEventCrossing
*event
,
2147 gpointer client_data
)
2150 GtkWidget
*subwidget
;
2151 xg_menu_item_cb_data
*data
;
2153 ev
.crossing
= *event
;
2154 subwidget
= gtk_get_event_widget (&ev
);
2155 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
2159 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2161 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2162 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2163 (*func
) (subwidget
, call_data
);
2170 /* Callback called when a menu is destroyed. Used to free data.
2171 W is the widget that is being destroyed (not used).
2172 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2175 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2177 unref_cl_data ((xg_menu_cb_data
*) client_data
);
2180 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2181 must be non-NULL) and can be inserted into a menu item.
2183 Returns the GtkHBox. */
2186 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2192 wbox
= gtk_hbox_new (FALSE
, 0);
2193 wlbl
= gtk_label_new (utf8_label
);
2194 wkey
= gtk_label_new (utf8_key
);
2196 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2197 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2199 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2200 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2202 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2203 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2204 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2209 /* Make and return a menu item widget with the key to the right.
2210 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2211 UTF8_KEY is the text representing the key binding.
2212 ITEM is the widget_value describing the menu item.
2214 GROUP is an in/out parameter. If the menu item to be created is not
2215 part of any radio menu group, *GROUP contains NULL on entry and exit.
2216 If the menu item to be created is part of a radio menu group, on entry
2217 *GROUP contains the group to use, or NULL if this is the first item
2218 in the group. On exit, *GROUP contains the radio item group.
2220 Unfortunately, keys don't line up as nicely as in Motif,
2221 but the MacOS X version doesn't either, so I guess that is OK. */
2224 make_menu_item (const char *utf8_label
,
2225 const char *utf8_key
,
2230 GtkWidget
*wtoadd
= 0;
2232 /* It has been observed that some menu items have a NULL name field.
2233 This will lead to this function being called with a NULL utf8_label.
2234 GTK crashes on that so we set a blank label. Why there is a NULL
2235 name remains to be investigated. */
2236 if (! utf8_label
) utf8_label
= " ";
2239 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2241 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2244 if (utf8_key
) w
= gtk_check_menu_item_new ();
2245 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2246 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2248 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2250 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2251 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2252 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2254 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2259 if (utf8_key
) w
= gtk_menu_item_new ();
2260 else w
= gtk_menu_item_new_with_label (utf8_label
);
2263 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2264 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2269 static int xg_detached_menus
;
2271 /* Returns non-zero if there are detached menus. */
2274 xg_have_tear_offs (void)
2276 return xg_detached_menus
> 0;
2279 /* Callback invoked when a detached menu window is removed. Here we
2280 decrease the xg_detached_menus count.
2281 WIDGET is the top level window that is removed (the parent of the menu).
2282 CLIENT_DATA is not used. */
2285 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2287 if (xg_detached_menus
> 0) --xg_detached_menus
;
2290 /* Callback invoked when a menu is detached. It increases the
2291 xg_detached_menus count.
2292 WIDGET is the GtkTearoffMenuItem.
2293 CLIENT_DATA is not used. */
2296 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2298 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2299 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2301 ++xg_detached_menus
;
2302 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2304 G_CALLBACK (tearoff_remove
), 0);
2309 /* Create a menu item widget, and connect the callbacks.
2310 ITEM describes the menu item.
2311 F is the frame the created menu belongs to.
2312 SELECT_CB is the callback to use when a menu item is selected.
2313 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2314 CL_DATA points to the callback data to be used for this menu.
2315 GROUP is an in/out parameter. If the menu item to be created is not
2316 part of any radio menu group, *GROUP contains NULL on entry and exit.
2317 If the menu item to be created is part of a radio menu group, on entry
2318 *GROUP contains the group to use, or NULL if this is the first item
2319 in the group. On exit, *GROUP contains the radio item group.
2321 Returns the created GtkWidget. */
2324 xg_create_one_menuitem (widget_value
*item
,
2326 GCallback select_cb
,
2327 GCallback highlight_cb
,
2328 xg_menu_cb_data
*cl_data
,
2334 xg_menu_item_cb_data
*cb_data
;
2336 utf8_label
= get_utf8_string (item
->name
);
2337 utf8_key
= get_utf8_string (item
->key
);
2339 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2341 if (utf8_label
) g_free (utf8_label
);
2342 if (utf8_key
) g_free (utf8_key
);
2344 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2346 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2348 cb_data
->select_id
= 0;
2349 cb_data
->help
= item
->help
;
2350 cb_data
->cl_data
= cl_data
;
2351 cb_data
->call_data
= item
->call_data
;
2353 g_signal_connect (G_OBJECT (w
),
2355 G_CALLBACK (menuitem_destroy_callback
),
2358 /* Put cb_data in widget, so we can get at it when modifying menubar */
2359 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2361 /* final item, not a submenu */
2362 if (item
->call_data
&& ! item
->contents
)
2366 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2372 /* Create a full menu tree specified by DATA.
2373 F is the frame the created menu belongs to.
2374 SELECT_CB is the callback to use when a menu item is selected.
2375 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2376 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2377 POP_UP_P is non-zero if we shall create a popup menu.
2378 MENU_BAR_P is non-zero if we shall create a menu bar.
2379 ADD_TEAROFF_P is non-zero if we shall add a tearoff menu item. Ignored
2380 if MENU_BAR_P is non-zero.
2381 TOPMENU is the topmost GtkWidget that others shall be placed under.
2382 It may be NULL, in that case we create the appropriate widget
2383 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2384 CL_DATA is the callback data we shall use for this menu, or NULL
2385 if we haven't set the first callback yet.
2386 NAME is the name to give to the top level menu if this function
2387 creates it. May be NULL to not set any name.
2389 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2392 This function calls itself to create submenus. */
2395 create_menus (widget_value
*data
,
2397 GCallback select_cb
,
2398 GCallback deactivate_cb
,
2399 GCallback highlight_cb
,
2404 xg_menu_cb_data
*cl_data
,
2408 GtkWidget
*wmenu
= topmenu
;
2409 GSList
*group
= NULL
;
2415 wmenu
= gtk_menu_new ();
2416 xg_set_screen (wmenu
, f
);
2417 /* Connect this to the menu instead of items so we get enter/leave for
2418 disabled items also. TODO: Still does not get enter/leave for
2419 disabled items in detached menus. */
2420 g_signal_connect (G_OBJECT (wmenu
),
2421 "enter-notify-event",
2422 G_CALLBACK (menuitem_highlight_callback
),
2424 g_signal_connect (G_OBJECT (wmenu
),
2425 "leave-notify-event",
2426 G_CALLBACK (menuitem_highlight_callback
),
2431 wmenu
= gtk_menu_bar_new ();
2432 /* Set width of menu bar to a small value so it doesn't enlarge
2433 a small initial frame size. The width will be set to the
2434 width of the frame later on when it is added to a container.
2435 height -1: Natural height. */
2436 gtk_widget_set_size_request (wmenu
, 1, -1);
2439 /* Put cl_data on the top menu for easier access. */
2440 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2441 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2442 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2443 G_CALLBACK (menu_destroy_callback
), cl_data
);
2446 gtk_widget_set_name (wmenu
, name
);
2449 g_signal_connect (G_OBJECT (wmenu
),
2450 "selection-done", deactivate_cb
, 0);
2453 if (! menu_bar_p
&& add_tearoff_p
)
2455 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2456 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2458 g_signal_connect (G_OBJECT (tearoff
), "activate",
2459 G_CALLBACK (tearoff_activate
), 0);
2462 for (item
= data
; item
; item
= item
->next
)
2466 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2467 && !menu_separator_name_p (item
->name
))
2470 /* A title for a popup. We do the same as GTK does when
2471 creating titles, but it does not look good. */
2473 utf8_label
= get_utf8_string (item
->name
);
2475 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2476 w
= gtk_menu_item_new_with_label (utf8_label
);
2477 gtk_widget_set_sensitive (w
, FALSE
);
2478 if (utf8_label
) g_free (utf8_label
);
2480 else if (menu_separator_name_p (item
->name
))
2483 /* GTK only have one separator type. */
2484 w
= gtk_separator_menu_item_new ();
2488 w
= xg_create_one_menuitem (item
,
2490 item
->contents
? 0 : select_cb
,
2495 /* Create a possibly empty submenu for menu bar items, since some
2496 themes don't highlight items correctly without it. */
2497 if (item
->contents
|| menu_bar_p
)
2499 GtkWidget
*submenu
= create_menus (item
->contents
,
2510 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2514 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2515 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2521 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2522 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2523 with some text and buttons.
2524 F is the frame the created item belongs to.
2525 NAME is the name to use for the top widget.
2526 VAL is a widget_value structure describing items to be created.
2527 SELECT_CB is the callback to use when a menu item is selected or
2528 a dialog button is pressed.
2529 DEACTIVATE_CB is the callback to use when an item is deactivated.
2530 For a menu, when a sub menu is not shown anymore, for a dialog it is
2531 called when the dialog is popped down.
2532 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2534 Returns the widget created. */
2537 xg_create_widget (const char *type
, const char *name
, FRAME_PTR f
, widget_value
*val
,
2538 GCallback select_cb
, GCallback deactivate_cb
,
2539 GCallback highlight_cb
)
2542 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2543 int pop_up_p
= strcmp (type
, "popup") == 0;
2545 if (strcmp (type
, "dialog") == 0)
2547 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2548 xg_set_screen (w
, f
);
2549 gtk_window_set_transient_for (GTK_WINDOW (w
),
2550 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2551 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2552 gtk_widget_set_name (w
, "emacs-dialog");
2553 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2555 else if (menu_bar_p
|| pop_up_p
)
2557 w
= create_menus (val
->contents
,
2569 /* Set the cursor to an arrow for popup menus when they are mapped.
2570 This is done by default for menu bar menus. */
2573 /* Must realize so the GdkWindow inside the widget is created. */
2574 gtk_widget_realize (w
);
2575 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2580 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2587 /* Return the label for menu item WITEM. */
2590 xg_get_menu_item_label (GtkMenuItem
*witem
)
2592 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2593 return gtk_label_get_label (wlabel
);
2596 /* Return non-zero if the menu item WITEM has the text LABEL. */
2599 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2602 char *utf8_label
= get_utf8_string (label
);
2603 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2605 if (! old_label
&& ! utf8_label
)
2607 else if (old_label
&& utf8_label
)
2608 is_same
= strcmp (utf8_label
, old_label
) == 0;
2610 if (utf8_label
) g_free (utf8_label
);
2615 /* Destroy widgets in LIST. */
2618 xg_destroy_widgets (GList
*list
)
2622 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2624 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2626 /* Destroying the widget will remove it from the container it is in. */
2627 gtk_widget_destroy (w
);
2631 /* Update the top level names in MENUBAR (i.e. not submenus).
2632 F is the frame the menu bar belongs to.
2633 *LIST is a list with the current menu bar names (menu item widgets).
2634 ITER is the item within *LIST that shall be updated.
2635 POS is the numerical position, starting at 0, of ITER in *LIST.
2636 VAL describes what the menu bar shall look like after the update.
2637 SELECT_CB is the callback to use when a menu item is selected.
2638 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2639 CL_DATA points to the callback data to be used for this menu bar.
2641 This function calls itself to walk through the menu bar names. */
2644 xg_update_menubar (GtkWidget
*menubar
,
2650 GCallback select_cb
,
2651 GCallback deactivate_cb
,
2652 GCallback highlight_cb
,
2653 xg_menu_cb_data
*cl_data
)
2655 if (! iter
&& ! val
)
2657 else if (iter
&& ! val
)
2659 /* Item(s) have been removed. Remove all remaining items. */
2660 xg_destroy_widgets (iter
);
2662 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2663 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2664 gtk_menu_item_new_with_label (""),
2670 else if (! iter
&& val
)
2672 /* Item(s) added. Add all new items in one call. */
2673 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2674 0, 1, 0, menubar
, cl_data
, 0);
2680 /* Below this neither iter or val is NULL */
2681 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2683 /* This item is still the same, check next item. */
2685 iter
= g_list_next (iter
);
2688 else /* This item is changed. */
2690 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2691 GtkMenuItem
*witem2
= 0;
2692 int val_in_menubar
= 0;
2693 int iter_in_new_menubar
= 0;
2697 /* See if the changed entry (val) is present later in the menu bar */
2699 iter2
&& ! val_in_menubar
;
2700 iter2
= g_list_next (iter2
))
2702 witem2
= GTK_MENU_ITEM (iter2
->data
);
2703 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2706 /* See if the current entry (iter) is present later in the
2707 specification for the new menu bar. */
2708 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2709 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2711 if (val_in_menubar
&& ! iter_in_new_menubar
)
2715 /* This corresponds to:
2720 g_object_ref (G_OBJECT (witem
));
2721 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2722 gtk_widget_destroy (GTK_WIDGET (witem
));
2724 /* Must get new list since the old changed. */
2725 g_list_free (*list
);
2726 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2727 while (nr
-- > 0) iter
= g_list_next (iter
);
2729 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2731 /* This corresponds to:
2734 Rename B to X. This might seem to be a strange thing to do,
2735 since if there is a menu under B it will be totally wrong for X.
2736 But consider editing a C file. Then there is a C-mode menu
2737 (corresponds to B above).
2738 If then doing C-x C-f the minibuf menu (X above) replaces the
2739 C-mode menu. When returning from the minibuffer, we get
2740 back the C-mode menu. Thus we do:
2741 Rename B to X (C-mode to minibuf menu)
2742 Rename X to B (minibuf to C-mode menu).
2743 If the X menu hasn't been invoked, the menu under B
2744 is up to date when leaving the minibuffer. */
2745 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2746 char *utf8_label
= get_utf8_string (val
->name
);
2747 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2749 gtk_label_set_text (wlabel
, utf8_label
);
2751 /* If this item has a submenu that has been detached, change
2752 the title in the WM decorations also. */
2753 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2754 /* Set the title of the detached window. */
2755 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2757 if (utf8_label
) g_free (utf8_label
);
2758 iter
= g_list_next (iter
);
2762 else if (! val_in_menubar
&& iter_in_new_menubar
)
2764 /* This corresponds to:
2771 GtkWidget
*w
= xg_create_one_menuitem (val
,
2778 /* Create a possibly empty submenu for menu bar items, since some
2779 themes don't highlight items correctly without it. */
2780 GtkWidget
*submenu
= create_menus (NULL
, f
,
2781 select_cb
, deactivate_cb
,
2783 0, 0, 0, 0, cl_data
, 0);
2784 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2785 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2786 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2788 g_list_free (*list
);
2789 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2790 while (nr
-- > 0) iter
= g_list_next (iter
);
2791 iter
= g_list_next (iter
);
2795 else /* if (val_in_menubar && iter_in_new_menubar) */
2798 /* This corresponds to:
2803 g_object_ref (G_OBJECT (witem2
));
2804 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2805 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2806 GTK_WIDGET (witem2
), pos
);
2807 g_object_unref (G_OBJECT (witem2
));
2809 g_list_free (*list
);
2810 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2811 while (nr
-- > 0) iter
= g_list_next (iter
);
2812 if (iter
) iter
= g_list_next (iter
);
2818 /* Update the rest of the menu bar. */
2819 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2820 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2823 /* Update the menu item W so it corresponds to VAL.
2824 SELECT_CB is the callback to use when a menu item is selected.
2825 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2826 CL_DATA is the data to set in the widget for menu invocation. */
2829 xg_update_menu_item (widget_value
*val
,
2831 GCallback select_cb
,
2832 GCallback highlight_cb
,
2833 xg_menu_cb_data
*cl_data
)
2840 const char *old_label
= 0;
2841 const char *old_key
= 0;
2842 xg_menu_item_cb_data
*cb_data
;
2844 wchild
= XG_BIN_CHILD (w
);
2845 utf8_label
= get_utf8_string (val
->name
);
2846 utf8_key
= get_utf8_string (val
->key
);
2848 /* See if W is a menu item with a key. See make_menu_item above. */
2849 if (GTK_IS_HBOX (wchild
))
2851 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2853 wlbl
= GTK_LABEL (list
->data
);
2854 wkey
= GTK_LABEL (list
->next
->data
);
2859 /* Remove the key and keep just the label. */
2860 g_object_ref (G_OBJECT (wlbl
));
2861 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2862 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2863 g_object_unref (G_OBJECT (wlbl
));
2868 else /* Just a label. */
2870 wlbl
= GTK_LABEL (wchild
);
2872 /* Check if there is now a key. */
2875 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2876 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2878 wlbl
= GTK_LABEL (list
->data
);
2879 wkey
= GTK_LABEL (list
->next
->data
);
2882 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2883 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2888 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2889 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2891 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2892 gtk_label_set_text (wkey
, utf8_key
);
2894 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2895 gtk_label_set_text (wlbl
, utf8_label
);
2897 if (utf8_key
) g_free (utf8_key
);
2898 if (utf8_label
) g_free (utf8_label
);
2900 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2901 gtk_widget_set_sensitive (w
, FALSE
);
2902 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2903 gtk_widget_set_sensitive (w
, TRUE
);
2905 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2909 cb_data
->call_data
= val
->call_data
;
2910 cb_data
->help
= val
->help
;
2911 cb_data
->cl_data
= cl_data
;
2913 /* We assume the callback functions don't change. */
2914 if (val
->call_data
&& ! val
->contents
)
2916 /* This item shall have a select callback. */
2917 if (! cb_data
->select_id
)
2919 = g_signal_connect (G_OBJECT (w
), "activate",
2920 select_cb
, cb_data
);
2922 else if (cb_data
->select_id
)
2924 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2925 cb_data
->select_id
= 0;
2930 /* Update the toggle menu item W so it corresponds to VAL. */
2933 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
2935 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2938 /* Update the radio menu item W so it corresponds to VAL. */
2941 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
2943 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2946 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2947 SUBMENU may be NULL, in that case a new menu is created.
2948 F is the frame the menu bar belongs to.
2949 VAL describes the contents of the menu bar.
2950 SELECT_CB is the callback to use when a menu item is selected.
2951 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2952 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2953 CL_DATA is the call back data to use for any newly created items.
2955 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2959 xg_update_submenu (GtkWidget
*submenu
,
2962 GCallback select_cb
,
2963 GCallback deactivate_cb
,
2964 GCallback highlight_cb
,
2965 xg_menu_cb_data
*cl_data
)
2967 GtkWidget
*newsub
= submenu
;
2971 int has_tearoff_p
= 0;
2972 GList
*first_radio
= 0;
2975 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2977 for (cur
= val
, iter
= list
;
2979 iter
= g_list_next (iter
), cur
= cur
->next
)
2981 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2983 /* Skip tearoff items, they have no counterpart in val. */
2984 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2987 iter
= g_list_next (iter
);
2988 if (iter
) w
= GTK_WIDGET (iter
->data
);
2992 /* Remember first radio button in a group. If we get a mismatch in
2993 a radio group we must rebuild the whole group so that the connections
2994 in GTK becomes correct. */
2995 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2997 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2998 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3001 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3003 if (! menu_separator_name_p (cur
->name
))
3006 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3008 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3010 xg_update_toggle_item (cur
, w
);
3011 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3013 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3015 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3017 xg_update_radio_item (cur
, w
);
3018 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3020 else if (GTK_IS_MENU_ITEM (w
))
3022 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3025 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3026 menu_separator_name_p (cur
->name
))
3029 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3031 sub
= gtk_menu_item_get_submenu (witem
);
3032 if (sub
&& ! cur
->contents
)
3034 /* Not a submenu anymore. */
3035 g_object_ref (G_OBJECT (sub
));
3036 remove_submenu (witem
);
3037 gtk_widget_destroy (sub
);
3039 else if (cur
->contents
)
3043 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3044 select_cb
, deactivate_cb
,
3045 highlight_cb
, cl_data
);
3047 /* If this item just became a submenu, we must set it. */
3049 gtk_menu_item_set_submenu (witem
, nsub
);
3054 /* Structural difference. Remove everything from here and down
3060 /* Remove widgets from first structural change. */
3063 /* If we are adding new menu items below, we must remove from
3064 first radio button so that radio groups become correct. */
3065 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3066 else xg_destroy_widgets (iter
);
3071 /* More items added. Create them. */
3072 newsub
= create_menus (cur
,
3085 if (list
) g_list_free (list
);
3090 /* Update the MENUBAR.
3091 F is the frame the menu bar belongs to.
3092 VAL describes the contents of the menu bar.
3093 If DEEP_P is non-zero, rebuild all but the top level menu names in
3094 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3095 SELECT_CB is the callback to use when a menu item is selected.
3096 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3097 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3100 xg_modify_menubar_widgets (GtkWidget
*menubar
, FRAME_PTR f
, widget_value
*val
,
3102 GCallback select_cb
, GCallback deactivate_cb
,
3103 GCallback highlight_cb
)
3105 xg_menu_cb_data
*cl_data
;
3106 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3110 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
3113 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3114 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3120 /* Update all sub menus.
3121 We must keep the submenus (GTK menu item widgets) since the
3122 X Window in the XEvent that activates the menu are those widgets. */
3124 /* Update cl_data, menu_item things in F may have changed. */
3125 update_cl_data (cl_data
, f
, highlight_cb
);
3127 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3132 GtkMenuItem
*witem
= 0;
3134 /* Find sub menu that corresponds to val and update it. */
3135 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3137 witem
= GTK_MENU_ITEM (iter
->data
);
3138 if (xg_item_label_same_p (witem
, cur
->name
))
3140 sub
= gtk_menu_item_get_submenu (witem
);
3145 newsub
= xg_update_submenu (sub
,
3152 /* sub may still be NULL. If we just updated non deep and added
3153 a new menu bar item, it has no sub menu yet. So we set the
3154 newly created sub menu under witem. */
3155 if (newsub
!= sub
&& witem
!= 0)
3157 xg_set_screen (newsub
, f
);
3158 gtk_menu_item_set_submenu (witem
, newsub
);
3164 gtk_widget_show_all (menubar
);
3167 /* Callback called when the menu bar W is mapped.
3168 Used to find the height of the menu bar if we didn't get it
3169 after showing the widget. */
3172 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3175 FRAME_PTR f
= (FRAME_PTR
) user_data
;
3176 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3177 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3179 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3180 xg_height_or_width_changed (f
);
3184 /* Recompute all the widgets of frame F, when the menu bar has been
3185 changed. Value is non-zero if widgets were updated. */
3188 xg_update_frame_menubar (FRAME_PTR f
)
3190 struct x_output
*x
= f
->output_data
.x
;
3193 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3196 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3197 return 0; /* Already done this, happens for frames created invisible. */
3201 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3203 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3205 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3206 gtk_widget_show_all (x
->menubar_widget
);
3207 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3209 /* If menu bar doesn't know its height yet, cheat a little so the frame
3210 doesn't jump so much when resized later in menubar_map_cb. */
3211 if (req
.height
== 0)
3214 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3216 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3217 xg_height_or_width_changed (f
);
3224 /* Get rid of the menu bar of frame F, and free its storage.
3225 This is used when deleting a frame, and when turning off the menu bar. */
3228 free_frame_menubar (FRAME_PTR f
)
3230 struct x_output
*x
= f
->output_data
.x
;
3232 if (x
->menubar_widget
)
3236 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3237 /* The menubar and its children shall be deleted when removed from
3239 x
->menubar_widget
= 0;
3240 FRAME_MENUBAR_HEIGHT (f
) = 0;
3241 xg_height_or_width_changed (f
);
3247 xg_event_is_for_menubar (FRAME_PTR f
, XEvent
*event
)
3249 struct x_output
*x
= f
->output_data
.x
;
3258 if (! x
->menubar_widget
) return 0;
3260 if (! (event
->xbutton
.x
>= 0
3261 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3262 && event
->xbutton
.y
>= 0
3263 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3264 && event
->xbutton
.same_screen
))
3267 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3268 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3270 gevent
.any
.window
= gw
;
3271 gevent
.any
.type
= GDK_NOTHING
;
3272 gwdesc
= gtk_get_event_widget (&gevent
);
3273 if (! gwdesc
) return 0;
3274 if (! GTK_IS_MENU_BAR (gwdesc
)
3275 && ! GTK_IS_MENU_ITEM (gwdesc
)
3276 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3279 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3280 if (! list
) return 0;
3281 rec
.x
= event
->xbutton
.x
;
3282 rec
.y
= event
->xbutton
.y
;
3286 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3288 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3289 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3293 return iter
== 0 ? 0 : 1;
3298 /***********************************************************************
3299 Scroll bar functions
3300 ***********************************************************************/
3303 /* Setting scroll bar values invokes the callback. Use this variable
3304 to indicate that callback should do nothing. */
3306 int xg_ignore_gtk_scrollbar
;
3308 /* The width of the scroll bar for the current theme. */
3310 static int scroll_bar_width_for_theme
;
3312 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3313 may be larger than 32 bits. Keep a mapping from integer index to widget
3314 pointers to get around the 32 bit limitation. */
3318 GtkWidget
**widgets
;
3323 /* Grow this much every time we need to allocate more */
3325 #define ID_TO_WIDGET_INCR 32
3327 /* Store the widget pointer W in id_to_widget and return the integer index. */
3330 xg_store_widget_in_map (GtkWidget
*w
)
3334 if (id_to_widget
.max_size
== id_to_widget
.used
)
3337 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3338 memory_full (SIZE_MAX
);
3340 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3341 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3342 new_size
, sizeof (GtkWidget
*));
3344 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3345 id_to_widget
.widgets
[i
] = 0;
3346 id_to_widget
.max_size
= new_size
;
3349 /* Just loop over the array and find a free place. After all,
3350 how many scroll bars are we creating? Should be a small number.
3351 The check above guarantees we will find a free place. */
3352 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3354 if (! id_to_widget
.widgets
[i
])
3356 id_to_widget
.widgets
[i
] = w
;
3357 ++id_to_widget
.used
;
3363 /* Should never end up here */
3367 /* Remove pointer at IDX from id_to_widget.
3368 Called when scroll bar is destroyed. */
3371 xg_remove_widget_from_map (ptrdiff_t idx
)
3373 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3375 id_to_widget
.widgets
[idx
] = 0;
3376 --id_to_widget
.used
;
3380 /* Get the widget pointer at IDX from id_to_widget. */
3383 xg_get_widget_from_map (ptrdiff_t idx
)
3385 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3386 return id_to_widget
.widgets
[idx
];
3392 update_theme_scrollbar_width (void)
3395 GtkAdjustment
*vadj
;
3402 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3403 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3404 g_object_ref_sink (G_OBJECT (wscroll
));
3405 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3406 gtk_widget_destroy (wscroll
);
3407 g_object_unref (G_OBJECT (wscroll
));
3410 scroll_bar_width_for_theme
= w
;
3414 xg_get_default_scrollbar_width (void)
3416 return scroll_bar_width_for_theme
;
3419 /* Return the scrollbar id for X Window WID on display DPY.
3420 Return -1 if WID not in id_to_widget. */
3423 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3428 w
= xg_win_to_widget (dpy
, wid
);
3432 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3433 if (id_to_widget
.widgets
[idx
] == w
)
3440 /* Callback invoked when scroll bar WIDGET is destroyed.
3441 DATA is the index into id_to_widget for WIDGET.
3442 We free pointer to last scroll bar values here and remove the index. */
3445 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3447 intptr_t id
= (intptr_t) data
;
3448 xg_remove_widget_from_map (id
);
3451 /* Create a scroll bar widget for frame F. Store the scroll bar
3453 SCROLL_CALLBACK is the callback to invoke when the value of the
3455 END_CALLBACK is the callback to invoke when scrolling ends.
3456 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3457 to set resources for the widget. */
3460 xg_create_scroll_bar (FRAME_PTR f
,
3461 struct scroll_bar
*bar
,
3462 GCallback scroll_callback
,
3463 GCallback end_callback
,
3464 const char *scroll_bar_name
)
3470 GtkAdjustment
*vadj
;
3475 /* Page, step increment values are not so important here, they
3476 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3477 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3480 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3481 webox
= gtk_event_box_new ();
3482 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3484 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3486 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3488 scroll_id
= xg_store_widget_in_map (wscroll
);
3490 g_signal_connect (G_OBJECT (wscroll
),
3492 G_CALLBACK (xg_gtk_scroll_destroy
),
3493 (gpointer
) scroll_id
);
3494 g_signal_connect (G_OBJECT (wscroll
),
3498 g_signal_connect (G_OBJECT (wscroll
),
3499 "button-release-event",
3503 /* The scroll bar widget does not draw on a window of its own. Instead
3504 it draws on the parent window, in this case the edit widget. So
3505 whenever the edit widget is cleared, the scroll bar needs to redraw
3506 also, which causes flicker. Put an event box between the edit widget
3507 and the scroll bar, so the scroll bar instead draws itself on the
3508 event box window. */
3509 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3510 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3513 /* Set the cursor to an arrow. */
3514 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3516 bar
->x_window
= scroll_id
;
3519 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3522 xg_remove_scroll_bar (FRAME_PTR f
, ptrdiff_t scrollbar_id
)
3524 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3527 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3528 gtk_widget_destroy (w
);
3529 gtk_widget_destroy (wparent
);
3530 SET_FRAME_GARBAGED (f
);
3534 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3536 TOP/LEFT are the new pixel positions where the bar shall appear.
3537 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3540 xg_update_scrollbar_pos (FRAME_PTR f
,
3541 ptrdiff_t scrollbar_id
,
3548 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3552 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3553 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3556 /* Clear out old position. */
3557 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3558 if (gtk_widget_get_parent (wparent
) == wfixed
)
3560 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3561 "x", &oldx
, "y", &oldy
, NULL
);
3562 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3565 /* Move and resize to new values. */
3566 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3567 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3570 /* No room. Hide scroll bar as some themes output a warning if
3571 the height is less than the min size. */
3572 gtk_widget_hide (wparent
);
3573 gtk_widget_hide (wscroll
);
3577 gtk_widget_show_all (wparent
);
3578 gtk_widget_set_size_request (wscroll
, width
, height
);
3580 gtk_widget_queue_draw (wfixed
);
3581 gdk_window_process_all_updates ();
3582 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3584 /* Clear under old scroll bar position. This must be done after
3585 the gtk_widget_queue_draw and gdk_window_process_all_updates
3587 x_clear_area (FRAME_X_DISPLAY (f
),
3589 oldx
, oldy
, oldw
, oldh
, 0);
3592 /* GTK does not redraw until the main loop is entered again, but
3593 if there are no X events pending we will not enter it. So we sync
3594 here to get some events. */
3597 SET_FRAME_GARBAGED (f
);
3598 cancel_mouse_face (f
);
3602 /* Get the current value of the range, truncated to an integer. */
3605 int_gtk_range_get_value (GtkRange
*range
)
3607 return gtk_range_get_value (range
);
3611 /* Set the thumb size and position of scroll bar BAR. We are currently
3612 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3615 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3620 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3622 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3624 if (wscroll
&& NILP (bar
->dragging
))
3634 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3636 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3637 rather than the real portion value. This makes the thumb less likely
3638 to resize and that looks better. */
3639 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3640 /* When the thumb is at the bottom, position == whole.
3641 So we need to increase `whole' to make space for the thumb. */
3648 top
= (gdouble
) position
/ whole
;
3649 shown
= (gdouble
) portion
/ whole
;
3652 size
= shown
* XG_SB_RANGE
;
3653 size
= min (size
, XG_SB_RANGE
);
3654 size
= max (size
, 1);
3656 value
= top
* XG_SB_RANGE
;
3657 value
= min (value
, XG_SB_MAX
- size
);
3658 value
= max (value
, XG_SB_MIN
);
3660 /* Assume all lines are of equal size. */
3661 new_step
= size
/ max (1, FRAME_LINES (f
));
3663 old_size
= gtk_adjustment_get_page_size (adj
);
3664 if (old_size
!= size
)
3666 int old_step
= gtk_adjustment_get_step_increment (adj
);
3667 if (old_step
!= new_step
)
3669 gtk_adjustment_set_page_size (adj
, size
);
3670 gtk_adjustment_set_step_increment (adj
, new_step
);
3671 /* Assume a page increment is about 95% of the page size */
3672 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3677 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3681 /* gtk_range_set_value invokes the callback. Set
3682 ignore_gtk_scrollbar to make the callback do nothing */
3683 xg_ignore_gtk_scrollbar
= 1;
3685 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3686 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3688 gtk_adjustment_changed (adj
);
3690 xg_ignore_gtk_scrollbar
= 0;
3697 /* Return non-zero if EVENT is for a scroll bar in frame F.
3698 When the same X window is used for several Gtk+ widgets, we cannot
3699 say for sure based on the X window alone if an event is for the
3700 frame. This function does additional checks.
3702 Return non-zero if the event is for a scroll bar, zero otherwise. */
3705 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3709 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3711 /* Check if press occurred outside the edit widget. */
3712 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3713 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3714 != gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3717 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3718 || event
->type
== MotionNotify
))
3720 /* If we are releasing or moving the scroll bar, it has the grab. */
3721 GtkWidget
*w
= gtk_grab_get_current ();
3722 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3730 /***********************************************************************
3732 ***********************************************************************/
3733 /* The key for the data we put in the GtkImage widgets. The data is
3734 the image used by Emacs. We use this to see if we need to update
3735 the GtkImage with a new image. */
3736 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3738 /* The key for storing the latest modifiers so the activate callback can
3740 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3742 /* The key for storing the button widget in its proxy menu item. */
3743 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3745 /* The key for the data we put in the GtkImage widgets. The data is
3746 the stock name used by Emacs. We use this to see if we need to update
3747 the GtkImage with a new image. */
3748 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3750 /* As above, but this is used for named theme widgets, as opposed to
3752 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3754 /* Callback function invoked when a tool bar item is pressed.
3755 W is the button widget in the tool bar that got pressed,
3756 CLIENT_DATA is an integer that is the index of the button in the
3757 tool bar. 0 is the first button. */
3760 xg_tool_bar_button_cb (GtkWidget
*widget
,
3761 GdkEventButton
*event
,
3764 intptr_t state
= event
->state
;
3765 gpointer ptr
= (gpointer
) state
;
3766 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3771 /* Callback function invoked when a tool bar item is pressed.
3772 W is the button widget in the tool bar that got pressed,
3773 CLIENT_DATA is an integer that is the index of the button in the
3774 tool bar. 0 is the first button. */
3777 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3779 intptr_t idx
= (intptr_t) client_data
;
3780 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3781 intptr_t mod
= (intptr_t) gmod
;
3783 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3784 Lisp_Object key
, frame
;
3785 struct input_event event
;
3788 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3791 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3793 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3794 XSETFRAME (frame
, f
);
3796 /* We generate two events here. The first one is to set the prefix
3797 to `(tool_bar)', see keyboard.c. */
3798 event
.kind
= TOOL_BAR_EVENT
;
3799 event
.frame_or_window
= frame
;
3801 kbd_buffer_store_event (&event
);
3803 event
.kind
= TOOL_BAR_EVENT
;
3804 event
.frame_or_window
= frame
;
3806 /* Convert between the modifier bits GDK uses and the modifier bits
3807 Emacs uses. This assumes GDK and X masks are the same, which they are when
3809 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3810 kbd_buffer_store_event (&event
);
3812 /* Return focus to the frame after we have clicked on a detached
3814 Fx_focus_frame (frame
);
3817 /* Callback function invoked when a tool bar item is pressed in a detached
3818 tool bar or the overflow drop down menu.
3819 We just call xg_tool_bar_callback.
3820 W is the menu item widget that got pressed,
3821 CLIENT_DATA is an integer that is the index of the button in the
3822 tool bar. 0 is the first button. */
3825 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3827 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3828 XG_TOOL_BAR_PROXY_BUTTON
));
3829 xg_tool_bar_callback (wbutton
, client_data
);
3834 xg_tool_bar_help_callback (GtkWidget
*w
,
3835 GdkEventCrossing
*event
,
3836 gpointer client_data
);
3838 /* This callback is called when a help is to be shown for an item in
3839 the detached tool bar when the detached tool bar it is not expanded. */
3842 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3843 GdkEventCrossing
*event
,
3844 gpointer client_data
)
3846 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3847 XG_TOOL_BAR_PROXY_BUTTON
));
3849 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3853 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3855 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3856 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3857 GtkWidget
*c2
= clist
->next
? (GtkWidget
*) clist
->next
->data
: NULL
;
3859 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3860 g_list_free (clist
);
3861 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3865 /* This callback is called when a tool item should create a proxy item,
3866 such as for the overflow menu. Also called when the tool bar is detached.
3867 If we don't create a proxy menu item, the detached tool bar will be
3871 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3873 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
3874 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
3876 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3877 GtkImage
*wimage
= GTK_IMAGE (c1
);
3878 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3879 (wlbl
? gtk_label_get_text (wlbl
) : "");
3880 GtkWidget
*wmenuimage
;
3883 if (gtk_button_get_use_stock (wbutton
))
3884 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3885 GTK_ICON_SIZE_MENU
);
3888 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3889 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3891 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
3893 if (store_type
== GTK_IMAGE_STOCK
)
3896 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3897 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3899 else if (store_type
== GTK_IMAGE_ICON_SET
)
3901 GtkIconSet
*icon_set
;
3902 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3903 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3904 GTK_ICON_SIZE_MENU
);
3906 else if (store_type
== GTK_IMAGE_PIXBUF
)
3911 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3914 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3916 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3917 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3918 GDK_INTERP_BILINEAR
);
3920 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3924 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3928 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3930 const gchar
*icon_name
;
3931 GtkIconSize icon_size
;
3933 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3934 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3935 GTK_ICON_SIZE_MENU
);
3939 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3944 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3946 g_signal_connect (G_OBJECT (wmenuitem
),
3948 G_CALLBACK (xg_tool_bar_proxy_callback
),
3952 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3953 (gpointer
) wbutton
);
3954 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3955 gtk_widget_set_sensitive (wmenuitem
,
3956 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
3958 /* Use enter/leave notify to show help. We use the events
3959 rather than the GtkButton specific signals "enter" and
3960 "leave", so we can have only one callback. The event
3961 will tell us what kind of event it is. */
3962 g_signal_connect (G_OBJECT (wmenuitem
),
3963 "enter-notify-event",
3964 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3966 g_signal_connect (G_OBJECT (wmenuitem
),
3967 "leave-notify-event",
3968 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3974 /* This callback is called when a tool bar is detached. We must set
3975 the height of the tool bar to zero when this happens so frame sizes
3976 are correctly calculated.
3977 WBOX is the handle box widget that enables detach/attach of the tool bar.
3978 W is the tool bar widget.
3979 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3982 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
3984 gpointer client_data
)
3986 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3988 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3993 GtkRequisition req
, req2
;
3994 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3995 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
3996 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
3997 req
.width
-= req2
.width
;
3998 req
.height
-= req2
.height
;
3999 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4000 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4001 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4002 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4003 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4004 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4005 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4006 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4007 xg_height_or_width_changed (f
);
4011 /* This callback is called when a tool bar is reattached. We must set
4012 the height of the tool bar when this happens so frame sizes
4013 are correctly calculated.
4014 WBOX is the handle box widget that enables detach/attach of the tool bar.
4015 W is the tool bar widget.
4016 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4019 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
4021 gpointer client_data
)
4023 FRAME_PTR f
= (FRAME_PTR
) client_data
;
4024 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4028 GtkRequisition req
, req2
;
4029 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
4030 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4031 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4032 req
.width
+= req2
.width
;
4033 req
.height
+= req2
.height
;
4034 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4035 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4036 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4037 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4038 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4039 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4040 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4041 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4042 xg_height_or_width_changed (f
);
4046 /* This callback is called when the mouse enters or leaves a tool bar item.
4047 It is used for displaying and hiding the help text.
4048 W is the tool bar item, a button.
4049 EVENT is either an enter event or leave event.
4050 CLIENT_DATA is an integer that is the index of the button in the
4051 tool bar. 0 is the first button.
4053 Returns FALSE to tell GTK to keep processing this event. */
4056 xg_tool_bar_help_callback (GtkWidget
*w
,
4057 GdkEventCrossing
*event
,
4058 gpointer client_data
)
4060 intptr_t idx
= (intptr_t) client_data
;
4061 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4062 Lisp_Object help
, frame
;
4064 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4067 if (event
->type
== GDK_ENTER_NOTIFY
)
4069 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4070 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4073 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4078 XSETFRAME (frame
, f
);
4079 kbd_buffer_store_help_event (frame
, help
);
4085 /* This callback is called when a tool bar item shall be redrawn.
4086 It modifies the expose event so that the GtkImage widget redraws the
4087 whole image. This to overcome a bug that makes GtkImage draw the image
4088 in the wrong place when it tries to redraw just a part of the image.
4089 W is the GtkImage to be redrawn.
4090 EVENT is the expose event for W.
4091 CLIENT_DATA is unused.
4093 Returns FALSE to tell GTK to keep processing this event. */
4097 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4098 GdkEventExpose
*event
,
4099 gpointer client_data
)
4103 gdk_drawable_get_size (event
->window
, &width
, &height
);
4104 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4105 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4107 event
->area
.x
= max (0, event
->area
.x
);
4108 event
->area
.y
= max (0, event
->area
.y
);
4110 event
->area
.width
= max (width
, event
->area
.width
);
4111 event
->area
.height
= max (height
, event
->area
.height
);
4117 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4118 #define toolbar_set_orientation(w, o) \
4119 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4121 #define toolbar_set_orientation(w, o) \
4122 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4125 /* Attach a tool bar to frame F. */
4128 xg_pack_tool_bar (FRAME_PTR f
, Lisp_Object pos
)
4130 struct x_output
*x
= f
->output_data
.x
;
4131 int into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4133 toolbar_set_orientation (x
->toolbar_widget
,
4135 ? GTK_ORIENTATION_VERTICAL
4136 : GTK_ORIENTATION_HORIZONTAL
);
4137 if (!x
->handlebox_widget
)
4139 x
->handlebox_widget
= gtk_handle_box_new ();
4140 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4141 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4142 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4143 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4144 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4150 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4152 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), x
->handlebox_widget
,
4155 if (EQ (pos
, Qleft
))
4156 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4157 x
->handlebox_widget
,
4159 x
->toolbar_in_hbox
= 1;
4163 int vbox_pos
= x
->menubar_widget
? 1 : 0;
4164 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4166 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
4170 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4171 x
->handlebox_widget
,
4173 x
->toolbar_in_hbox
= 0;
4177 /* Create a tool bar for frame F. */
4180 xg_create_tool_bar (FRAME_PTR f
)
4182 struct x_output
*x
= f
->output_data
.x
;
4184 x
->toolbar_widget
= gtk_toolbar_new ();
4185 x
->toolbar_detached
= 0;
4187 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4189 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4190 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4194 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4196 /* Find the right-to-left image named by RTL in the tool bar images for F.
4197 Returns IMAGE if RTL is not found. */
4200 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
4203 Lisp_Object file
, rtl_name
;
4204 struct gcpro gcpro1
, gcpro2
;
4205 GCPRO2 (file
, rtl_name
);
4207 rtl_name
= Ffile_name_nondirectory (rtl
);
4209 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4211 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4212 if (!NILP (file
= file_for_image (rtl_image
)))
4214 file
= call1 (intern ("file-name-sans-extension"),
4215 Ffile_name_nondirectory (file
));
4216 if (EQ (Fequal (file
, rtl_name
), Qt
))
4227 static GtkToolItem
*
4228 xg_make_tool_item (FRAME_PTR f
,
4230 GtkWidget
**wbutton
,
4232 int i
, int horiz
, int text_image
)
4234 GtkToolItem
*ti
= gtk_tool_item_new ();
4235 GtkWidget
*vb
= horiz
? gtk_hbox_new (FALSE
, 0) : gtk_vbox_new (FALSE
, 0);
4236 GtkWidget
*wb
= gtk_button_new ();
4237 /* The eventbox is here so we can have tooltips on disabled items. */
4238 GtkWidget
*weventbox
= gtk_event_box_new ();
4240 if (wimage
&& !text_image
)
4241 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4243 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4244 if (wimage
&& text_image
)
4245 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4247 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4248 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4249 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4250 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4251 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4253 if (wimage
|| label
)
4256 gpointer gi
= (gpointer
) ii
;
4258 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4259 G_CALLBACK (xg_tool_bar_menu_proxy
),
4262 g_signal_connect (G_OBJECT (wb
), "clicked",
4263 G_CALLBACK (xg_tool_bar_callback
),
4266 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4269 /* Catch expose events to overcome an annoying redraw bug, see
4270 comment for xg_tool_bar_item_expose_callback. */
4271 g_signal_connect (G_OBJECT (ti
),
4273 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4276 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4278 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4279 no distinction based on modifiers in the activate callback,
4280 so we have to do it ourselves. */
4281 g_signal_connect (wb
, "button-release-event",
4282 G_CALLBACK (xg_tool_bar_button_cb
),
4285 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4287 /* Use enter/leave notify to show help. We use the events
4288 rather than the GtkButton specific signals "enter" and
4289 "leave", so we can have only one callback. The event
4290 will tell us what kind of event it is. */
4291 g_signal_connect (G_OBJECT (weventbox
),
4292 "enter-notify-event",
4293 G_CALLBACK (xg_tool_bar_help_callback
),
4295 g_signal_connect (G_OBJECT (weventbox
),
4296 "leave-notify-event",
4297 G_CALLBACK (xg_tool_bar_help_callback
),
4301 if (wbutton
) *wbutton
= wb
;
4307 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4308 const char *icon_name
, const struct image
*img
,
4309 const char *label
, int horiz
)
4313 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4314 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4316 /* Check if the tool icon matches. */
4317 if (stock_name
&& wimage
)
4319 old
= g_object_get_data (G_OBJECT (wimage
),
4320 XG_TOOL_BAR_STOCK_NAME
);
4321 if (!old
|| strcmp (old
, stock_name
))
4324 else if (icon_name
&& wimage
)
4326 old
= g_object_get_data (G_OBJECT (wimage
),
4327 XG_TOOL_BAR_ICON_NAME
);
4328 if (!old
|| strcmp (old
, icon_name
))
4333 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4334 XG_TOOL_BAR_IMAGE_DATA
);
4335 Pixmap old_img
= (Pixmap
) gold_img
;
4336 if (old_img
!= img
->pixmap
)
4340 /* Check button configuration and label. */
4341 if ((horiz
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
))
4342 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4345 /* Ensure label is correct. */
4347 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4352 xg_update_tool_bar_sizes (FRAME_PTR f
)
4354 struct x_output
*x
= f
->output_data
.x
;
4356 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4358 gtk_widget_get_preferred_size (GTK_WIDGET (x
->handlebox_widget
), NULL
, &req
);
4359 if (x
->toolbar_in_hbox
)
4362 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4363 x
->handlebox_widget
,
4364 "position", &pos
, NULL
);
4365 if (pos
== 0) nl
= req
.width
;
4366 else nr
= req
.width
;
4371 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4372 x
->handlebox_widget
,
4373 "position", &pos
, NULL
);
4374 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4375 else nb
= req
.height
;
4378 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4379 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4380 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4381 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4383 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4384 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4385 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4386 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4387 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4388 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4396 /* Update the tool bar for frame F. Add new buttons and remove old. */
4399 update_frame_tool_bar (FRAME_PTR f
)
4402 struct x_output
*x
= f
->output_data
.x
;
4403 int hmargin
= 0, vmargin
= 0;
4404 GtkToolbar
*wtoolbar
;
4406 GtkTextDirection dir
;
4407 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
4409 int text_image
, horiz
;
4411 if (! FRAME_GTK_WIDGET (f
))
4416 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4418 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4419 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4421 else if (CONSP (Vtool_bar_button_margin
))
4423 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4424 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4426 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4427 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4430 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4431 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4432 i.e. zero. This means that margins less than
4433 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4434 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4435 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4437 if (! x
->toolbar_widget
)
4438 xg_create_tool_bar (f
);
4440 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4441 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4443 style
= Ftool_bar_get_system_style ();
4444 text_image
= EQ (style
, Qtext_image_horiz
);
4445 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4447 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4449 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4450 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4454 struct image
*img
= NULL
;
4456 Lisp_Object stock
= Qnil
;
4457 GtkStockItem stock_item
;
4458 char *stock_name
= NULL
;
4459 char *icon_name
= NULL
;
4461 GtkWidget
*wbutton
= NULL
;
4462 Lisp_Object specified_file
;
4463 int vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4465 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4466 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4467 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4470 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4472 /* If this is a separator, use a gtk separator item. */
4473 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4475 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4478 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4480 ti
= gtk_separator_tool_item_new ();
4481 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4487 /* Otherwise, the tool-bar item is an ordinary button. */
4489 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4491 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4495 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4497 /* Ignore invalid image specifications. */
4498 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4499 if (!valid_image_p (image
))
4502 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4507 specified_file
= file_for_image (image
);
4508 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4509 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4511 if (STRINGP (stock
))
4513 stock_name
= SSDATA (stock
);
4514 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4516 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4517 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4519 icon_name
= stock_name
+ 2;
4523 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4526 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4528 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4529 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4537 if (stock_name
== NULL
&& icon_name
== NULL
)
4539 /* No stock image, or stock item not known. Try regular
4540 image. If image is a vector, choose it according to the
4542 if (dir
== GTK_TEXT_DIR_RTL
4543 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4545 image
= find_rtl_image (f
, image
, rtl
);
4547 if (VECTORP (image
))
4551 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4552 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4555 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4556 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4558 eassert (ASIZE (image
) >= idx
);
4559 image
= AREF (image
, idx
);
4564 img_id
= lookup_image (f
, image
);
4565 img
= IMAGE_FROM_ID (f
, img_id
);
4566 prepare_image_for_display (f
, img
);
4568 if (img
->load_failed_p
|| img
->pixmap
== None
)
4571 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4577 /* If there is an existing widget, check if it's stale; if so,
4578 remove it and make a new tool item from scratch. */
4579 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4582 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4591 /* Save the image so we can see if an update is needed the
4592 next time we call xg_tool_item_match_p. */
4593 if (EQ (style
, Qtext
))
4595 else if (stock_name
)
4597 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4598 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4599 (gpointer
) xstrdup (stock_name
),
4600 (GDestroyNotify
) xfree
);
4604 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4605 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4606 (gpointer
) xstrdup (icon_name
),
4607 (GDestroyNotify
) xfree
);
4611 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4612 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4613 (gpointer
)img
->pixmap
);
4616 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4617 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4618 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4623 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4627 /* Remove buttons not longer needed. */
4630 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4632 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4633 } while (ti
!= NULL
);
4635 if (f
->n_tool_bar_items
!= 0)
4638 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4639 gtk_widget_show_all (GTK_WIDGET (x
->handlebox_widget
));
4640 if (xg_update_tool_bar_sizes (f
))
4641 xg_height_or_width_changed (f
);
4647 /* Deallocate all resources for the tool bar on frame F.
4648 Remove the tool bar. */
4651 free_frame_tool_bar (FRAME_PTR f
)
4653 struct x_output
*x
= f
->output_data
.x
;
4655 if (x
->toolbar_widget
)
4657 int is_packed
= x
->handlebox_widget
!= 0;
4659 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4660 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4663 if (x
->toolbar_in_hbox
)
4664 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4665 x
->handlebox_widget
);
4667 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4668 x
->handlebox_widget
);
4671 gtk_widget_destroy (x
->toolbar_widget
);
4673 x
->toolbar_widget
= 0;
4674 x
->handlebox_widget
= 0;
4675 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4676 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4678 xg_height_or_width_changed (f
);
4685 xg_change_toolbar_position (FRAME_PTR f
, Lisp_Object pos
)
4687 struct x_output
*x
= f
->output_data
.x
;
4689 if (! x
->toolbar_widget
|| ! x
->handlebox_widget
)
4693 g_object_ref (x
->handlebox_widget
);
4694 if (x
->toolbar_in_hbox
)
4695 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4696 x
->handlebox_widget
);
4698 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4699 x
->handlebox_widget
);
4700 xg_pack_tool_bar (f
, pos
);
4701 g_object_unref (x
->handlebox_widget
);
4702 if (xg_update_tool_bar_sizes (f
))
4703 xg_height_or_width_changed (f
);
4711 /***********************************************************************
4713 ***********************************************************************/
4715 xg_initialize (void)
4717 GtkBindingSet
*binding_set
;
4720 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4721 we keep it permanently linked in. */
4726 xg_ignore_gtk_scrollbar
= 0;
4727 xg_detached_menus
= 0;
4728 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4729 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4731 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4732 id_to_widget
.widgets
= 0;
4734 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4735 bindings. It doesn't seem to be any way to remove properties,
4736 so we set it to VoidSymbol which in X means "no key". */
4737 gtk_settings_set_string_property (gtk_settings_get_default (),
4738 "gtk-menu-bar-accel",
4742 /* Make GTK text input widgets use Emacs style keybindings. This is
4744 gtk_settings_set_string_property (gtk_settings_get_default (),
4745 "gtk-key-theme-name",
4749 /* Make dialogs close on C-g. Since file dialog inherits from
4750 dialog, this works for them also. */
4751 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4752 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4755 /* Make menus close on C-g. */
4756 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4757 (GTK_TYPE_MENU_SHELL
));
4758 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4760 update_theme_scrollbar_width ();
4763 #endif /* USE_GTK */