1 /* Functions for creating and updating GTK widgets.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
28 #include "blockinput.h"
29 #include "syssignal.h"
32 #include "termhooks.h"
36 #include <gdk/gdkkeysyms.h>
37 #include "xsettings.h"
40 #include <X11/Xft/Xft.h>
43 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
44 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
46 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
47 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
49 /* Avoid "differ in sign" warnings */
50 #define SSDATA(x) ((char *) SDATA (x))
52 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
53 #define gtk_widget_set_has_window(w, b) \
54 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
56 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
57 #define gtk_dialog_get_action_area(w) ((w)->action_area)
58 #define gtk_dialog_get_content_area(w) ((w)->vbox)
60 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
61 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
63 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
64 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
65 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
66 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
67 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
69 #if GTK_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 11
70 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
72 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
75 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
78 /***********************************************************************
79 Display handling functions
80 ***********************************************************************/
82 /* Keep track of the default display, or NULL if there is none. Emacs
83 may close all its displays. */
85 static GdkDisplay
*gdpy_def
;
87 /* When the GTK widget W is to be created on a display for F that
88 is not the default display, set the display for W.
89 W can be a GtkMenu or a GtkWindow widget. */
92 xg_set_screen (GtkWidget
*w
, FRAME_PTR f
)
94 if (FRAME_X_DISPLAY (f
) != GDK_DISPLAY ())
96 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
97 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
100 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
102 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
107 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
108 *DPY is set to NULL if the display can't be opened.
110 Returns non-zero if display could be opened, zero if display could not
111 be opened, and less than zero if the GTK version doesn't support
115 xg_display_open (char *display_name
, Display
**dpy
)
119 gdpy
= gdk_display_open (display_name
);
120 if (!gdpy_def
&& gdpy
)
123 gdk_display_manager_set_default_display (gdk_display_manager_get (),
127 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
131 /* Close display DPY. */
134 xg_display_close (Display
*dpy
)
136 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
138 /* If this is the default display, try to change it before closing.
139 If there is no other display to use, gdpy_def is set to NULL, and
140 the next call to xg_display_open resets the default display. */
141 if (gdk_display_get_default () == gdpy
)
143 struct x_display_info
*dpyinfo
;
144 GdkDisplay
*gdpy_new
= NULL
;
146 /* Find another display. */
147 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
148 if (dpyinfo
->display
!= dpy
)
150 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
151 gdk_display_manager_set_default_display (gdk_display_manager_get (),
158 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
159 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
160 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
161 can continue running, but there will be memory leaks. */
162 g_object_run_dispose (G_OBJECT (gdpy
));
164 /* This seems to be fixed in GTK 2.10. */
165 gdk_display_close (gdpy
);
170 /***********************************************************************
172 ***********************************************************************/
173 /* The next two variables and functions are taken from lwlib. */
174 static widget_value
*widget_value_free_list
;
175 static int malloc_cpt
;
177 /* Allocate a widget_value structure, either by taking one from the
178 widget_value_free_list or by malloc:ing a new one.
180 Return a pointer to the allocated structure. */
183 malloc_widget_value (void)
186 if (widget_value_free_list
)
188 wv
= widget_value_free_list
;
189 widget_value_free_list
= wv
->free_list
;
194 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
197 memset (wv
, 0, sizeof (widget_value
));
201 /* This is analogous to free. It frees only what was allocated
202 by malloc_widget_value, and no substructures. */
205 free_widget_value (widget_value
*wv
)
212 /* When the number of already allocated cells is too big,
219 wv
->free_list
= widget_value_free_list
;
220 widget_value_free_list
= wv
;
225 /* Create and return the cursor to be used for popup menus and
226 scroll bars on display DPY. */
229 xg_create_default_cursor (Display
*dpy
)
231 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
232 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
235 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
238 xg_get_pixbuf_from_pix_and_mask (GdkPixmap
*gpix
,
243 GdkPixbuf
*icon_buf
, *tmp_buf
;
245 gdk_drawable_get_size (gpix
, &width
, &height
);
246 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
247 0, 0, 0, 0, width
, height
);
248 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
249 g_object_unref (G_OBJECT (tmp_buf
));
253 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
258 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
259 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
260 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
261 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
264 for (y
= 0; y
< height
; ++y
)
266 guchar
*iconptr
, *maskptr
;
269 iconptr
= pixels
+ y
* rowstride
;
270 maskptr
= mask_pixels
+ y
* mask_rowstride
;
272 for (x
= 0; x
< width
; ++x
)
274 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
275 just R is sufficient. */
277 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
279 iconptr
+= rowstride
/width
;
280 maskptr
+= mask_rowstride
/width
;
284 g_object_unref (G_OBJECT (mask_buf
));
291 file_for_image (Lisp_Object image
)
293 Lisp_Object specified_file
= Qnil
;
296 for (tail
= XCDR (image
);
297 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
298 tail
= XCDR (XCDR (tail
)))
299 if (EQ (XCAR (tail
), QCfile
))
300 specified_file
= XCAR (XCDR (tail
));
302 return specified_file
;
305 /* For the image defined in IMG, make and return a GtkImage. For displays with
306 8 planes or less we must make a GdkPixbuf and apply the mask manually.
307 Otherwise the highlightning and dimming the tool bar code in GTK does
308 will look bad. For display with more than 8 planes we just use the
309 pixmap and mask directly. For monochrome displays, GTK doesn't seem
310 able to use external pixmaps, it looks bad whatever we do.
311 The image is defined on the display where frame F is.
312 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
313 If OLD_WIDGET is NULL, a new widget is constructed and returned.
314 If OLD_WIDGET is not NULL, that widget is modified. */
317 xg_get_image_for_pixmap (FRAME_PTR f
,
320 GtkImage
*old_widget
)
328 /* If we have a file, let GTK do all the image handling.
329 This seems to be the only way to make insensitive and activated icons
330 look good in all cases. */
331 Lisp_Object specified_file
= file_for_image (img
->spec
);
334 /* We already loaded the image once before calling this
335 function, so this only fails if the image file has been removed.
336 In that case, use the pixmap already loaded. */
338 if (STRINGP (specified_file
)
339 && STRINGP (file
= x_find_image_file (specified_file
)))
342 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
344 gtk_image_set_from_file (old_widget
, SSDATA (file
));
346 return GTK_WIDGET (old_widget
);
349 /* No file, do the image handling ourselves. This will look very bad
350 on a monochrome display, and sometimes bad on all displays with
353 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
354 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
355 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
357 /* This is a workaround to make icons look good on pseudo color
358 displays. Apparently GTK expects the images to have an alpha
359 channel. If they don't, insensitive and activated icons will
360 look bad. This workaround does not work on monochrome displays,
361 and is strictly not needed on true color/static color displays (i.e.
362 16 bits and higher). But we do it anyway so we get a pixbuf that is
363 not associated with the img->pixmap. The img->pixmap may be removed
364 by clearing the image cache and then the tool bar redraw fails, since
365 Gtk+ assumes the pixmap is always there. */
366 cmap
= gtk_widget_get_colormap (widget
);
367 icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
370 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
372 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
374 g_object_unref (G_OBJECT (icon_buf
));
376 g_object_unref (G_OBJECT (gpix
));
377 if (gmask
) g_object_unref (G_OBJECT (gmask
));
379 return GTK_WIDGET (old_widget
);
383 /* Set CURSOR on W and all widgets W contain. We must do like this
384 for scroll bars and menu because they create widgets internally,
385 and it is those widgets that are visible. */
388 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
390 GdkWindow
*window
= gtk_widget_get_window(w
);
391 GList
*children
= gdk_window_peek_children (window
);
393 gdk_window_set_cursor (window
, cursor
);
395 /* The scroll bar widget has more than one GDK window (had to look at
396 the source to figure this out), and there is no way to set cursor
397 on widgets in GTK. So we must set the cursor for all GDK windows.
400 for ( ; children
; children
= g_list_next (children
))
401 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
404 /* Insert NODE into linked LIST. */
407 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
409 xg_list_node
*list_start
= list
->next
;
411 if (list_start
) list_start
->prev
= node
;
412 node
->next
= list_start
;
417 /* Remove NODE from linked LIST. */
420 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
422 xg_list_node
*list_start
= list
->next
;
423 if (node
== list_start
)
425 list
->next
= node
->next
;
426 if (list
->next
) list
->next
->prev
= 0;
430 node
->prev
->next
= node
->next
;
431 if (node
->next
) node
->next
->prev
= node
->prev
;
435 /* Allocate and return a utf8 version of STR. If STR is already
436 utf8 or NULL, just return a copy of STR.
437 A new string is allocated and the caller must free the result
441 get_utf8_string (const char *str
)
445 if (!str
) return NULL
;
447 /* If not UTF-8, try current locale. */
448 if (!g_utf8_validate (str
, -1, NULL
))
449 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
451 return g_strdup (str
);
455 /* Probably some control characters in str. Escape them. */
459 unsigned char *p
= (unsigned char *)str
;
461 GError
*error
= NULL
;
463 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
464 &bytes_written
, &error
))
465 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
468 p
+= bytes_written
+1;
469 g_error_free (error
);
475 g_error_free (error
);
480 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
481 p
= (unsigned char *)str
;
483 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
484 &bytes_written
, &error
))
485 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
487 strncpy (up
, (char *)p
, bytes_written
);
488 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
489 up
[bytes_written
+4] = '\0';
490 up
+= bytes_written
+4;
491 p
+= bytes_written
+1;
492 g_error_free (error
);
498 strcat (utf8_str
, cp
);
503 g_error_free (error
);
510 /* Check for special colors used in face spec for region face.
511 The colors are fetched from the Gtk+ theme.
512 Return 1 if color was found, 0 if not. */
515 xg_check_special_colors (struct frame
*f
,
516 const char *color_name
,
520 if (FRAME_GTK_WIDGET (f
))
522 if (strcmp ("gtk_selection_bg_color", color_name
) == 0)
524 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
525 color
->red
= gsty
->bg
[GTK_STATE_SELECTED
].red
;
526 color
->green
= gsty
->bg
[GTK_STATE_SELECTED
].green
;
527 color
->blue
= gsty
->bg
[GTK_STATE_SELECTED
].blue
;
528 color
->pixel
= gsty
->bg
[GTK_STATE_SELECTED
].pixel
;
531 else if (strcmp ("gtk_selection_fg_color", color_name
) == 0)
533 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
534 color
->red
= gsty
->fg
[GTK_STATE_SELECTED
].red
;
535 color
->green
= gsty
->fg
[GTK_STATE_SELECTED
].green
;
536 color
->blue
= gsty
->fg
[GTK_STATE_SELECTED
].blue
;
537 color
->pixel
= gsty
->fg
[GTK_STATE_SELECTED
].pixel
;
547 /***********************************************************************
549 ***********************************************************************/
550 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
551 We use that to pop down the tooltip. This happens if Gtk+ for some
552 reason wants to change or hide the tooltip. */
554 #ifdef USE_GTK_TOOLTIP
557 hierarchy_ch_cb (GtkWidget
*widget
,
558 GtkWidget
*previous_toplevel
,
561 FRAME_PTR f
= (FRAME_PTR
) user_data
;
562 struct x_output
*x
= f
->output_data
.x
;
563 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
565 if (! top
|| ! GTK_IS_WINDOW (top
))
566 gtk_widget_hide (previous_toplevel
);
569 /* Callback called when Gtk+ thinks a tooltip should be displayed.
570 We use it to get the tooltip window and the tooltip widget so
571 we can manipulate the ourselves.
573 Return FALSE ensures that the tooltip is not shown. */
576 qttip_cb (GtkWidget
*widget
,
579 gboolean keyboard_mode
,
583 FRAME_PTR f
= (FRAME_PTR
) user_data
;
584 struct x_output
*x
= f
->output_data
.x
;
585 if (x
->ttip_widget
== NULL
)
587 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
588 x
->ttip_widget
= tooltip
;
589 g_object_ref (G_OBJECT (tooltip
));
590 x
->ttip_lbl
= gtk_label_new ("");
591 g_object_ref (G_OBJECT (x
->ttip_lbl
));
592 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
593 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
594 /* ATK needs an empty title for some reason. */
595 gtk_window_set_title (x
->ttip_window
, "");
596 /* Realize so we can safely get screen later on. */
597 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
598 gtk_widget_realize (x
->ttip_lbl
);
600 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
601 G_CALLBACK (hierarchy_ch_cb
), f
);
606 #endif /* USE_GTK_TOOLTIP */
608 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
609 Return zero if no system tooltip available, non-zero otherwise. */
612 xg_prepare_tooltip (FRAME_PTR f
,
617 #ifndef USE_GTK_TOOLTIP
620 struct x_output
*x
= f
->output_data
.x
;
624 GtkSettings
*settings
;
625 gboolean tt_enabled
= TRUE
;
627 Lisp_Object encoded_string
;
629 if (!x
->ttip_lbl
) return 0;
632 encoded_string
= ENCODE_UTF_8 (string
);
633 widget
= GTK_WIDGET (x
->ttip_lbl
);
634 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
635 screen
= gdk_drawable_get_screen (gwin
);
636 settings
= gtk_settings_get_for_screen (screen
);
637 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
640 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
641 /* Record that we disabled it so it can be enabled again. */
642 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
646 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
647 g_object_set_data (G_OBJECT
648 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
649 "gdk-display-current-tooltip", NULL
);
651 /* Put out dummy widget in so we can get callbacks for unrealize and
652 hierarchy-changed. */
653 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
655 gtk_tooltip_set_text (x
->ttip_widget
, SDATA (encoded_string
));
656 gtk_widget_size_request (GTK_WIDGET (x
->ttip_window
), &req
);
657 if (width
) *width
= req
.width
;
658 if (height
) *height
= req
.height
;
663 #endif /* USE_GTK_TOOLTIP */
666 /* Show the tooltip at ROOT_X and ROOT_Y.
667 xg_prepare_tooltip must have been called before this function. */
670 xg_show_tooltip (FRAME_PTR f
, int root_x
, int root_y
)
672 #ifdef USE_GTK_TOOLTIP
673 struct x_output
*x
= f
->output_data
.x
;
677 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
678 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
684 /* Hide tooltip if shown. Do nothing if not shown.
685 Return non-zero if tip was hidden, non-ero if not (i.e. not using
689 xg_hide_tooltip (FRAME_PTR f
)
692 #ifdef USE_GTK_TOOLTIP
693 if (f
->output_data
.x
->ttip_window
)
695 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
697 gtk_widget_hide (GTK_WIDGET (win
));
699 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
701 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
702 GdkScreen
*screen
= gdk_drawable_get_screen (gwin
);
703 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
704 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
715 /***********************************************************************
716 General functions for creating widgets, resizing, events, e.t.c.
717 ***********************************************************************/
719 /* Make a geometry string and pass that to GTK. It seems this is the
720 only way to get geometry position right if the user explicitly
721 asked for a position when starting Emacs.
722 F is the frame we shall set geometry for. */
725 xg_set_geometry (FRAME_PTR f
)
727 if (f
->size_hint_flags
& (USPosition
| PPosition
))
729 int left
= f
->left_pos
;
730 int xneg
= f
->size_hint_flags
& XNegative
;
731 int top
= f
->top_pos
;
732 int yneg
= f
->size_hint_flags
& YNegative
;
740 sprintf (geom_str
, "=%dx%d%c%d%c%d",
741 FRAME_PIXEL_WIDTH (f
),
742 FRAME_PIXEL_HEIGHT (f
),
743 (xneg
? '-' : '+'), left
,
744 (yneg
? '-' : '+'), top
);
746 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
748 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
752 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
753 and use a GtkFixed widget, this doesn't happen automatically. */
756 xg_clear_under_internal_border (FRAME_PTR f
)
758 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
760 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
761 gtk_widget_queue_draw (wfixed
);
762 gdk_window_process_all_updates ();
763 x_clear_area (FRAME_X_DISPLAY (f
),
766 FRAME_PIXEL_WIDTH (f
),
767 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
768 x_clear_area (FRAME_X_DISPLAY (f
),
771 FRAME_INTERNAL_BORDER_WIDTH (f
),
772 FRAME_PIXEL_HEIGHT (f
), 0);
773 x_clear_area (FRAME_X_DISPLAY (f
),
775 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
776 FRAME_PIXEL_WIDTH (f
),
777 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
778 x_clear_area (FRAME_X_DISPLAY (f
),
780 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
782 FRAME_INTERNAL_BORDER_WIDTH (f
),
783 FRAME_PIXEL_HEIGHT (f
), 0);
787 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
788 and a Gtk+ menu bar, we get resize events for the edit part of the
789 frame only. We let Gtk+ deal with the Gtk+ parts.
790 F is the frame to resize.
791 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
794 xg_frame_resized (FRAME_PTR f
, int pixelwidth
, int pixelheight
)
798 if (pixelwidth
== -1 && pixelheight
== -1)
800 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
801 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
803 &pixelwidth
, &pixelheight
, 0);
808 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
809 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
811 if (columns
!= FRAME_COLS (f
)
812 || rows
!= FRAME_LINES (f
)
813 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
814 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
816 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
817 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
819 xg_clear_under_internal_border (f
);
820 change_frame_size (f
, rows
, columns
, 0, 1, 0);
821 SET_FRAME_GARBAGED (f
);
822 cancel_mouse_face (f
);
826 /* Resize the outer window of frame F after chainging the height.
827 COLUMNS/ROWS is the size the edit area shall have after the resize. */
830 xg_frame_set_char_size (FRAME_PTR f
, int cols
, int rows
)
832 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
833 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
836 if (FRAME_PIXEL_HEIGHT (f
) == 0)
839 /* Take into account the size of the scroll bar. Always use the
840 number of columns occupied by the scroll bar here otherwise we
841 might end up with a frame width that is not a multiple of the
842 frame's character width which is bad for vertically split
844 f
->scroll_bar_actual_width
845 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
847 compute_fringe_widths (f
, 0);
849 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
850 after calculating that value. */
851 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
852 + FRAME_TOOLBAR_WIDTH (f
);
855 /* Do this before resize, as we don't know yet if we will be resized. */
856 xg_clear_under_internal_border (f
);
858 /* Must resize our top level widget. Font size may have changed,
859 but not rows/cols. */
860 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
861 pixelwidth
, pixelheight
);
862 x_wm_set_size_hint (f
, 0, 0);
864 SET_FRAME_GARBAGED (f
);
865 cancel_mouse_face (f
);
867 /* We can not call change_frame_size for a mapped frame,
868 we can not set pixel width/height either. The window manager may
869 override our resize request, XMonad does this all the time.
870 The best we can do is try to sync, so lisp code sees the updated
871 size as fast as possible.
872 For unmapped windows, we can set rows/cols. When
873 the frame is mapped again we will (hopefully) get the correct size. */
874 if (f
->async_visible
)
876 /* Must call this to flush out events */
877 (void)gtk_events_pending ();
879 x_wait_for_event (f
, ConfigureNotify
);
883 change_frame_size (f
, rows
, cols
, 0, 1, 0);
884 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
885 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
889 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
890 The policy is to keep the number of editable lines. */
893 xg_height_or_width_changed (FRAME_PTR f
)
895 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
896 FRAME_TOTAL_PIXEL_WIDTH (f
),
897 FRAME_TOTAL_PIXEL_HEIGHT (f
));
898 f
->output_data
.x
->hint_flags
= 0;
899 x_wm_set_size_hint (f
, 0, 0);
902 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
903 Must be done like this, because GtkWidget:s can have "hidden"
904 X Window that aren't accessible.
906 Return 0 if no widget match WDESC. */
909 xg_win_to_widget (Display
*dpy
, Window wdesc
)
912 GtkWidget
*gwdesc
= 0;
916 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
921 event
.any
.window
= gdkwin
;
922 gwdesc
= gtk_get_event_widget (&event
);
929 /* Fill in the GdkColor C so that it represents PIXEL.
930 W is the widget that color will be used for. Used to find colormap. */
933 xg_pix_to_gcolor (GtkWidget
*w
, long unsigned int pixel
, GdkColor
*c
)
935 GdkColormap
*map
= gtk_widget_get_colormap (w
);
936 gdk_colormap_query_color (map
, pixel
, c
);
939 /* Callback called when the gtk theme changes.
940 We notify lisp code so it can fix faces used for region for example. */
943 style_changed_cb (GObject
*go
,
947 struct input_event event
;
948 GdkDisplay
*gdpy
= (GdkDisplay
*) user_data
;
949 const char *display_name
= gdk_display_get_name (gdpy
);
952 event
.kind
= CONFIG_CHANGED_EVENT
;
953 event
.frame_or_window
= make_string (display_name
, strlen (display_name
));
954 /* Theme doesn't change often, so intern is called seldom. */
955 event
.arg
= intern ("theme-name");
956 kbd_buffer_store_event (&event
);
959 /* Create and set up the GTK widgets for frame F.
960 Return 0 if creation failed, non-zero otherwise. */
963 xg_create_frame_widgets (FRAME_PTR f
)
966 GtkWidget
*wvbox
, *whbox
;
974 if (FRAME_X_EMBEDDED_P (f
))
975 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
977 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
979 xg_set_screen (wtop
, f
);
981 wvbox
= gtk_vbox_new (FALSE
, 0);
982 whbox
= gtk_hbox_new (FALSE
, 0);
983 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
985 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
987 if (wtop
) gtk_widget_destroy (wtop
);
988 if (wvbox
) gtk_widget_destroy (wvbox
);
989 if (whbox
) gtk_widget_destroy (whbox
);
990 if (wfixed
) gtk_widget_destroy (wfixed
);
996 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
997 gtk_widget_set_name (wtop
, EMACS_CLASS
);
998 gtk_widget_set_name (wvbox
, "pane");
999 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1001 /* If this frame has a title or name, set it in the title bar. */
1002 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1003 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1005 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1007 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1008 FRAME_GTK_WIDGET (f
) = wfixed
;
1009 f
->output_data
.x
->vbox_widget
= wvbox
;
1010 f
->output_data
.x
->hbox_widget
= whbox
;
1012 gtk_widget_set_has_window (wfixed
, TRUE
);
1014 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1015 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1016 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1018 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1019 update_frame_tool_bar (f
);
1021 /* We don't want this widget double buffered, because we draw on it
1022 with regular X drawing primitives, so from a GTK/GDK point of
1023 view, the widget is totally blank. When an expose comes, this
1024 will make the widget blank, and then Emacs redraws it. This flickers
1025 a lot, so we turn off double buffering. */
1026 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1028 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1029 SSDATA (Vx_resource_name
),
1030 SSDATA (Vx_resource_class
));
1032 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1033 GTK is to destroy the widget. We want Emacs to do that instead. */
1034 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1035 G_CALLBACK (gtk_true
), 0);
1037 /* Convert our geometry parameters into a geometry string
1039 GTK will itself handle calculating the real position this way. */
1040 xg_set_geometry (f
);
1042 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1044 gtk_widget_add_events (wfixed
,
1045 GDK_POINTER_MOTION_MASK
1047 | GDK_BUTTON_PRESS_MASK
1048 | GDK_BUTTON_RELEASE_MASK
1049 | GDK_KEY_PRESS_MASK
1050 | GDK_ENTER_NOTIFY_MASK
1051 | GDK_LEAVE_NOTIFY_MASK
1052 | GDK_FOCUS_CHANGE_MASK
1053 | GDK_STRUCTURE_MASK
1054 | GDK_VISIBILITY_NOTIFY_MASK
);
1056 /* Must realize the windows so the X window gets created. It is used
1057 by callers of this function. */
1058 gtk_widget_realize (wfixed
);
1059 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1061 /* Since GTK clears its window by filling with the background color,
1062 we must keep X and GTK background in sync. */
1063 xg_pix_to_gcolor (wfixed
, FRAME_BACKGROUND_PIXEL (f
), &bg
);
1064 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
1066 /* Also, do not let any background pixmap to be set, this looks very
1067 bad as Emacs overwrites the background pixmap with its own idea
1068 of background color. */
1069 style
= gtk_widget_get_modifier_style (wfixed
);
1071 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1072 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1073 gtk_widget_modify_style (wfixed
, style
);
1075 #ifdef USE_GTK_TOOLTIP
1076 /* Steal a tool tip window we can move ourselves. */
1077 f
->output_data
.x
->ttip_widget
= 0;
1078 f
->output_data
.x
->ttip_lbl
= 0;
1079 f
->output_data
.x
->ttip_window
= 0;
1080 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1081 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1085 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1086 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1087 /* Only connect this signal once per screen. */
1088 if (! g_signal_handler_find (G_OBJECT (gs
),
1089 G_SIGNAL_MATCH_FUNC
,
1091 G_CALLBACK (style_changed_cb
),
1094 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1095 G_CALLBACK (style_changed_cb
),
1096 gdk_screen_get_display (screen
));
1106 xg_free_frame_widgets (FRAME_PTR f
)
1108 if (FRAME_GTK_OUTER_WIDGET (f
))
1110 struct x_output
*x
= f
->output_data
.x
;
1111 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1112 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1113 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1114 #ifdef USE_GTK_TOOLTIP
1116 gtk_widget_destroy (x
->ttip_lbl
);
1118 g_object_unref (G_OBJECT (x
->ttip_widget
));
1123 /* Set the normal size hints for the window manager, for frame F.
1124 FLAGS is the flags word to use--or 0 meaning preserve the flags
1125 that the window now has.
1126 If USER_POSITION is nonzero, we set the User Position
1127 flag (this is useful when FLAGS is 0). */
1130 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
1132 /* Must use GTK routines here, otherwise GTK resets the size hints
1133 to its own defaults. */
1134 GdkGeometry size_hints
;
1135 gint hint_flags
= 0;
1136 int base_width
, base_height
;
1137 int min_rows
= 0, min_cols
= 0;
1138 int win_gravity
= f
->win_gravity
;
1140 /* Don't set size hints during initialization; that apparently leads
1141 to a race condition. See the thread at
1142 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1143 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1148 memset (&size_hints
, 0, sizeof (size_hints
));
1149 f
->output_data
.x
->size_hints
= size_hints
;
1150 f
->output_data
.x
->hint_flags
= hint_flags
;
1153 flags
= f
->size_hint_flags
;
1155 size_hints
= f
->output_data
.x
->size_hints
;
1156 hint_flags
= f
->output_data
.x
->hint_flags
;
1158 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1159 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1160 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1162 hint_flags
|= GDK_HINT_BASE_SIZE
;
1163 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0) + FRAME_TOOLBAR_WIDTH (f
);
1164 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
1165 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1167 check_frame_size (f
, &min_rows
, &min_cols
);
1169 size_hints
.base_width
= base_width
;
1170 size_hints
.base_height
= base_height
;
1171 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1172 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1174 /* These currently have a one to one mapping with the X values, but I
1175 don't think we should rely on that. */
1176 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1177 size_hints
.win_gravity
= 0;
1178 if (win_gravity
== NorthWestGravity
)
1179 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1180 else if (win_gravity
== NorthGravity
)
1181 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1182 else if (win_gravity
== NorthEastGravity
)
1183 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1184 else if (win_gravity
== WestGravity
)
1185 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1186 else if (win_gravity
== CenterGravity
)
1187 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1188 else if (win_gravity
== EastGravity
)
1189 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1190 else if (win_gravity
== SouthWestGravity
)
1191 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1192 else if (win_gravity
== SouthGravity
)
1193 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1194 else if (win_gravity
== SouthEastGravity
)
1195 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1196 else if (win_gravity
== StaticGravity
)
1197 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1201 hint_flags
&= ~GDK_HINT_POS
;
1202 hint_flags
|= GDK_HINT_USER_POS
;
1205 if (hint_flags
!= f
->output_data
.x
->hint_flags
1206 || memcmp (&size_hints
,
1207 &f
->output_data
.x
->size_hints
,
1208 sizeof (size_hints
)) != 0)
1211 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1212 NULL
, &size_hints
, hint_flags
);
1213 f
->output_data
.x
->size_hints
= size_hints
;
1214 f
->output_data
.x
->hint_flags
= hint_flags
;
1219 /* Change background color of a frame.
1220 Since GTK uses the background color to clear the window, we must
1221 keep the GTK and X colors in sync.
1222 F is the frame to change,
1223 BG is the pixel value to change to. */
1226 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
1228 if (FRAME_GTK_WIDGET (f
))
1233 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
1234 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
1240 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1241 functions so GTK does not overwrite the icon. */
1244 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1246 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1247 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
1248 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
1249 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
1251 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1256 /***********************************************************************
1258 ***********************************************************************/
1259 /* Return the dialog title to use for a dialog of type KEY.
1260 This is the encoding used by lwlib. We use the same for GTK. */
1263 get_dialog_title (char key
)
1265 const char *title
= "";
1273 title
= "Information";
1292 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1293 the dialog, but return TRUE so the event does not propagate further
1294 in GTK. This prevents GTK from destroying the dialog widget automatically
1295 and we can always destrou the widget manually, regardles of how
1296 it was popped down (button press or WM_DELETE_WINDOW).
1297 W is the dialog widget.
1298 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1299 user_data is NULL (not used).
1301 Returns TRUE to end propagation of event. */
1304 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1306 gtk_widget_unmap (w
);
1310 /* Create a popup dialog window. See also xg_create_widget below.
1311 WV is a widget_value describing the dialog.
1312 SELECT_CB is the callback to use when a button has been pressed.
1313 DEACTIVATE_CB is the callback to use when the dialog pops down.
1315 Returns the GTK dialog widget. */
1318 create_dialog (widget_value
*wv
,
1319 GCallback select_cb
,
1320 GCallback deactivate_cb
)
1322 const char *title
= get_dialog_title (wv
->name
[0]);
1323 int total_buttons
= wv
->name
[1] - '0';
1324 int right_buttons
= wv
->name
[4] - '0';
1327 int button_spacing
= 10;
1328 GtkWidget
*wdialog
= gtk_dialog_new ();
1329 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1330 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1333 GtkWidget
*whbox_up
;
1334 GtkWidget
*whbox_down
;
1336 /* If the number of buttons is greater than 4, make two rows of buttons
1337 instead. This looks better. */
1338 int make_two_rows
= total_buttons
> 4;
1340 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1341 left_buttons
= total_buttons
- right_buttons
;
1343 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1344 gtk_widget_set_name (wdialog
, "emacs-dialog");
1349 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1350 whbox_up
= gtk_hbox_new (FALSE
, 0);
1351 whbox_down
= gtk_hbox_new (FALSE
, 0);
1353 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1354 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1355 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1357 cur_box
= GTK_BOX (whbox_up
);
1360 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1361 G_CALLBACK (dialog_delete_callback
), 0);
1365 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1366 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1369 for (item
= wv
->contents
; item
; item
= item
->next
)
1371 char *utf8_label
= get_utf8_string (item
->value
);
1375 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1377 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1378 /* This is the text part of the dialog. */
1379 w
= gtk_label_new (utf8_label
);
1380 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1381 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1382 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1384 /* Try to make dialog look better. Must realize first so
1385 the widget can calculate the size it needs. */
1386 gtk_widget_realize (w
);
1387 gtk_widget_size_request (w
, &req
);
1388 gtk_box_set_spacing (wvbox
, req
.height
);
1389 if (item
->value
&& strlen (item
->value
) > 0)
1390 button_spacing
= 2*req
.width
/strlen (item
->value
);
1394 /* This is one button to add to the dialog. */
1395 w
= gtk_button_new_with_label (utf8_label
);
1396 if (! item
->enabled
)
1397 gtk_widget_set_sensitive (w
, FALSE
);
1399 g_signal_connect (G_OBJECT (w
), "clicked",
1400 select_cb
, item
->call_data
);
1402 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1403 if (++button_nr
== left_buttons
)
1406 cur_box
= GTK_BOX (whbox_down
);
1408 gtk_box_pack_start (cur_box
,
1416 g_free (utf8_label
);
1422 struct xg_dialog_data
1430 /* Function that is called when the file or font dialogs pop down.
1431 W is the dialog widget, RESPONSE is the response code.
1432 USER_DATA is what we passed in to g_signal_connect. */
1435 xg_dialog_response_cb (GtkDialog
*w
,
1439 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1440 dd
->response
= response
;
1441 g_main_loop_quit (dd
->loop
);
1445 /* Destroy the dialog. This makes it pop down. */
1448 pop_down_dialog (Lisp_Object arg
)
1450 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1451 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1454 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1455 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1457 g_main_loop_quit (dd
->loop
);
1458 g_main_loop_unref (dd
->loop
);
1465 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1466 We pass in DATA as gpointer* so we can use this as a callback. */
1469 xg_maybe_add_timer (gpointer data
)
1471 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1472 EMACS_TIME next_time
= timer_check (1);
1473 long secs
= EMACS_SECS (next_time
);
1474 long usecs
= EMACS_USECS (next_time
);
1478 if (secs
>= 0 && usecs
>= 0 && secs
< ((guint
)-1)/1000)
1480 dd
->timerid
= g_timeout_add (secs
* 1000 + usecs
/1000,
1488 /* Pops up a modal dialog W and waits for response.
1489 We don't use gtk_dialog_run because we want to process emacs timers.
1490 The dialog W is not destroyed when this function returns. */
1493 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1495 int count
= SPECPDL_INDEX ();
1496 struct xg_dialog_data dd
;
1498 xg_set_screen (w
, f
);
1499 gtk_window_set_transient_for (GTK_WINDOW (w
),
1500 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1501 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1502 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1504 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1505 dd
.response
= GTK_RESPONSE_CANCEL
;
1509 g_signal_connect (G_OBJECT (w
),
1511 G_CALLBACK (xg_dialog_response_cb
),
1513 /* Don't destroy the widget if closed by the window manager close button. */
1514 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1515 gtk_widget_show (w
);
1517 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1519 (void) xg_maybe_add_timer (&dd
);
1520 g_main_loop_run (dd
.loop
);
1523 unbind_to (count
, Qnil
);
1529 /***********************************************************************
1530 File dialog functions
1531 ***********************************************************************/
1532 /* Return non-zero if the old file selection dialog is being used.
1533 Return zero if not. */
1536 xg_uses_old_file_dialog (void)
1538 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1539 extern int x_gtk_use_old_file_dialog
;
1540 return x_gtk_use_old_file_dialog
;
1547 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1549 /* Return the selected file for file chooser dialog W.
1550 The returned string must be free:d. */
1553 xg_get_file_name_from_chooser (GtkWidget
*w
)
1555 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1558 /* Callback called when the "Show hidden files" toggle is pressed.
1559 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1562 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1564 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1566 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1567 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1571 /* Callback called when a property changes in a file chooser.
1572 GOBJECT is the file chooser dialog, ARG1 describes the property.
1573 USER_DATA is the toggle widget in the file chooser dialog.
1574 We use this to update the "Show hidden files" toggle when the user
1575 changes that property by right clicking in the file list. */
1578 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1580 extern int x_gtk_show_hidden_files
;
1582 if (strcmp (arg1
->name
, "show-hidden") == 0)
1584 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1585 gboolean visible
, toggle_on
;
1587 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1588 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1590 if (!!visible
!= !!toggle_on
)
1592 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1593 G_CALLBACK (xg_toggle_visibility_cb
),
1595 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1596 g_signal_handlers_unblock_by_func
1597 (G_OBJECT (wtoggle
),
1598 G_CALLBACK (xg_toggle_visibility_cb
),
1601 x_gtk_show_hidden_files
= visible
;
1605 /* Read a file name from the user using a file chooser dialog.
1606 F is the current frame.
1607 PROMPT is a prompt to show to the user. May not be NULL.
1608 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1609 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1610 file. *FUNC is set to a function that can be used to retrieve the
1611 selected file name from the returned widget.
1613 Returns the created widget. */
1616 xg_get_file_with_chooser (FRAME_PTR f
,
1618 char *default_filename
,
1619 int mustmatch_p
, int only_dir_p
,
1620 xg_get_file_func
*func
)
1624 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1625 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1626 GtkFileChooserAction action
= (mustmatch_p
?
1627 GTK_FILE_CHOOSER_ACTION_OPEN
:
1628 GTK_FILE_CHOOSER_ACTION_SAVE
);
1629 extern int x_gtk_show_hidden_files
;
1630 extern int x_gtk_file_dialog_help_text
;
1634 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1636 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1637 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1638 (mustmatch_p
|| only_dir_p
?
1639 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1642 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1644 wbox
= gtk_vbox_new (FALSE
, 0);
1645 gtk_widget_show (wbox
);
1646 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1648 if (x_gtk_show_hidden_files
)
1650 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1651 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1653 gtk_widget_show (wtoggle
);
1654 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1655 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1656 g_signal_connect (G_OBJECT (filewin
), "notify",
1657 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1659 if (x_gtk_file_dialog_help_text
)
1662 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1663 Show the C-l help text only for versions < 2.10. */
1664 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1665 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1666 strcat (message
, "\nIf you don't like this file selector, use the "
1667 "corresponding\nkey binding or customize "
1668 "use-file-dialog to turn it off.");
1670 wmessage
= gtk_label_new (message
);
1671 gtk_widget_show (wmessage
);
1674 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1675 if (x_gtk_file_dialog_help_text
)
1676 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1677 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1679 if (default_filename
)
1682 struct gcpro gcpro1
;
1683 char *utf8_filename
;
1686 file
= build_string (default_filename
);
1688 /* File chooser does not understand ~/... in the file name. It must be
1689 an absolute name starting with /. */
1690 if (default_filename
[0] != '/')
1691 file
= Fexpand_file_name (file
, Qnil
);
1693 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1694 if (! NILP (Ffile_directory_p (file
)))
1695 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1699 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1701 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1703 char *cp
= strrchr (utf8_filename
, '/');
1705 else cp
= utf8_filename
;
1706 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1713 *func
= xg_get_file_name_from_chooser
;
1717 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1719 /* Return the selected file for file selector dialog W.
1720 The returned string must be free:d. */
1723 xg_get_file_name_from_selector (GtkWidget
*w
)
1725 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1726 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1729 /* Create a file selection dialog.
1730 F is the current frame.
1731 PROMPT is a prompt to show to the user. May not be NULL.
1732 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1733 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1734 file. *FUNC is set to a function that can be used to retrieve the
1735 selected file name from the returned widget.
1737 Returns the created widget. */
1740 xg_get_file_with_selection (FRAME_PTR f
,
1742 char *default_filename
,
1743 int mustmatch_p
, int only_dir_p
,
1744 xg_get_file_func
*func
)
1747 GtkFileSelection
*filesel
;
1749 filewin
= gtk_file_selection_new (prompt
);
1750 filesel
= GTK_FILE_SELECTION (filewin
);
1752 if (default_filename
)
1753 gtk_file_selection_set_filename (filesel
, default_filename
);
1757 /* The selection_entry part of filesel is not documented. */
1758 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1759 gtk_file_selection_hide_fileop_buttons (filesel
);
1762 *func
= xg_get_file_name_from_selector
;
1766 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1768 /* Read a file name from the user using a file dialog, either the old
1769 file selection dialog, or the new file chooser dialog. Which to use
1770 depends on what the GTK version used has, and what the value of
1771 gtk-use-old-file-dialog.
1772 F is the current frame.
1773 PROMPT is a prompt to show to the user. May not be NULL.
1774 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1775 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1778 Returns a file name or NULL if no file was selected.
1779 The returned string must be freed by the caller. */
1782 xg_get_file_name (FRAME_PTR f
,
1784 char *default_filename
,
1790 int filesel_done
= 0;
1791 xg_get_file_func func
;
1793 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1794 /* I really don't know why this is needed, but without this the GLIBC add on
1795 library linuxthreads hangs when the Gnome file chooser backend creates
1797 sigblock (sigmask (__SIGRTMIN
));
1798 #endif /* HAVE_GTK_AND_PTHREAD */
1800 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1802 if (xg_uses_old_file_dialog ())
1803 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1804 mustmatch_p
, only_dir_p
, &func
);
1806 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1807 mustmatch_p
, only_dir_p
, &func
);
1809 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1810 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1811 mustmatch_p
, only_dir_p
, &func
);
1812 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1814 gtk_widget_set_name (w
, "emacs-filedialog");
1816 filesel_done
= xg_dialog_run (f
, w
);
1818 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1819 sigunblock (sigmask (__SIGRTMIN
));
1822 if (filesel_done
== GTK_RESPONSE_OK
)
1825 gtk_widget_destroy (w
);
1829 #ifdef HAVE_FREETYPE
1830 /* Pop up a GTK font selector and return the name of the font the user
1831 selects, as a C string. The returned font name follows GTK's own
1834 `FAMILY [VALUE1 VALUE2] SIZE'
1836 This can be parsed using font_parse_fcname in font.c.
1837 DEFAULT_NAME, if non-zero, is the default font name. */
1840 xg_get_font_name (FRAME_PTR f
, const char *default_name
)
1843 char *fontname
= NULL
;
1846 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1847 sigblock (sigmask (__SIGRTMIN
));
1848 #endif /* HAVE_GTK_AND_PTHREAD */
1850 w
= gtk_font_selection_dialog_new ("Pick a font");
1852 default_name
= "Monospace 10";
1853 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1856 gtk_widget_set_name (w
, "emacs-fontdialog");
1858 done
= xg_dialog_run (f
, w
);
1860 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1861 sigunblock (sigmask (__SIGRTMIN
));
1864 if (done
== GTK_RESPONSE_OK
)
1865 fontname
= gtk_font_selection_dialog_get_font_name
1866 (GTK_FONT_SELECTION_DIALOG (w
));
1868 gtk_widget_destroy (w
);
1871 #endif /* HAVE_FREETYPE */
1875 /***********************************************************************
1877 ***********************************************************************/
1879 /* The name of menu items that can be used for customization. Since GTK
1880 RC files are very crude and primitive, we have to set this on all
1881 menu item names so a user can easily customize menu items. */
1883 #define MENU_ITEM_NAME "emacs-menuitem"
1886 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1887 during GC. The next member points to the items. */
1888 static xg_list_node xg_menu_cb_list
;
1890 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1891 during GC. The next member points to the items. */
1892 static xg_list_node xg_menu_item_cb_list
;
1894 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1895 F is the frame CL_DATA will be initialized for.
1896 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1898 The menu bar and all sub menus under the menu bar in a frame
1899 share the same structure, hence the reference count.
1901 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1902 allocated xg_menu_cb_data if CL_DATA is NULL. */
1904 static xg_menu_cb_data
*
1905 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
1909 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1911 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1912 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1913 cl_data
->highlight_cb
= highlight_cb
;
1914 cl_data
->ref_count
= 0;
1916 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1919 cl_data
->ref_count
++;
1924 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1925 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1927 When the menu bar is updated, menu items may have been added and/or
1928 removed, so menu_bar_vector and menu_bar_items_used change. We must
1929 then update CL_DATA since it is used to determine which menu
1930 item that is invoked in the menu.
1931 HIGHLIGHT_CB could change, there is no check that the same
1932 function is given when modifying a menu bar as was given when
1933 creating the menu bar. */
1936 update_cl_data (xg_menu_cb_data
*cl_data
,
1938 GCallback highlight_cb
)
1943 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1944 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1945 cl_data
->highlight_cb
= highlight_cb
;
1949 /* Decrease reference count for CL_DATA.
1950 If reference count is zero, free CL_DATA. */
1953 unref_cl_data (xg_menu_cb_data
*cl_data
)
1955 if (cl_data
&& cl_data
->ref_count
> 0)
1957 cl_data
->ref_count
--;
1958 if (cl_data
->ref_count
== 0)
1960 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1966 /* Function that marks all lisp data during GC. */
1973 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1974 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1976 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1978 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1980 if (! NILP (cb_data
->help
))
1981 mark_object (cb_data
->help
);
1986 /* Callback called when a menu item is destroyed. Used to free data.
1987 W is the widget that is being destroyed (not used).
1988 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1991 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
1995 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1996 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2001 /* Callback called when the pointer enters/leaves a menu item.
2002 W is the parent of the menu item.
2003 EVENT is either an enter event or leave event.
2004 CLIENT_DATA is not used.
2006 Returns FALSE to tell GTK to keep processing this event. */
2009 menuitem_highlight_callback (GtkWidget
*w
,
2010 GdkEventCrossing
*event
,
2011 gpointer client_data
)
2014 GtkWidget
*subwidget
;
2015 xg_menu_item_cb_data
*data
;
2017 ev
.crossing
= *event
;
2018 subwidget
= gtk_get_event_widget (&ev
);
2019 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
2023 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2025 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2026 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2027 (*func
) (subwidget
, call_data
);
2034 /* Callback called when a menu is destroyed. Used to free data.
2035 W is the widget that is being destroyed (not used).
2036 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2039 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2041 unref_cl_data ((xg_menu_cb_data
*) client_data
);
2044 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2045 must be non-NULL) and can be inserted into a menu item.
2047 Returns the GtkHBox. */
2050 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2056 wbox
= gtk_hbox_new (FALSE
, 0);
2057 wlbl
= gtk_label_new (utf8_label
);
2058 wkey
= gtk_label_new (utf8_key
);
2060 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2061 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2063 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2064 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2066 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2067 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2068 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2073 /* Make and return a menu item widget with the key to the right.
2074 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2075 UTF8_KEY is the text representing the key binding.
2076 ITEM is the widget_value describing the menu item.
2078 GROUP is an in/out parameter. If the menu item to be created is not
2079 part of any radio menu group, *GROUP contains NULL on entry and exit.
2080 If the menu item to be created is part of a radio menu group, on entry
2081 *GROUP contains the group to use, or NULL if this is the first item
2082 in the group. On exit, *GROUP contains the radio item group.
2084 Unfortunately, keys don't line up as nicely as in Motif,
2085 but the MacOS X version doesn't either, so I guess that is OK. */
2088 make_menu_item (const char *utf8_label
,
2089 const char *utf8_key
,
2094 GtkWidget
*wtoadd
= 0;
2096 /* It has been observed that some menu items have a NULL name field.
2097 This will lead to this function being called with a NULL utf8_label.
2098 GTK crashes on that so we set a blank label. Why there is a NULL
2099 name remains to be investigated. */
2100 if (! utf8_label
) utf8_label
= " ";
2103 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2105 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2108 if (utf8_key
) w
= gtk_check_menu_item_new ();
2109 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2110 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2112 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2114 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2115 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2116 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2118 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2123 if (utf8_key
) w
= gtk_menu_item_new ();
2124 else w
= gtk_menu_item_new_with_label (utf8_label
);
2127 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2128 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2133 static int xg_detached_menus
;
2135 /* Returns non-zero if there are detached menus. */
2138 xg_have_tear_offs (void)
2140 return xg_detached_menus
> 0;
2143 /* Callback invoked when a detached menu window is removed. Here we
2144 decrease the xg_detached_menus count.
2145 WIDGET is the top level window that is removed (the parent of the menu).
2146 CLIENT_DATA is not used. */
2149 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2151 if (xg_detached_menus
> 0) --xg_detached_menus
;
2154 /* Callback invoked when a menu is detached. It increases the
2155 xg_detached_menus count.
2156 WIDGET is the GtkTearoffMenuItem.
2157 CLIENT_DATA is not used. */
2160 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2162 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2163 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2165 ++xg_detached_menus
;
2166 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2168 G_CALLBACK (tearoff_remove
), 0);
2173 /* Create a menu item widget, and connect the callbacks.
2174 ITEM decribes the menu item.
2175 F is the frame the created menu belongs to.
2176 SELECT_CB is the callback to use when a menu item is selected.
2177 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2178 CL_DATA points to the callback data to be used for this menu.
2179 GROUP is an in/out parameter. If the menu item to be created is not
2180 part of any radio menu group, *GROUP contains NULL on entry and exit.
2181 If the menu item to be created is part of a radio menu group, on entry
2182 *GROUP contains the group to use, or NULL if this is the first item
2183 in the group. On exit, *GROUP contains the radio item group.
2185 Returns the created GtkWidget. */
2188 xg_create_one_menuitem (widget_value
*item
,
2190 GCallback select_cb
,
2191 GCallback highlight_cb
,
2192 xg_menu_cb_data
*cl_data
,
2198 xg_menu_item_cb_data
*cb_data
;
2200 utf8_label
= get_utf8_string (item
->name
);
2201 utf8_key
= get_utf8_string (item
->key
);
2203 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2205 if (utf8_label
) g_free (utf8_label
);
2206 if (utf8_key
) g_free (utf8_key
);
2208 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2210 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2212 cb_data
->select_id
= 0;
2213 cb_data
->help
= item
->help
;
2214 cb_data
->cl_data
= cl_data
;
2215 cb_data
->call_data
= item
->call_data
;
2217 g_signal_connect (G_OBJECT (w
),
2219 G_CALLBACK (menuitem_destroy_callback
),
2222 /* Put cb_data in widget, so we can get at it when modifying menubar */
2223 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2225 /* final item, not a submenu */
2226 if (item
->call_data
&& ! item
->contents
)
2230 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2236 /* Create a full menu tree specified by DATA.
2237 F is the frame the created menu belongs to.
2238 SELECT_CB is the callback to use when a menu item is selected.
2239 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2240 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2241 POP_UP_P is non-zero if we shall create a popup menu.
2242 MENU_BAR_P is non-zero if we shall create a menu bar.
2243 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2244 if MENU_BAR_P is non-zero.
2245 TOPMENU is the topmost GtkWidget that others shall be placed under.
2246 It may be NULL, in that case we create the appropriate widget
2247 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2248 CL_DATA is the callback data we shall use for this menu, or NULL
2249 if we haven't set the first callback yet.
2250 NAME is the name to give to the top level menu if this function
2251 creates it. May be NULL to not set any name.
2253 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2256 This function calls itself to create submenus. */
2259 create_menus (widget_value
*data
,
2261 GCallback select_cb
,
2262 GCallback deactivate_cb
,
2263 GCallback highlight_cb
,
2268 xg_menu_cb_data
*cl_data
,
2272 GtkWidget
*wmenu
= topmenu
;
2273 GSList
*group
= NULL
;
2279 wmenu
= gtk_menu_new ();
2280 xg_set_screen (wmenu
, f
);
2281 /* Connect this to the menu instead of items so we get enter/leave for
2282 disabled items also. TODO: Still does not get enter/leave for
2283 disabled items in detached menus. */
2284 g_signal_connect (G_OBJECT (wmenu
),
2285 "enter-notify-event",
2286 G_CALLBACK (menuitem_highlight_callback
),
2288 g_signal_connect (G_OBJECT (wmenu
),
2289 "leave-notify-event",
2290 G_CALLBACK (menuitem_highlight_callback
),
2295 wmenu
= gtk_menu_bar_new ();
2296 /* Set width of menu bar to a small value so it doesn't enlarge
2297 a small initial frame size. The width will be set to the
2298 width of the frame later on when it is added to a container.
2299 height -1: Natural height. */
2300 gtk_widget_set_size_request (wmenu
, 1, -1);
2303 /* Put cl_data on the top menu for easier access. */
2304 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2305 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2306 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2307 G_CALLBACK (menu_destroy_callback
), cl_data
);
2310 gtk_widget_set_name (wmenu
, name
);
2313 g_signal_connect (G_OBJECT (wmenu
),
2314 "selection-done", deactivate_cb
, 0);
2317 if (! menu_bar_p
&& add_tearoff_p
)
2319 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2320 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2322 g_signal_connect (G_OBJECT (tearoff
), "activate",
2323 G_CALLBACK (tearoff_activate
), 0);
2326 for (item
= data
; item
; item
= item
->next
)
2330 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2331 && !menu_separator_name_p (item
->name
))
2334 /* A title for a popup. We do the same as GTK does when
2335 creating titles, but it does not look good. */
2337 utf8_label
= get_utf8_string (item
->name
);
2339 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2340 w
= gtk_menu_item_new_with_label (utf8_label
);
2341 gtk_widget_set_sensitive (w
, FALSE
);
2342 if (utf8_label
) g_free (utf8_label
);
2344 else if (menu_separator_name_p (item
->name
))
2347 /* GTK only have one separator type. */
2348 w
= gtk_separator_menu_item_new ();
2352 w
= xg_create_one_menuitem (item
,
2354 item
->contents
? 0 : select_cb
,
2359 /* Create a possibly empty submenu for menu bar items, since some
2360 themes don't highlight items correctly without it. */
2361 if (item
->contents
|| menu_bar_p
)
2363 GtkWidget
*submenu
= create_menus (item
->contents
,
2374 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2378 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2379 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2385 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2386 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2387 with some text and buttons.
2388 F is the frame the created item belongs to.
2389 NAME is the name to use for the top widget.
2390 VAL is a widget_value structure describing items to be created.
2391 SELECT_CB is the callback to use when a menu item is selected or
2392 a dialog button is pressed.
2393 DEACTIVATE_CB is the callback to use when an item is deactivated.
2394 For a menu, when a sub menu is not shown anymore, for a dialog it is
2395 called when the dialog is popped down.
2396 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2398 Returns the widget created. */
2401 xg_create_widget (const char *type
, const char *name
, FRAME_PTR f
, widget_value
*val
,
2402 GCallback select_cb
, GCallback deactivate_cb
,
2403 GCallback highlight_cb
)
2406 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2407 int pop_up_p
= strcmp (type
, "popup") == 0;
2409 if (strcmp (type
, "dialog") == 0)
2411 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2412 xg_set_screen (w
, f
);
2413 gtk_window_set_transient_for (GTK_WINDOW (w
),
2414 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2415 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2416 gtk_widget_set_name (w
, "emacs-dialog");
2417 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2419 else if (menu_bar_p
|| pop_up_p
)
2421 w
= create_menus (val
->contents
,
2433 /* Set the cursor to an arrow for popup menus when they are mapped.
2434 This is done by default for menu bar menus. */
2437 /* Must realize so the GdkWindow inside the widget is created. */
2438 gtk_widget_realize (w
);
2439 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2444 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2451 /* Return the label for menu item WITEM. */
2454 xg_get_menu_item_label (GtkMenuItem
*witem
)
2456 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2457 return gtk_label_get_label (wlabel
);
2460 /* Return non-zero if the menu item WITEM has the text LABEL. */
2463 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2466 char *utf8_label
= get_utf8_string (label
);
2467 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2469 if (! old_label
&& ! utf8_label
)
2471 else if (old_label
&& utf8_label
)
2472 is_same
= strcmp (utf8_label
, old_label
) == 0;
2474 if (utf8_label
) g_free (utf8_label
);
2479 /* Destroy widgets in LIST. */
2482 xg_destroy_widgets (GList
*list
)
2486 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2488 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2490 /* Destroying the widget will remove it from the container it is in. */
2491 gtk_widget_destroy (w
);
2495 /* Update the top level names in MENUBAR (i.e. not submenus).
2496 F is the frame the menu bar belongs to.
2497 *LIST is a list with the current menu bar names (menu item widgets).
2498 ITER is the item within *LIST that shall be updated.
2499 POS is the numerical position, starting at 0, of ITER in *LIST.
2500 VAL describes what the menu bar shall look like after the update.
2501 SELECT_CB is the callback to use when a menu item is selected.
2502 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2503 CL_DATA points to the callback data to be used for this menu bar.
2505 This function calls itself to walk through the menu bar names. */
2508 xg_update_menubar (GtkWidget
*menubar
,
2514 GCallback select_cb
,
2515 GCallback deactivate_cb
,
2516 GCallback highlight_cb
,
2517 xg_menu_cb_data
*cl_data
)
2519 if (! iter
&& ! val
)
2521 else if (iter
&& ! val
)
2523 /* Item(s) have been removed. Remove all remaining items. */
2524 xg_destroy_widgets (iter
);
2526 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2527 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2528 gtk_menu_item_new_with_label (""),
2534 else if (! iter
&& val
)
2536 /* Item(s) added. Add all new items in one call. */
2537 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2538 0, 1, 0, menubar
, cl_data
, 0);
2544 /* Below this neither iter or val is NULL */
2545 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2547 /* This item is still the same, check next item. */
2549 iter
= g_list_next (iter
);
2552 else /* This item is changed. */
2554 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2555 GtkMenuItem
*witem2
= 0;
2556 int val_in_menubar
= 0;
2557 int iter_in_new_menubar
= 0;
2561 /* See if the changed entry (val) is present later in the menu bar */
2563 iter2
&& ! val_in_menubar
;
2564 iter2
= g_list_next (iter2
))
2566 witem2
= GTK_MENU_ITEM (iter2
->data
);
2567 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2570 /* See if the current entry (iter) is present later in the
2571 specification for the new menu bar. */
2572 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2573 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2575 if (val_in_menubar
&& ! iter_in_new_menubar
)
2579 /* This corresponds to:
2584 g_object_ref (G_OBJECT (witem
));
2585 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2586 gtk_widget_destroy (GTK_WIDGET (witem
));
2588 /* Must get new list since the old changed. */
2589 g_list_free (*list
);
2590 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2591 while (nr
-- > 0) iter
= g_list_next (iter
);
2593 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2595 /* This corresponds to:
2598 Rename B to X. This might seem to be a strange thing to do,
2599 since if there is a menu under B it will be totally wrong for X.
2600 But consider editing a C file. Then there is a C-mode menu
2601 (corresponds to B above).
2602 If then doing C-x C-f the minibuf menu (X above) replaces the
2603 C-mode menu. When returning from the minibuffer, we get
2604 back the C-mode menu. Thus we do:
2605 Rename B to X (C-mode to minibuf menu)
2606 Rename X to B (minibuf to C-mode menu).
2607 If the X menu hasn't been invoked, the menu under B
2608 is up to date when leaving the minibuffer. */
2609 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2610 char *utf8_label
= get_utf8_string (val
->name
);
2611 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2613 gtk_label_set_text (wlabel
, utf8_label
);
2615 /* If this item has a submenu that has been detached, change
2616 the title in the WM decorations also. */
2617 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2618 /* Set the title of the detached window. */
2619 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2621 if (utf8_label
) g_free (utf8_label
);
2622 iter
= g_list_next (iter
);
2626 else if (! val_in_menubar
&& iter_in_new_menubar
)
2628 /* This corresponds to:
2635 GtkWidget
*w
= xg_create_one_menuitem (val
,
2642 /* Create a possibly empty submenu for menu bar items, since some
2643 themes don't highlight items correctly without it. */
2644 GtkWidget
*submenu
= create_menus (NULL
, f
,
2645 select_cb
, deactivate_cb
,
2647 0, 0, 0, 0, cl_data
, 0);
2648 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2649 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2650 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2652 g_list_free (*list
);
2653 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2654 while (nr
-- > 0) iter
= g_list_next (iter
);
2655 iter
= g_list_next (iter
);
2659 else /* if (val_in_menubar && iter_in_new_menubar) */
2662 /* This corresponds to:
2667 g_object_ref (G_OBJECT (witem2
));
2668 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2669 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2670 GTK_WIDGET (witem2
), pos
);
2671 g_object_unref (G_OBJECT (witem2
));
2673 g_list_free (*list
);
2674 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2675 while (nr
-- > 0) iter
= g_list_next (iter
);
2676 if (iter
) iter
= g_list_next (iter
);
2682 /* Update the rest of the menu bar. */
2683 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2684 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2687 /* Update the menu item W so it corresponds to VAL.
2688 SELECT_CB is the callback to use when a menu item is selected.
2689 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2690 CL_DATA is the data to set in the widget for menu invocation. */
2693 xg_update_menu_item (widget_value
*val
,
2695 GCallback select_cb
,
2696 GCallback highlight_cb
,
2697 xg_menu_cb_data
*cl_data
)
2704 const char *old_label
= 0;
2705 const char *old_key
= 0;
2706 xg_menu_item_cb_data
*cb_data
;
2708 wchild
= XG_BIN_CHILD (w
);
2709 utf8_label
= get_utf8_string (val
->name
);
2710 utf8_key
= get_utf8_string (val
->key
);
2712 /* See if W is a menu item with a key. See make_menu_item above. */
2713 if (GTK_IS_HBOX (wchild
))
2715 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2717 wlbl
= GTK_LABEL (list
->data
);
2718 wkey
= GTK_LABEL (list
->next
->data
);
2723 /* Remove the key and keep just the label. */
2724 g_object_ref (G_OBJECT (wlbl
));
2725 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2726 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2727 g_object_unref (G_OBJECT (wlbl
));
2732 else /* Just a label. */
2734 wlbl
= GTK_LABEL (wchild
);
2736 /* Check if there is now a key. */
2739 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2740 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2742 wlbl
= GTK_LABEL (list
->data
);
2743 wkey
= GTK_LABEL (list
->next
->data
);
2746 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2747 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2752 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2753 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2755 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2756 gtk_label_set_text (wkey
, utf8_key
);
2758 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2759 gtk_label_set_text (wlbl
, utf8_label
);
2761 if (utf8_key
) g_free (utf8_key
);
2762 if (utf8_label
) g_free (utf8_label
);
2764 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2765 gtk_widget_set_sensitive (w
, FALSE
);
2766 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2767 gtk_widget_set_sensitive (w
, TRUE
);
2769 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2773 cb_data
->call_data
= val
->call_data
;
2774 cb_data
->help
= val
->help
;
2775 cb_data
->cl_data
= cl_data
;
2777 /* We assume the callback functions don't change. */
2778 if (val
->call_data
&& ! val
->contents
)
2780 /* This item shall have a select callback. */
2781 if (! cb_data
->select_id
)
2783 = g_signal_connect (G_OBJECT (w
), "activate",
2784 select_cb
, cb_data
);
2786 else if (cb_data
->select_id
)
2788 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2789 cb_data
->select_id
= 0;
2794 /* Update the toggle menu item W so it corresponds to VAL. */
2797 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
2799 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2802 /* Update the radio menu item W so it corresponds to VAL. */
2805 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
2807 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2810 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2811 SUBMENU may be NULL, in that case a new menu is created.
2812 F is the frame the menu bar belongs to.
2813 VAL describes the contents of the menu bar.
2814 SELECT_CB is the callback to use when a menu item is selected.
2815 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2816 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2817 CL_DATA is the call back data to use for any newly created items.
2819 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2823 xg_update_submenu (GtkWidget
*submenu
,
2826 GCallback select_cb
,
2827 GCallback deactivate_cb
,
2828 GCallback highlight_cb
,
2829 xg_menu_cb_data
*cl_data
)
2831 GtkWidget
*newsub
= submenu
;
2835 int has_tearoff_p
= 0;
2836 GList
*first_radio
= 0;
2839 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2841 for (cur
= val
, iter
= list
;
2843 iter
= g_list_next (iter
), cur
= cur
->next
)
2845 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2847 /* Skip tearoff items, they have no counterpart in val. */
2848 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2851 iter
= g_list_next (iter
);
2852 if (iter
) w
= GTK_WIDGET (iter
->data
);
2856 /* Remember first radio button in a group. If we get a mismatch in
2857 a radio group we must rebuild the whole group so that the connections
2858 in GTK becomes correct. */
2859 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2861 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2862 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2865 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2867 if (! menu_separator_name_p (cur
->name
))
2870 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2872 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2874 xg_update_toggle_item (cur
, w
);
2875 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2877 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2879 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2881 xg_update_radio_item (cur
, w
);
2882 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2884 else if (GTK_IS_MENU_ITEM (w
))
2886 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2889 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2890 menu_separator_name_p (cur
->name
))
2893 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2895 sub
= gtk_menu_item_get_submenu (witem
);
2896 if (sub
&& ! cur
->contents
)
2898 /* Not a submenu anymore. */
2899 g_object_ref (G_OBJECT (sub
));
2900 remove_submenu (witem
);
2901 gtk_widget_destroy (sub
);
2903 else if (cur
->contents
)
2907 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2908 select_cb
, deactivate_cb
,
2909 highlight_cb
, cl_data
);
2911 /* If this item just became a submenu, we must set it. */
2913 gtk_menu_item_set_submenu (witem
, nsub
);
2918 /* Structural difference. Remove everything from here and down
2924 /* Remove widgets from first structual change. */
2927 /* If we are adding new menu items below, we must remove from
2928 first radio button so that radio groups become correct. */
2929 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2930 else xg_destroy_widgets (iter
);
2935 /* More items added. Create them. */
2936 newsub
= create_menus (cur
,
2949 if (list
) g_list_free (list
);
2954 /* Update the MENUBAR.
2955 F is the frame the menu bar belongs to.
2956 VAL describes the contents of the menu bar.
2957 If DEEP_P is non-zero, rebuild all but the top level menu names in
2958 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2959 SELECT_CB is the callback to use when a menu item is selected.
2960 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2961 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2964 xg_modify_menubar_widgets (GtkWidget
*menubar
, FRAME_PTR f
, widget_value
*val
,
2966 GCallback select_cb
, GCallback deactivate_cb
,
2967 GCallback highlight_cb
)
2969 xg_menu_cb_data
*cl_data
;
2970 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2974 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2977 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2978 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2984 /* Update all sub menus.
2985 We must keep the submenus (GTK menu item widgets) since the
2986 X Window in the XEvent that activates the menu are those widgets. */
2988 /* Update cl_data, menu_item things in F may have changed. */
2989 update_cl_data (cl_data
, f
, highlight_cb
);
2991 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2996 GtkMenuItem
*witem
= 0;
2998 /* Find sub menu that corresponds to val and update it. */
2999 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3001 witem
= GTK_MENU_ITEM (iter
->data
);
3002 if (xg_item_label_same_p (witem
, cur
->name
))
3004 sub
= gtk_menu_item_get_submenu (witem
);
3009 newsub
= xg_update_submenu (sub
,
3016 /* sub may still be NULL. If we just updated non deep and added
3017 a new menu bar item, it has no sub menu yet. So we set the
3018 newly created sub menu under witem. */
3019 if (newsub
!= sub
&& witem
!= 0)
3021 xg_set_screen (newsub
, f
);
3022 gtk_menu_item_set_submenu (witem
, newsub
);
3028 gtk_widget_show_all (menubar
);
3031 /* Callback called when the menu bar W is mapped.
3032 Used to find the height of the menu bar if we didn't get it
3033 after showing the widget. */
3036 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3039 FRAME_PTR f
= (FRAME_PTR
) user_data
;
3040 gtk_widget_size_request (w
, &req
);
3041 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3043 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3044 xg_height_or_width_changed (f
);
3048 /* Recompute all the widgets of frame F, when the menu bar has been
3049 changed. Value is non-zero if widgets were updated. */
3052 xg_update_frame_menubar (FRAME_PTR f
)
3054 struct x_output
*x
= f
->output_data
.x
;
3057 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3060 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3061 return 0; /* Already done this, happens for frames created invisible. */
3065 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3067 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3069 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3070 gtk_widget_show_all (x
->menubar_widget
);
3071 gtk_widget_size_request (x
->menubar_widget
, &req
);
3073 /* If menu bar doesn't know its height yet, cheat a little so the frame
3074 doesn't jump so much when resized later in menubar_map_cb. */
3075 if (req
.height
== 0)
3078 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3080 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3081 xg_height_or_width_changed (f
);
3088 /* Get rid of the menu bar of frame F, and free its storage.
3089 This is used when deleting a frame, and when turning off the menu bar. */
3092 free_frame_menubar (FRAME_PTR f
)
3094 struct x_output
*x
= f
->output_data
.x
;
3096 if (x
->menubar_widget
)
3100 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3101 /* The menubar and its children shall be deleted when removed from
3103 x
->menubar_widget
= 0;
3104 FRAME_MENUBAR_HEIGHT (f
) = 0;
3105 xg_height_or_width_changed (f
);
3111 xg_event_is_for_menubar (FRAME_PTR f
, XEvent
*event
)
3113 struct x_output
*x
= f
->output_data
.x
;
3122 if (! x
->menubar_widget
) return 0;
3124 if (! (event
->xbutton
.x
>= 0
3125 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3126 && event
->xbutton
.y
>= 0
3127 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3128 && event
->xbutton
.same_screen
))
3131 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3132 gw
= gdk_xid_table_lookup_for_display (gdpy
, event
->xbutton
.window
);
3134 gevent
.any
.window
= gw
;
3135 gwdesc
= gtk_get_event_widget (&gevent
);
3136 if (! gwdesc
) return 0;
3137 if (! GTK_IS_MENU_BAR (gwdesc
)
3138 && ! GTK_IS_MENU_ITEM (gwdesc
)
3139 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3142 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3143 if (! list
) return 0;
3144 rec
.x
= event
->xbutton
.x
;
3145 rec
.y
= event
->xbutton
.y
;
3149 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3151 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3152 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3156 return iter
== 0 ? 0 : 1;
3161 /***********************************************************************
3162 Scroll bar functions
3163 ***********************************************************************/
3166 /* Setting scroll bar values invokes the callback. Use this variable
3167 to indicate that callback should do nothing. */
3169 int xg_ignore_gtk_scrollbar
;
3171 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3172 may be larger than 32 bits. Keep a mapping from integer index to widget
3173 pointers to get around the 32 bit limitation. */
3177 GtkWidget
**widgets
;
3182 /* Grow this much every time we need to allocate more */
3184 #define ID_TO_WIDGET_INCR 32
3186 /* Store the widget pointer W in id_to_widget and return the integer index. */
3189 xg_store_widget_in_map (GtkWidget
*w
)
3193 if (id_to_widget
.max_size
== id_to_widget
.used
)
3195 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3197 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
3198 sizeof (GtkWidget
*)*new_size
);
3200 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3201 id_to_widget
.widgets
[i
] = 0;
3202 id_to_widget
.max_size
= new_size
;
3205 /* Just loop over the array and find a free place. After all,
3206 how many scroll bars are we creating? Should be a small number.
3207 The check above guarantees we will find a free place. */
3208 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3210 if (! id_to_widget
.widgets
[i
])
3212 id_to_widget
.widgets
[i
] = w
;
3213 ++id_to_widget
.used
;
3219 /* Should never end up here */
3223 /* Remove pointer at IDX from id_to_widget.
3224 Called when scroll bar is destroyed. */
3227 xg_remove_widget_from_map (int idx
)
3229 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3231 id_to_widget
.widgets
[idx
] = 0;
3232 --id_to_widget
.used
;
3236 /* Get the widget pointer at IDX from id_to_widget. */
3239 xg_get_widget_from_map (int idx
)
3241 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3242 return id_to_widget
.widgets
[idx
];
3247 /* Return the scrollbar id for X Window WID on display DPY.
3248 Return -1 if WID not in id_to_widget. */
3251 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3256 w
= xg_win_to_widget (dpy
, wid
);
3260 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3261 if (id_to_widget
.widgets
[idx
] == w
)
3268 /* Callback invoked when scroll bar WIDGET is destroyed.
3269 DATA is the index into id_to_widget for WIDGET.
3270 We free pointer to last scroll bar values here and remove the index. */
3273 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3275 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
3276 xg_remove_widget_from_map (id
);
3279 /* Create a scroll bar widget for frame F. Store the scroll bar
3281 SCROLL_CALLBACK is the callback to invoke when the value of the
3283 END_CALLBACK is the callback to invoke when scrolling ends.
3284 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3285 to set resources for the widget. */
3288 xg_create_scroll_bar (FRAME_PTR f
,
3289 struct scroll_bar
*bar
,
3290 GCallback scroll_callback
,
3291 GCallback end_callback
,
3292 const char *scroll_bar_name
)
3299 /* Page, step increment values are not so important here, they
3300 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3301 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3304 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3305 webox
= gtk_event_box_new ();
3306 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3307 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3308 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3310 scroll_id
= xg_store_widget_in_map (wscroll
);
3312 /* The EMACS_INT cast avoids a warning. */
3313 g_signal_connect (G_OBJECT (wscroll
),
3315 G_CALLBACK (xg_gtk_scroll_destroy
),
3316 (gpointer
) (EMACS_INT
) scroll_id
);
3317 g_signal_connect (G_OBJECT (wscroll
),
3321 g_signal_connect (G_OBJECT (wscroll
),
3322 "button-release-event",
3326 /* The scroll bar widget does not draw on a window of its own. Instead
3327 it draws on the parent window, in this case the edit widget. So
3328 whenever the edit widget is cleared, the scroll bar needs to redraw
3329 also, which causes flicker. Put an event box between the edit widget
3330 and the scroll bar, so the scroll bar instead draws itself on the
3331 event box window. */
3332 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3333 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3336 /* Set the cursor to an arrow. */
3337 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3339 bar
->x_window
= scroll_id
;
3342 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3345 xg_remove_scroll_bar (FRAME_PTR f
, int scrollbar_id
)
3347 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3350 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3351 gtk_widget_destroy (w
);
3352 gtk_widget_destroy (wparent
);
3353 SET_FRAME_GARBAGED (f
);
3357 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3359 TOP/LEFT are the new pixel positions where the bar shall appear.
3360 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3363 xg_update_scrollbar_pos (FRAME_PTR f
,
3371 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3375 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3376 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3379 /* Clear out old position. */
3380 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3381 if (gtk_widget_get_parent (wparent
) == wfixed
)
3383 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3384 "x", &oldx
, "y", &oldy
, NULL
);
3385 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3388 /* Move and resize to new values. */
3389 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3390 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3393 /* No room. Hide scroll bar as some themes output a warning if
3394 the height is less than the min size. */
3395 gtk_widget_hide (wparent
);
3396 gtk_widget_hide (wscroll
);
3400 gtk_widget_show_all (wparent
);
3401 gtk_widget_set_size_request (wscroll
, width
, height
);
3403 gtk_widget_queue_draw (wfixed
);
3404 gdk_window_process_all_updates ();
3405 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3407 /* Clear under old scroll bar position. This must be done after
3408 the gtk_widget_queue_draw and gdk_window_process_all_updates
3410 x_clear_area (FRAME_X_DISPLAY (f
),
3412 oldx
, oldy
, oldw
, oldh
, 0);
3415 /* GTK does not redraw until the main loop is entered again, but
3416 if there are no X events pending we will not enter it. So we sync
3417 here to get some events. */
3420 SET_FRAME_GARBAGED (f
);
3421 cancel_mouse_face (f
);
3425 /* Set the thumb size and position of scroll bar BAR. We are currently
3426 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3429 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3434 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3436 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3438 if (wscroll
&& NILP (bar
->dragging
))
3447 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3449 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3450 rather than the real portion value. This makes the thumb less likely
3451 to resize and that looks better. */
3452 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3453 /* When the thumb is at the bottom, position == whole.
3454 So we need to increase `whole' to make space for the thumb. */
3461 top
= (gdouble
) position
/ whole
;
3462 shown
= (gdouble
) portion
/ whole
;
3465 size
= shown
* XG_SB_RANGE
;
3466 size
= min (size
, XG_SB_RANGE
);
3467 size
= max (size
, 1);
3469 value
= top
* XG_SB_RANGE
;
3470 value
= min (value
, XG_SB_MAX
- size
);
3471 value
= max (value
, XG_SB_MIN
);
3473 /* Assume all lines are of equal size. */
3474 new_step
= size
/ max (1, FRAME_LINES (f
));
3476 if ((int) gtk_adjustment_get_page_size (adj
) != size
3477 || (int) gtk_adjustment_get_step_increment (adj
) != new_step
)
3479 gtk_adjustment_set_page_size (adj
, size
);
3480 gtk_adjustment_set_step_increment (adj
, new_step
);
3481 /* Assume a page increment is about 95% of the page size */
3482 gtk_adjustment_set_page_increment (adj
,(int) (0.95*size
));
3486 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3490 /* gtk_range_set_value invokes the callback. Set
3491 ignore_gtk_scrollbar to make the callback do nothing */
3492 xg_ignore_gtk_scrollbar
= 1;
3494 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3495 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3497 gtk_adjustment_changed (adj
);
3499 xg_ignore_gtk_scrollbar
= 0;
3506 /* Return non-zero if EVENT is for a scroll bar in frame F.
3507 When the same X window is used for several Gtk+ widgets, we cannot
3508 say for sure based on the X window alone if an event is for the
3509 frame. This function does additional checks.
3511 Return non-zero if the event is for a scroll bar, zero otherwise. */
3514 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3518 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3520 /* Check if press occurred outside the edit widget. */
3521 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3522 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3523 != gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3526 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3527 || event
->type
== MotionNotify
))
3529 /* If we are releasing or moving the scroll bar, it has the grab. */
3530 GtkWidget
*w
= gtk_grab_get_current ();
3531 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3539 /***********************************************************************
3541 ***********************************************************************/
3542 /* The key for the data we put in the GtkImage widgets. The data is
3543 the image used by Emacs. We use this to see if we need to update
3544 the GtkImage with a new image. */
3545 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3547 /* The key for storing the latest modifiers so the activate callback can
3549 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3551 /* The key for storing the button widget in its proxy menu item. */
3552 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3554 /* The key for the data we put in the GtkImage widgets. The data is
3555 the stock name used by Emacs. We use this to see if we need to update
3556 the GtkImage with a new image. */
3557 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3559 /* As above, but this is used for named theme widgets, as opposed to
3561 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3563 /* Callback function invoked when a tool bar item is pressed.
3564 W is the button widget in the tool bar that got pressed,
3565 CLIENT_DATA is an integer that is the index of the button in the
3566 tool bar. 0 is the first button. */
3569 xg_tool_bar_button_cb (GtkWidget
*widget
,
3570 GdkEventButton
*event
,
3573 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3574 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3575 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3580 /* Callback function invoked when a tool bar item is pressed.
3581 W is the button widget in the tool bar that got pressed,
3582 CLIENT_DATA is an integer that is the index of the button in the
3583 tool bar. 0 is the first button. */
3586 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3588 /* The EMACS_INT cast avoids a warning. */
3589 int idx
= (int) (EMACS_INT
) client_data
;
3590 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3591 XG_TOOL_BAR_LAST_MODIFIER
);
3593 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3594 Lisp_Object key
, frame
;
3595 struct input_event event
;
3598 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3601 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3603 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3604 XSETFRAME (frame
, f
);
3606 /* We generate two events here. The first one is to set the prefix
3607 to `(tool_bar)', see keyboard.c. */
3608 event
.kind
= TOOL_BAR_EVENT
;
3609 event
.frame_or_window
= frame
;
3611 kbd_buffer_store_event (&event
);
3613 event
.kind
= TOOL_BAR_EVENT
;
3614 event
.frame_or_window
= frame
;
3616 /* Convert between the modifier bits GDK uses and the modifier bits
3617 Emacs uses. This assumes GDK and X masks are the same, which they are when
3619 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3620 kbd_buffer_store_event (&event
);
3622 /* Return focus to the frame after we have clicked on a detached
3624 Fx_focus_frame (frame
);
3627 /* Callback function invoked when a tool bar item is pressed in a detached
3628 tool bar or the overflow drop down menu.
3629 We just call xg_tool_bar_callback.
3630 W is the menu item widget that got pressed,
3631 CLIENT_DATA is an integer that is the index of the button in the
3632 tool bar. 0 is the first button. */
3635 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3637 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3638 XG_TOOL_BAR_PROXY_BUTTON
));
3639 xg_tool_bar_callback (wbutton
, client_data
);
3644 xg_tool_bar_help_callback (GtkWidget
*w
,
3645 GdkEventCrossing
*event
,
3646 gpointer client_data
);
3648 /* This callback is called when a help is to be shown for an item in
3649 the detached tool bar when the detached tool bar it is not expanded. */
3652 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3653 GdkEventCrossing
*event
,
3654 gpointer client_data
)
3656 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3657 XG_TOOL_BAR_PROXY_BUTTON
));
3659 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3663 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3665 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3666 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3667 GtkWidget
*c2
= clist
->next
? (GtkWidget
*) clist
->next
->data
: NULL
;
3669 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3670 g_list_free (clist
);
3671 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3675 /* This callback is called when a tool item should create a proxy item,
3676 such as for the overflow menu. Also called when the tool bar is detached.
3677 If we don't create a proxy menu item, the detached tool bar will be
3681 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3683 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
3684 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
3686 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3687 GtkImage
*wimage
= GTK_IMAGE (c1
);
3688 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3689 (gtk_label_get_text (wlbl
));
3690 GtkWidget
*wmenuimage
;
3693 if (gtk_button_get_use_stock (wbutton
))
3694 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3695 GTK_ICON_SIZE_MENU
);
3698 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3699 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3701 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
3703 if (store_type
== GTK_IMAGE_STOCK
)
3706 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3707 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3709 else if (store_type
== GTK_IMAGE_ICON_SET
)
3711 GtkIconSet
*icon_set
;
3712 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3713 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3714 GTK_ICON_SIZE_MENU
);
3716 else if (store_type
== GTK_IMAGE_PIXBUF
)
3721 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3724 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3726 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3727 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3728 GDK_INTERP_BILINEAR
);
3730 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3734 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3738 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3740 const gchar
*icon_name
;
3741 GtkIconSize icon_size
;
3743 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3744 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3745 GTK_ICON_SIZE_MENU
);
3749 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3754 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3756 g_signal_connect (G_OBJECT (wmenuitem
),
3758 G_CALLBACK (xg_tool_bar_proxy_callback
),
3762 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3763 (gpointer
) wbutton
);
3764 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3765 gtk_widget_set_sensitive (wmenuitem
,
3766 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
3768 /* Use enter/leave notify to show help. We use the events
3769 rather than the GtkButton specific signals "enter" and
3770 "leave", so we can have only one callback. The event
3771 will tell us what kind of event it is. */
3772 g_signal_connect (G_OBJECT (wmenuitem
),
3773 "enter-notify-event",
3774 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3776 g_signal_connect (G_OBJECT (wmenuitem
),
3777 "leave-notify-event",
3778 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3784 /* This callback is called when a tool bar is detached. We must set
3785 the height of the tool bar to zero when this happens so frame sizes
3786 are correctly calculated.
3787 WBOX is the handle box widget that enables detach/attach of the tool bar.
3788 W is the tool bar widget.
3789 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3792 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
3794 gpointer client_data
)
3796 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3797 extern int x_gtk_whole_detached_tool_bar
;
3799 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3804 GtkRequisition req
, req2
;
3805 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3806 gtk_widget_size_request (GTK_WIDGET (wbox
), &req
);
3807 gtk_widget_size_request (w
, &req2
);
3808 req
.width
-= req2
.width
;
3809 req
.height
-= req2
.height
;
3810 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
3811 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
3812 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
3813 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
3814 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
3815 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
3816 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
3817 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
3818 xg_height_or_width_changed (f
);
3822 /* This callback is called when a tool bar is reattached. We must set
3823 the height of the tool bar when this happens so frame sizes
3824 are correctly calculated.
3825 WBOX is the handle box widget that enables detach/attach of the tool bar.
3826 W is the tool bar widget.
3827 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3830 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
3832 gpointer client_data
)
3834 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3835 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3839 GtkRequisition req
, req2
;
3840 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3841 gtk_widget_size_request (GTK_WIDGET (wbox
), &req
);
3842 gtk_widget_size_request (w
, &req2
);
3843 req
.width
+= req2
.width
;
3844 req
.height
+= req2
.height
;
3845 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
3846 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
3847 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
3848 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
3849 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
3850 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
3851 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
3852 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
3853 xg_height_or_width_changed (f
);
3857 /* This callback is called when the mouse enters or leaves a tool bar item.
3858 It is used for displaying and hiding the help text.
3859 W is the tool bar item, a button.
3860 EVENT is either an enter event or leave event.
3861 CLIENT_DATA is an integer that is the index of the button in the
3862 tool bar. 0 is the first button.
3864 Returns FALSE to tell GTK to keep processing this event. */
3867 xg_tool_bar_help_callback (GtkWidget
*w
,
3868 GdkEventCrossing
*event
,
3869 gpointer client_data
)
3871 /* The EMACS_INT cast avoids a warning. */
3872 int idx
= (int) (EMACS_INT
) client_data
;
3873 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3874 Lisp_Object help
, frame
;
3876 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3879 if (event
->type
== GDK_ENTER_NOTIFY
)
3881 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3882 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3885 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3890 XSETFRAME (frame
, f
);
3891 kbd_buffer_store_help_event (frame
, help
);
3897 /* This callback is called when a tool bar item shall be redrawn.
3898 It modifies the expose event so that the GtkImage widget redraws the
3899 whole image. This to overcome a bug that makes GtkImage draw the image
3900 in the wrong place when it tries to redraw just a part of the image.
3901 W is the GtkImage to be redrawn.
3902 EVENT is the expose event for W.
3903 CLIENT_DATA is unused.
3905 Returns FALSE to tell GTK to keep processing this event. */
3908 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
3909 GdkEventExpose
*event
,
3910 gpointer client_data
)
3914 gdk_drawable_get_size (event
->window
, &width
, &height
);
3916 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3917 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3919 event
->area
.x
= max (0, event
->area
.x
);
3920 event
->area
.y
= max (0, event
->area
.y
);
3922 event
->area
.width
= max (width
, event
->area
.width
);
3923 event
->area
.height
= max (height
, event
->area
.height
);
3928 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
3929 #define toolbar_set_orientation(w, o) \
3930 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
3932 #define toolbar_set_orientation(w, o) \
3933 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
3936 /* Attach a tool bar to frame F. */
3939 xg_pack_tool_bar (FRAME_PTR f
, Lisp_Object pos
)
3941 struct x_output
*x
= f
->output_data
.x
;
3942 int into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
3944 toolbar_set_orientation (x
->toolbar_widget
,
3946 ? GTK_ORIENTATION_VERTICAL
3947 : GTK_ORIENTATION_HORIZONTAL
);
3948 if (!x
->handlebox_widget
)
3950 x
->handlebox_widget
= gtk_handle_box_new ();
3951 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3952 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3953 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3954 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3955 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3961 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
3963 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), x
->handlebox_widget
,
3966 if (EQ (pos
, Qleft
))
3967 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
3968 x
->handlebox_widget
,
3970 x
->toolbar_in_hbox
= 1;
3974 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3975 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
3977 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3981 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
3982 x
->handlebox_widget
,
3984 x
->toolbar_in_hbox
= 0;
3988 /* Create a tool bar for frame F. */
3991 xg_create_tool_bar (FRAME_PTR f
)
3993 struct x_output
*x
= f
->output_data
.x
;
3995 x
->toolbar_widget
= gtk_toolbar_new ();
3996 x
->toolbar_detached
= 0;
3998 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4000 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4001 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4005 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4007 /* Find the right-to-left image named by RTL in the tool bar images for F.
4008 Returns IMAGE if RTL is not found. */
4011 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
4014 Lisp_Object file
, rtl_name
;
4015 struct gcpro gcpro1
, gcpro2
;
4016 GCPRO2 (file
, rtl_name
);
4018 rtl_name
= Ffile_name_nondirectory (rtl
);
4020 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4022 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4023 if (!NILP (file
= file_for_image (rtl_image
)))
4025 file
= call1 (intern ("file-name-sans-extension"),
4026 Ffile_name_nondirectory (file
));
4027 if (EQ (Fequal (file
, rtl_name
), Qt
))
4038 static GtkToolItem
*
4039 xg_make_tool_item (FRAME_PTR f
,
4041 GtkWidget
**wbutton
,
4043 int i
, int horiz
, int text_image
)
4045 GtkToolItem
*ti
= gtk_tool_item_new ();
4046 GtkWidget
*vb
= horiz
? gtk_hbox_new (FALSE
, 0) : gtk_vbox_new (FALSE
, 0);
4047 GtkWidget
*wb
= gtk_button_new ();
4048 GtkWidget
*weventbox
= gtk_event_box_new ();
4050 if (wimage
&& !text_image
)
4051 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4053 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4054 if (wimage
&& text_image
)
4055 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4057 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4058 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4059 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4060 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4061 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4065 /* The EMACS_INT cast avoids a warning. */
4066 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4067 G_CALLBACK (xg_tool_bar_menu_proxy
),
4068 (gpointer
) (EMACS_INT
) i
);
4070 g_signal_connect (G_OBJECT (wb
), "clicked",
4071 G_CALLBACK (xg_tool_bar_callback
),
4072 (gpointer
) (EMACS_INT
) i
);
4074 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4076 /* Catch expose events to overcome an annoying redraw bug, see
4077 comment for xg_tool_bar_item_expose_callback. */
4078 g_signal_connect (G_OBJECT (ti
),
4080 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4083 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4085 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
4086 no distinction based on modifiers in the activate callback,
4087 so we have to do it ourselves. */
4088 g_signal_connect (wb
, "button-release-event",
4089 G_CALLBACK (xg_tool_bar_button_cb
),
4092 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4094 /* Use enter/leave notify to show help. We use the events
4095 rather than the GtkButton specific signals "enter" and
4096 "leave", so we can have only one callback. The event
4097 will tell us what kind of event it is. */
4098 /* The EMACS_INT cast avoids a warning. */
4099 g_signal_connect (G_OBJECT (weventbox
),
4100 "enter-notify-event",
4101 G_CALLBACK (xg_tool_bar_help_callback
),
4102 (gpointer
) (EMACS_INT
) i
);
4103 g_signal_connect (G_OBJECT (weventbox
),
4104 "leave-notify-event",
4105 G_CALLBACK (xg_tool_bar_help_callback
),
4106 (gpointer
) (EMACS_INT
) i
);
4109 if (wbutton
) *wbutton
= wb
;
4115 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4116 const char *icon_name
, const struct image
*img
,
4117 const char *label
, int horiz
)
4121 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4122 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4124 /* Check if the tool icon matches. */
4127 old
= g_object_get_data (G_OBJECT (wimage
),
4128 XG_TOOL_BAR_STOCK_NAME
);
4129 if (!old
|| strcmp (old
, stock_name
))
4134 old
= g_object_get_data (G_OBJECT (wimage
),
4135 XG_TOOL_BAR_ICON_NAME
);
4136 if (!old
|| strcmp (old
, icon_name
))
4142 = (Pixmap
) g_object_get_data (G_OBJECT (wimage
),
4143 XG_TOOL_BAR_IMAGE_DATA
);
4144 if (old_img
!= img
->pixmap
)
4148 /* Check button configuration and label. */
4149 if ((horiz
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
))
4150 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4153 /* Ensure label is correct. */
4155 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4160 xg_update_tool_bar_sizes (FRAME_PTR f
)
4162 struct x_output
*x
= f
->output_data
.x
;
4164 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4166 gtk_widget_size_request (GTK_WIDGET (x
->handlebox_widget
), &req
);
4167 if (x
->toolbar_in_hbox
)
4170 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4171 x
->handlebox_widget
,
4172 "position", &pos
, NULL
);
4173 if (pos
== 0) nl
= req
.width
;
4174 else nr
= req
.width
;
4179 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4180 x
->handlebox_widget
,
4181 "position", &pos
, NULL
);
4182 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4183 else nb
= req
.height
;
4186 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4187 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4188 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4189 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4191 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4192 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4193 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4194 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4195 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4196 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4204 /* Update the tool bar for frame F. Add new buttons and remove old. */
4207 update_frame_tool_bar (FRAME_PTR f
)
4210 struct x_output
*x
= f
->output_data
.x
;
4211 int hmargin
= 0, vmargin
= 0;
4212 GtkToolbar
*wtoolbar
;
4214 GtkTextDirection dir
;
4215 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
4218 int text_image
, horiz
;
4220 if (! FRAME_GTK_WIDGET (f
))
4225 if (INTEGERP (Vtool_bar_button_margin
)
4226 && XINT (Vtool_bar_button_margin
) > 0)
4228 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4229 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4231 else if (CONSP (Vtool_bar_button_margin
))
4233 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
4234 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
4235 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4237 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
4238 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
4239 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4242 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4243 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4244 i.e. zero. This means that margins less than
4245 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4246 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4247 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4249 if (! x
->toolbar_widget
)
4250 xg_create_tool_bar (f
);
4252 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4253 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4255 style
= Ftool_bar_get_system_style ();
4256 text_image
= EQ (style
, Qtext_image_horiz
);
4257 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4259 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4261 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4262 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4266 struct image
*img
= NULL
;
4268 Lisp_Object stock
= Qnil
;
4269 GtkStockItem stock_item
;
4270 char *stock_name
= NULL
;
4271 char *icon_name
= NULL
;
4273 GtkWidget
*wbutton
= NULL
;
4274 Lisp_Object specified_file
;
4275 int vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4277 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4278 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4279 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4282 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4284 /* If this is a separator, use a gtk separator item. */
4285 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4287 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4290 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4292 ti
= gtk_separator_tool_item_new ();
4293 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4299 /* Otherwise, the tool-bar item is an ordinary button. */
4301 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4303 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4307 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4309 /* Ignore invalid image specifications. */
4310 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4311 if (!valid_image_p (image
))
4314 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4319 specified_file
= file_for_image (image
);
4320 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4321 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4323 if (STRINGP (stock
))
4325 stock_name
= SSDATA (stock
);
4326 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4328 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4329 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4331 icon_name
= stock_name
+ 2;
4335 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4338 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4340 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4341 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4349 if (stock_name
== NULL
&& icon_name
== NULL
)
4351 /* No stock image, or stock item not known. Try regular
4352 image. If image is a vector, choose it according to the
4354 if (dir
== GTK_TEXT_DIR_RTL
4355 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4357 image
= find_rtl_image (f
, image
, rtl
);
4359 if (VECTORP (image
))
4363 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4364 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4367 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4368 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4370 xassert (ASIZE (image
) >= idx
);
4371 image
= AREF (image
, idx
);
4376 img_id
= lookup_image (f
, image
);
4377 img
= IMAGE_FROM_ID (f
, img_id
);
4378 prepare_image_for_display (f
, img
);
4380 if (img
->load_failed_p
|| img
->pixmap
== None
)
4383 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4389 /* If there is an existing widget, check if it's stale; if so,
4390 remove it and make a new tool item from scratch. */
4391 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4394 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4403 /* Save the image so we can see if an update is needed the
4404 next time we call xg_tool_item_match_p. */
4405 if (EQ (style
, Qtext
))
4407 else if (stock_name
)
4409 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4410 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4411 (gpointer
) xstrdup (stock_name
),
4412 (GDestroyNotify
) xfree
);
4416 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4417 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4418 (gpointer
) xstrdup (icon_name
),
4419 (GDestroyNotify
) xfree
);
4423 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4424 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4425 (gpointer
)img
->pixmap
);
4428 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4429 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4430 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4435 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4439 /* Remove buttons not longer needed. */
4442 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4444 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4445 } while (ti
!= NULL
);
4447 if (f
->n_tool_bar_items
!= 0)
4450 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4451 gtk_widget_show_all (GTK_WIDGET (x
->handlebox_widget
));
4452 if (xg_update_tool_bar_sizes (f
))
4453 xg_height_or_width_changed (f
);
4459 /* Deallocate all resources for the tool bar on frame F.
4460 Remove the tool bar. */
4463 free_frame_tool_bar (FRAME_PTR f
)
4465 struct x_output
*x
= f
->output_data
.x
;
4467 if (x
->toolbar_widget
)
4469 int is_packed
= x
->handlebox_widget
!= 0;
4471 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4472 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4475 if (x
->toolbar_in_hbox
)
4476 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4477 x
->handlebox_widget
);
4479 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4480 x
->handlebox_widget
);
4483 gtk_widget_destroy (x
->toolbar_widget
);
4485 x
->toolbar_widget
= 0;
4486 x
->handlebox_widget
= 0;
4487 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4488 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4490 xg_height_or_width_changed (f
);
4497 xg_change_toolbar_position (FRAME_PTR f
, Lisp_Object pos
)
4499 struct x_output
*x
= f
->output_data
.x
;
4501 if (! x
->toolbar_widget
|| ! x
->handlebox_widget
)
4505 g_object_ref (x
->handlebox_widget
);
4506 if (x
->toolbar_in_hbox
)
4507 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4508 x
->handlebox_widget
);
4510 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4511 x
->handlebox_widget
);
4512 xg_pack_tool_bar (f
, pos
);
4513 g_object_unref (x
->handlebox_widget
);
4514 if (xg_update_tool_bar_sizes (f
))
4515 xg_height_or_width_changed (f
);
4523 /***********************************************************************
4525 ***********************************************************************/
4527 xg_initialize (void)
4529 GtkBindingSet
*binding_set
;
4532 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4533 we keep it permanently linked in. */
4538 xg_ignore_gtk_scrollbar
= 0;
4539 xg_detached_menus
= 0;
4540 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4541 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4543 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4544 id_to_widget
.widgets
= 0;
4546 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4547 bindings. It doesn't seem to be any way to remove properties,
4548 so we set it to VoidSymbol which in X means "no key". */
4549 gtk_settings_set_string_property (gtk_settings_get_default (),
4550 "gtk-menu-bar-accel",
4554 /* Make GTK text input widgets use Emacs style keybindings. This is
4556 gtk_settings_set_string_property (gtk_settings_get_default (),
4557 "gtk-key-theme-name",
4561 /* Make dialogs close on C-g. Since file dialog inherits from
4562 dialog, this works for them also. */
4563 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4564 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4567 /* Make menus close on C-g. */
4568 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4569 (GTK_TYPE_MENU_SHELL
));
4570 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4574 #endif /* USE_GTK */