1 /* Functions for creating and updating GTK widgets.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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/>. */
29 #include "blockinput.h"
30 #include "syssignal.h"
33 #include "termhooks.h"
37 #include <gdk/gdkkeysyms.h>
38 #include "xsettings.h"
41 #include <X11/Xft/Xft.h>
44 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
45 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
47 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
48 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
50 /* Avoid "differ in sign" warnings */
51 #define SSDATA(x) ((char *) SDATA (x))
53 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
54 #define gtk_widget_set_has_window(w, b) \
55 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
57 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
58 #define gtk_dialog_get_action_area(w) ((w)->action_area)
59 #define gtk_dialog_get_content_area(w) ((w)->vbox)
61 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
62 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
64 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
65 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
66 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
67 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
68 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
70 #if GTK_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 11
71 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
73 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
77 /***********************************************************************
78 Display handling functions
79 ***********************************************************************/
81 /* Keep track of the default display, or NULL if there is none. Emacs
82 may close all its displays. */
84 static GdkDisplay
*gdpy_def
;
86 /* When the GTK widget W is to be created on a display for F that
87 is not the default display, set the display for W.
88 W can be a GtkMenu or a GtkWindow widget. */
91 xg_set_screen (GtkWidget
*w
, FRAME_PTR f
)
93 if (FRAME_X_DISPLAY (f
) != GDK_DISPLAY ())
95 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
96 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
99 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
101 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
106 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
107 *DPY is set to NULL if the display can't be opened.
109 Returns non-zero if display could be opened, zero if display could not
110 be opened, and less than zero if the GTK version doesn't support
114 xg_display_open (char *display_name
, Display
**dpy
)
118 gdpy
= gdk_display_open (display_name
);
119 if (!gdpy_def
&& gdpy
)
122 gdk_display_manager_set_default_display (gdk_display_manager_get (),
126 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
130 /* Close display DPY. */
133 xg_display_close (Display
*dpy
)
135 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
137 /* If this is the default display, try to change it before closing.
138 If there is no other display to use, gdpy_def is set to NULL, and
139 the next call to xg_display_open resets the default display. */
140 if (gdk_display_get_default () == gdpy
)
142 struct x_display_info
*dpyinfo
;
143 GdkDisplay
*gdpy_new
= NULL
;
145 /* Find another display. */
146 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
147 if (dpyinfo
->display
!= dpy
)
149 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
150 gdk_display_manager_set_default_display (gdk_display_manager_get (),
157 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
158 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
159 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
160 can continue running, but there will be memory leaks. */
161 g_object_run_dispose (G_OBJECT (gdpy
));
163 /* This seems to be fixed in GTK 2.10. */
164 gdk_display_close (gdpy
);
169 /***********************************************************************
171 ***********************************************************************/
172 /* The next two variables and functions are taken from lwlib. */
173 static widget_value
*widget_value_free_list
;
174 static int malloc_cpt
;
176 /* Allocate a widget_value structure, either by taking one from the
177 widget_value_free_list or by malloc:ing a new one.
179 Return a pointer to the allocated structure. */
182 malloc_widget_value (void)
185 if (widget_value_free_list
)
187 wv
= widget_value_free_list
;
188 widget_value_free_list
= wv
->free_list
;
193 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
196 memset (wv
, 0, sizeof (widget_value
));
200 /* This is analogous to free. It frees only what was allocated
201 by malloc_widget_value, and no substructures. */
204 free_widget_value (widget_value
*wv
)
211 /* When the number of already allocated cells is too big,
218 wv
->free_list
= widget_value_free_list
;
219 widget_value_free_list
= wv
;
224 /* Create and return the cursor to be used for popup menus and
225 scroll bars on display DPY. */
228 xg_create_default_cursor (Display
*dpy
)
230 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
231 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
234 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
237 xg_get_pixbuf_from_pix_and_mask (GdkPixmap
*gpix
,
242 GdkPixbuf
*icon_buf
, *tmp_buf
;
244 gdk_drawable_get_size (gpix
, &width
, &height
);
245 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
246 0, 0, 0, 0, width
, height
);
247 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
248 g_object_unref (G_OBJECT (tmp_buf
));
252 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
257 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
258 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
259 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
260 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
263 for (y
= 0; y
< height
; ++y
)
265 guchar
*iconptr
, *maskptr
;
268 iconptr
= pixels
+ y
* rowstride
;
269 maskptr
= mask_pixels
+ y
* mask_rowstride
;
271 for (x
= 0; x
< width
; ++x
)
273 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
274 just R is sufficient. */
276 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
278 iconptr
+= rowstride
/width
;
279 maskptr
+= mask_rowstride
/width
;
283 g_object_unref (G_OBJECT (mask_buf
));
290 file_for_image (Lisp_Object image
)
292 Lisp_Object specified_file
= Qnil
;
295 for (tail
= XCDR (image
);
296 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
297 tail
= XCDR (XCDR (tail
)))
298 if (EQ (XCAR (tail
), QCfile
))
299 specified_file
= XCAR (XCDR (tail
));
301 return specified_file
;
304 /* For the image defined in IMG, make and return a GtkImage. For displays with
305 8 planes or less we must make a GdkPixbuf and apply the mask manually.
306 Otherwise the highlightning and dimming the tool bar code in GTK does
307 will look bad. For display with more than 8 planes we just use the
308 pixmap and mask directly. For monochrome displays, GTK doesn't seem
309 able to use external pixmaps, it looks bad whatever we do.
310 The image is defined on the display where frame F is.
311 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
312 If OLD_WIDGET is NULL, a new widget is constructed and returned.
313 If OLD_WIDGET is not NULL, that widget is modified. */
316 xg_get_image_for_pixmap (FRAME_PTR f
,
319 GtkImage
*old_widget
)
327 /* If we have a file, let GTK do all the image handling.
328 This seems to be the only way to make insensitive and activated icons
329 look good in all cases. */
330 Lisp_Object specified_file
= file_for_image (img
->spec
);
333 /* We already loaded the image once before calling this
334 function, so this only fails if the image file has been removed.
335 In that case, use the pixmap already loaded. */
337 if (STRINGP (specified_file
)
338 && STRINGP (file
= x_find_image_file (specified_file
)))
341 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
343 gtk_image_set_from_file (old_widget
, SSDATA (file
));
345 return GTK_WIDGET (old_widget
);
348 /* No file, do the image handling ourselves. This will look very bad
349 on a monochrome display, and sometimes bad on all displays with
352 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
353 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
354 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
356 /* This is a workaround to make icons look good on pseudo color
357 displays. Apparently GTK expects the images to have an alpha
358 channel. If they don't, insensitive and activated icons will
359 look bad. This workaround does not work on monochrome displays,
360 and is strictly not needed on true color/static color displays (i.e.
361 16 bits and higher). But we do it anyway so we get a pixbuf that is
362 not associated with the img->pixmap. The img->pixmap may be removed
363 by clearing the image cache and then the tool bar redraw fails, since
364 Gtk+ assumes the pixmap is always there. */
365 cmap
= gtk_widget_get_colormap (widget
);
366 icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
369 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
371 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
373 g_object_unref (G_OBJECT (icon_buf
));
375 g_object_unref (G_OBJECT (gpix
));
376 if (gmask
) g_object_unref (G_OBJECT (gmask
));
378 return GTK_WIDGET (old_widget
);
382 /* Set CURSOR on W and all widgets W contain. We must do like this
383 for scroll bars and menu because they create widgets internally,
384 and it is those widgets that are visible. */
387 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
389 GdkWindow
*window
= gtk_widget_get_window(w
);
390 GList
*children
= gdk_window_peek_children (window
);
392 gdk_window_set_cursor (window
, cursor
);
394 /* The scroll bar widget has more than one GDK window (had to look at
395 the source to figure this out), and there is no way to set cursor
396 on widgets in GTK. So we must set the cursor for all GDK windows.
399 for ( ; children
; children
= g_list_next (children
))
400 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
403 /* Insert NODE into linked LIST. */
406 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
408 xg_list_node
*list_start
= list
->next
;
410 if (list_start
) list_start
->prev
= node
;
411 node
->next
= list_start
;
416 /* Remove NODE from linked LIST. */
419 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
421 xg_list_node
*list_start
= list
->next
;
422 if (node
== list_start
)
424 list
->next
= node
->next
;
425 if (list
->next
) list
->next
->prev
= 0;
429 node
->prev
->next
= node
->next
;
430 if (node
->next
) node
->next
->prev
= node
->prev
;
434 /* Allocate and return a utf8 version of STR. If STR is already
435 utf8 or NULL, just return a copy of STR.
436 A new string is allocated and the caller must free the result
440 get_utf8_string (const char *str
)
444 if (!str
) return NULL
;
446 /* If not UTF-8, try current locale. */
447 if (!g_utf8_validate (str
, -1, NULL
))
448 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
450 return g_strdup (str
);
454 /* Probably some control characters in str. Escape them. */
458 unsigned char *p
= (unsigned char *)str
;
460 GError
*error
= NULL
;
462 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
463 &bytes_written
, &error
))
464 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
467 p
+= bytes_written
+1;
468 g_error_free (error
);
474 g_error_free (error
);
479 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
480 p
= (unsigned char *)str
;
482 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
483 &bytes_written
, &error
))
484 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
486 strncpy (up
, (char *)p
, bytes_written
);
487 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
488 up
[bytes_written
+4] = '\0';
489 up
+= bytes_written
+4;
490 p
+= bytes_written
+1;
491 g_error_free (error
);
497 strcat (utf8_str
, cp
);
502 g_error_free (error
);
509 /* Check for special colors used in face spec for region face.
510 The colors are fetched from the Gtk+ theme.
511 Return 1 if color was found, 0 if not. */
514 xg_check_special_colors (struct frame
*f
,
515 const char *color_name
,
519 if (FRAME_GTK_WIDGET (f
))
521 if (strcmp ("gtk_selection_bg_color", color_name
) == 0)
523 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
524 color
->red
= gsty
->bg
[GTK_STATE_SELECTED
].red
;
525 color
->green
= gsty
->bg
[GTK_STATE_SELECTED
].green
;
526 color
->blue
= gsty
->bg
[GTK_STATE_SELECTED
].blue
;
527 color
->pixel
= gsty
->bg
[GTK_STATE_SELECTED
].pixel
;
530 else if (strcmp ("gtk_selection_fg_color", color_name
) == 0)
532 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
533 color
->red
= gsty
->fg
[GTK_STATE_SELECTED
].red
;
534 color
->green
= gsty
->fg
[GTK_STATE_SELECTED
].green
;
535 color
->blue
= gsty
->fg
[GTK_STATE_SELECTED
].blue
;
536 color
->pixel
= gsty
->fg
[GTK_STATE_SELECTED
].pixel
;
546 /***********************************************************************
548 ***********************************************************************/
549 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
550 We use that to pop down the tooltip. This happens if Gtk+ for some
551 reason wants to change or hide the tooltip. */
553 #ifdef USE_GTK_TOOLTIP
556 hierarchy_ch_cb (GtkWidget
*widget
,
557 GtkWidget
*previous_toplevel
,
560 FRAME_PTR f
= (FRAME_PTR
) user_data
;
561 struct x_output
*x
= f
->output_data
.x
;
562 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
564 if (! top
|| ! GTK_IS_WINDOW (top
))
565 gtk_widget_hide (previous_toplevel
);
568 /* Callback called when Gtk+ thinks a tooltip should be displayed.
569 We use it to get the tooltip window and the tooltip widget so
570 we can manipulate the ourselves.
572 Return FALSE ensures that the tooltip is not shown. */
575 qttip_cb (GtkWidget
*widget
,
578 gboolean keyboard_mode
,
582 FRAME_PTR f
= (FRAME_PTR
) user_data
;
583 struct x_output
*x
= f
->output_data
.x
;
584 if (x
->ttip_widget
== NULL
)
586 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
587 x
->ttip_widget
= tooltip
;
588 g_object_ref (G_OBJECT (tooltip
));
589 x
->ttip_lbl
= gtk_label_new ("");
590 g_object_ref (G_OBJECT (x
->ttip_lbl
));
591 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
592 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
593 /* Realize so we can safely get screen later on. */
594 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
595 gtk_widget_realize (x
->ttip_lbl
);
597 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
598 G_CALLBACK (hierarchy_ch_cb
), f
);
603 #endif /* USE_GTK_TOOLTIP */
605 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
606 Return zero if no system tooltip available, non-zero otherwise. */
609 xg_prepare_tooltip (FRAME_PTR f
,
614 #ifndef USE_GTK_TOOLTIP
617 struct x_output
*x
= f
->output_data
.x
;
621 GtkSettings
*settings
;
622 gboolean tt_enabled
= TRUE
;
624 Lisp_Object encoded_string
;
626 if (!x
->ttip_lbl
) return 0;
629 encoded_string
= ENCODE_UTF_8 (string
);
630 widget
= GTK_WIDGET (x
->ttip_lbl
);
631 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
632 screen
= gdk_drawable_get_screen (gwin
);
633 settings
= gtk_settings_get_for_screen (screen
);
634 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
637 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
638 /* Record that we disabled it so it can be enabled again. */
639 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
643 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
644 g_object_set_data (G_OBJECT
645 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
646 "gdk-display-current-tooltip", NULL
);
648 /* Put out dummy widget in so we can get callbacks for unrealize and
649 hierarchy-changed. */
650 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
652 gtk_tooltip_set_text (x
->ttip_widget
, SDATA (encoded_string
));
653 gtk_widget_size_request (GTK_WIDGET (x
->ttip_window
), &req
);
654 if (width
) *width
= req
.width
;
655 if (height
) *height
= req
.height
;
660 #endif /* USE_GTK_TOOLTIP */
663 /* Show the tooltip at ROOT_X and ROOT_Y.
664 xg_prepare_tooltip must have been called before this function. */
667 xg_show_tooltip (FRAME_PTR f
, int root_x
, int root_y
)
669 #ifdef USE_GTK_TOOLTIP
670 struct x_output
*x
= f
->output_data
.x
;
674 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
675 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
681 /* Hide tooltip if shown. Do nothing if not shown.
682 Return non-zero if tip was hidden, non-ero if not (i.e. not using
686 xg_hide_tooltip (FRAME_PTR f
)
689 #ifdef USE_GTK_TOOLTIP
690 if (f
->output_data
.x
->ttip_window
)
692 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
694 gtk_widget_hide (GTK_WIDGET (win
));
696 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
698 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
699 GdkScreen
*screen
= gdk_drawable_get_screen (gwin
);
700 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
701 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
712 /***********************************************************************
713 General functions for creating widgets, resizing, events, e.t.c.
714 ***********************************************************************/
716 /* Make a geometry string and pass that to GTK. It seems this is the
717 only way to get geometry position right if the user explicitly
718 asked for a position when starting Emacs.
719 F is the frame we shall set geometry for. */
722 xg_set_geometry (FRAME_PTR f
)
724 if (f
->size_hint_flags
& (USPosition
| PPosition
))
726 int left
= f
->left_pos
;
727 int xneg
= f
->size_hint_flags
& XNegative
;
728 int top
= f
->top_pos
;
729 int yneg
= f
->size_hint_flags
& YNegative
;
737 sprintf (geom_str
, "=%dx%d%c%d%c%d",
738 FRAME_PIXEL_WIDTH (f
),
739 FRAME_PIXEL_HEIGHT (f
),
740 (xneg
? '-' : '+'), left
,
741 (yneg
? '-' : '+'), top
);
743 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
745 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
749 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
750 and use a GtkFixed widget, this doesn't happen automatically. */
753 xg_clear_under_internal_border (FRAME_PTR f
)
755 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
757 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
758 gtk_widget_queue_draw (wfixed
);
759 gdk_window_process_all_updates ();
760 x_clear_area (FRAME_X_DISPLAY (f
),
763 FRAME_PIXEL_WIDTH (f
),
764 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
765 x_clear_area (FRAME_X_DISPLAY (f
),
768 FRAME_INTERNAL_BORDER_WIDTH (f
),
769 FRAME_PIXEL_HEIGHT (f
), 0);
770 x_clear_area (FRAME_X_DISPLAY (f
),
772 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
773 FRAME_PIXEL_WIDTH (f
),
774 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
775 x_clear_area (FRAME_X_DISPLAY (f
),
777 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
779 FRAME_INTERNAL_BORDER_WIDTH (f
),
780 FRAME_PIXEL_HEIGHT (f
), 0);
784 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
785 and a Gtk+ menu bar, we get resize events for the edit part of the
786 frame only. We let Gtk+ deal with the Gtk+ parts.
787 F is the frame to resize.
788 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
791 xg_frame_resized (FRAME_PTR f
, int pixelwidth
, int pixelheight
)
795 if (pixelwidth
== -1 && pixelheight
== -1)
797 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
798 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
800 &pixelwidth
, &pixelheight
, 0);
805 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
806 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
808 if (columns
!= FRAME_COLS (f
)
809 || rows
!= FRAME_LINES (f
)
810 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
811 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
813 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
814 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
816 xg_clear_under_internal_border (f
);
817 change_frame_size (f
, rows
, columns
, 0, 1, 0);
818 SET_FRAME_GARBAGED (f
);
819 cancel_mouse_face (f
);
823 /* Resize the outer window of frame F after chainging the height.
824 COLUMNS/ROWS is the size the edit area shall have after the resize. */
827 xg_frame_set_char_size (FRAME_PTR f
, int cols
, int rows
)
829 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
830 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
833 if (FRAME_PIXEL_HEIGHT (f
) == 0)
836 /* Take into account the size of the scroll bar. Always use the
837 number of columns occupied by the scroll bar here otherwise we
838 might end up with a frame width that is not a multiple of the
839 frame's character width which is bad for vertically split
841 f
->scroll_bar_actual_width
842 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
844 compute_fringe_widths (f
, 0);
846 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
847 after calculating that value. */
848 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
849 + FRAME_TOOLBAR_WIDTH (f
);
852 /* Do this before resize, as we don't know yet if we will be resized. */
853 xg_clear_under_internal_border (f
);
855 /* Must resize our top level widget. Font size may have changed,
856 but not rows/cols. */
857 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
858 pixelwidth
, pixelheight
);
859 x_wm_set_size_hint (f
, 0, 0);
861 SET_FRAME_GARBAGED (f
);
862 cancel_mouse_face (f
);
864 /* We can not call change_frame_size for a mapped frame,
865 we can not set pixel width/height either. The window manager may
866 override our resize request, XMonad does this all the time.
867 The best we can do is try to sync, so lisp code sees the updated
868 size as fast as possible.
869 For unmapped windows, we can set rows/cols. When
870 the frame is mapped again we will (hopefully) get the correct size. */
871 if (f
->async_visible
)
873 /* Must call this to flush out events */
874 (void)gtk_events_pending ();
876 x_wait_for_event (f
, ConfigureNotify
);
880 change_frame_size (f
, rows
, cols
, 0, 1, 0);
881 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
882 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
886 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
887 The policy is to keep the number of editable lines. */
890 xg_height_or_width_changed (FRAME_PTR f
)
892 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
893 FRAME_TOTAL_PIXEL_WIDTH (f
),
894 FRAME_TOTAL_PIXEL_HEIGHT (f
));
895 f
->output_data
.x
->hint_flags
= 0;
896 x_wm_set_size_hint (f
, 0, 0);
899 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
900 Must be done like this, because GtkWidget:s can have "hidden"
901 X Window that aren't accessible.
903 Return 0 if no widget match WDESC. */
906 xg_win_to_widget (Display
*dpy
, Window wdesc
)
909 GtkWidget
*gwdesc
= 0;
913 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
918 event
.any
.window
= gdkwin
;
919 gwdesc
= gtk_get_event_widget (&event
);
926 /* Fill in the GdkColor C so that it represents PIXEL.
927 W is the widget that color will be used for. Used to find colormap. */
930 xg_pix_to_gcolor (GtkWidget
*w
, long unsigned int pixel
, GdkColor
*c
)
932 GdkColormap
*map
= gtk_widget_get_colormap (w
);
933 gdk_colormap_query_color (map
, pixel
, c
);
936 /* Callback called when the gtk theme changes.
937 We notify lisp code so it can fix faces used for region for example. */
940 style_changed_cb (GObject
*go
,
944 struct input_event event
;
945 GdkDisplay
*gdpy
= (GdkDisplay
*) user_data
;
946 const char *display_name
= gdk_display_get_name (gdpy
);
949 event
.kind
= CONFIG_CHANGED_EVENT
;
950 event
.frame_or_window
= make_string (display_name
, strlen (display_name
));
951 /* Theme doesn't change often, so intern is called seldom. */
952 event
.arg
= intern ("theme-name");
953 kbd_buffer_store_event (&event
);
956 /* Create and set up the GTK widgets for frame F.
957 Return 0 if creation failed, non-zero otherwise. */
960 xg_create_frame_widgets (FRAME_PTR f
)
963 GtkWidget
*wvbox
, *whbox
;
971 if (FRAME_X_EMBEDDED_P (f
))
972 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
974 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
976 xg_set_screen (wtop
, f
);
978 wvbox
= gtk_vbox_new (FALSE
, 0);
979 whbox
= gtk_hbox_new (FALSE
, 0);
980 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
982 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
984 if (wtop
) gtk_widget_destroy (wtop
);
985 if (wvbox
) gtk_widget_destroy (wvbox
);
986 if (whbox
) gtk_widget_destroy (whbox
);
987 if (wfixed
) gtk_widget_destroy (wfixed
);
993 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
994 gtk_widget_set_name (wtop
, EMACS_CLASS
);
995 gtk_widget_set_name (wvbox
, "pane");
996 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
998 /* If this frame has a title or name, set it in the title bar. */
999 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1000 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1002 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1004 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1005 FRAME_GTK_WIDGET (f
) = wfixed
;
1006 f
->output_data
.x
->vbox_widget
= wvbox
;
1007 f
->output_data
.x
->hbox_widget
= whbox
;
1009 gtk_widget_set_has_window (wfixed
, TRUE
);
1011 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1012 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1013 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1015 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1016 update_frame_tool_bar (f
);
1018 /* We don't want this widget double buffered, because we draw on it
1019 with regular X drawing primitives, so from a GTK/GDK point of
1020 view, the widget is totally blank. When an expose comes, this
1021 will make the widget blank, and then Emacs redraws it. This flickers
1022 a lot, so we turn off double buffering. */
1023 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1025 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1026 SSDATA (Vx_resource_name
),
1027 SSDATA (Vx_resource_class
));
1029 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1030 GTK is to destroy the widget. We want Emacs to do that instead. */
1031 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1032 G_CALLBACK (gtk_true
), 0);
1034 /* Convert our geometry parameters into a geometry string
1036 GTK will itself handle calculating the real position this way. */
1037 xg_set_geometry (f
);
1039 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1041 gtk_widget_add_events (wfixed
,
1042 GDK_POINTER_MOTION_MASK
1044 | GDK_BUTTON_PRESS_MASK
1045 | GDK_BUTTON_RELEASE_MASK
1046 | GDK_KEY_PRESS_MASK
1047 | GDK_ENTER_NOTIFY_MASK
1048 | GDK_LEAVE_NOTIFY_MASK
1049 | GDK_FOCUS_CHANGE_MASK
1050 | GDK_STRUCTURE_MASK
1051 | GDK_VISIBILITY_NOTIFY_MASK
);
1053 /* Must realize the windows so the X window gets created. It is used
1054 by callers of this function. */
1055 gtk_widget_realize (wfixed
);
1056 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1058 /* Since GTK clears its window by filling with the background color,
1059 we must keep X and GTK background in sync. */
1060 xg_pix_to_gcolor (wfixed
, FRAME_BACKGROUND_PIXEL (f
), &bg
);
1061 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
1063 /* Also, do not let any background pixmap to be set, this looks very
1064 bad as Emacs overwrites the background pixmap with its own idea
1065 of background color. */
1066 style
= gtk_widget_get_modifier_style (wfixed
);
1068 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1069 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1070 gtk_widget_modify_style (wfixed
, style
);
1072 #ifdef USE_GTK_TOOLTIP
1073 /* Steal a tool tip window we can move ourselves. */
1074 f
->output_data
.x
->ttip_widget
= 0;
1075 f
->output_data
.x
->ttip_lbl
= 0;
1076 f
->output_data
.x
->ttip_window
= 0;
1077 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1078 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1082 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1083 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1084 /* Only connect this signal once per screen. */
1085 if (! g_signal_handler_find (G_OBJECT (gs
),
1086 G_SIGNAL_MATCH_FUNC
,
1088 G_CALLBACK (style_changed_cb
),
1091 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1092 G_CALLBACK (style_changed_cb
),
1093 gdk_screen_get_display (screen
));
1103 xg_free_frame_widgets (FRAME_PTR f
)
1105 if (FRAME_GTK_OUTER_WIDGET (f
))
1107 struct x_output
*x
= f
->output_data
.x
;
1108 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1109 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1110 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1111 #ifdef USE_GTK_TOOLTIP
1113 gtk_widget_destroy (x
->ttip_lbl
);
1115 g_object_unref (G_OBJECT (x
->ttip_widget
));
1120 /* Set the normal size hints for the window manager, for frame F.
1121 FLAGS is the flags word to use--or 0 meaning preserve the flags
1122 that the window now has.
1123 If USER_POSITION is nonzero, we set the User Position
1124 flag (this is useful when FLAGS is 0). */
1127 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
1129 /* Must use GTK routines here, otherwise GTK resets the size hints
1130 to its own defaults. */
1131 GdkGeometry size_hints
;
1132 gint hint_flags
= 0;
1133 int base_width
, base_height
;
1134 int min_rows
= 0, min_cols
= 0;
1135 int win_gravity
= f
->win_gravity
;
1137 /* Don't set size hints during initialization; that apparently leads
1138 to a race condition. See the thread at
1139 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1140 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1145 memset (&size_hints
, 0, sizeof (size_hints
));
1146 f
->output_data
.x
->size_hints
= size_hints
;
1147 f
->output_data
.x
->hint_flags
= hint_flags
;
1150 flags
= f
->size_hint_flags
;
1152 size_hints
= f
->output_data
.x
->size_hints
;
1153 hint_flags
= f
->output_data
.x
->hint_flags
;
1155 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1156 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1157 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1159 hint_flags
|= GDK_HINT_BASE_SIZE
;
1160 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0) + FRAME_TOOLBAR_WIDTH (f
);
1161 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
1162 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1164 check_frame_size (f
, &min_rows
, &min_cols
);
1166 size_hints
.base_width
= base_width
;
1167 size_hints
.base_height
= base_height
;
1168 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1169 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1171 /* These currently have a one to one mapping with the X values, but I
1172 don't think we should rely on that. */
1173 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1174 size_hints
.win_gravity
= 0;
1175 if (win_gravity
== NorthWestGravity
)
1176 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1177 else if (win_gravity
== NorthGravity
)
1178 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1179 else if (win_gravity
== NorthEastGravity
)
1180 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1181 else if (win_gravity
== WestGravity
)
1182 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1183 else if (win_gravity
== CenterGravity
)
1184 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1185 else if (win_gravity
== EastGravity
)
1186 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1187 else if (win_gravity
== SouthWestGravity
)
1188 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1189 else if (win_gravity
== SouthGravity
)
1190 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1191 else if (win_gravity
== SouthEastGravity
)
1192 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1193 else if (win_gravity
== StaticGravity
)
1194 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1198 hint_flags
&= ~GDK_HINT_POS
;
1199 hint_flags
|= GDK_HINT_USER_POS
;
1202 if (hint_flags
!= f
->output_data
.x
->hint_flags
1203 || memcmp (&size_hints
,
1204 &f
->output_data
.x
->size_hints
,
1205 sizeof (size_hints
)) != 0)
1208 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1209 NULL
, &size_hints
, hint_flags
);
1210 f
->output_data
.x
->size_hints
= size_hints
;
1211 f
->output_data
.x
->hint_flags
= hint_flags
;
1216 /* Change background color of a frame.
1217 Since GTK uses the background color to clear the window, we must
1218 keep the GTK and X colors in sync.
1219 F is the frame to change,
1220 BG is the pixel value to change to. */
1223 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
1225 if (FRAME_GTK_WIDGET (f
))
1230 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
1231 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
1237 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1238 functions so GTK does not overwrite the icon. */
1241 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1243 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1244 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
1245 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
1246 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
1248 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1253 /***********************************************************************
1255 ***********************************************************************/
1256 /* Return the dialog title to use for a dialog of type KEY.
1257 This is the encoding used by lwlib. We use the same for GTK. */
1260 get_dialog_title (char key
)
1262 const char *title
= "";
1270 title
= "Information";
1289 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1290 the dialog, but return TRUE so the event does not propagate further
1291 in GTK. This prevents GTK from destroying the dialog widget automatically
1292 and we can always destrou the widget manually, regardles of how
1293 it was popped down (button press or WM_DELETE_WINDOW).
1294 W is the dialog widget.
1295 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1296 user_data is NULL (not used).
1298 Returns TRUE to end propagation of event. */
1301 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1303 gtk_widget_unmap (w
);
1307 /* Create a popup dialog window. See also xg_create_widget below.
1308 WV is a widget_value describing the dialog.
1309 SELECT_CB is the callback to use when a button has been pressed.
1310 DEACTIVATE_CB is the callback to use when the dialog pops down.
1312 Returns the GTK dialog widget. */
1315 create_dialog (widget_value
*wv
,
1316 GCallback select_cb
,
1317 GCallback deactivate_cb
)
1319 const char *title
= get_dialog_title (wv
->name
[0]);
1320 int total_buttons
= wv
->name
[1] - '0';
1321 int right_buttons
= wv
->name
[4] - '0';
1324 int button_spacing
= 10;
1325 GtkWidget
*wdialog
= gtk_dialog_new ();
1326 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1327 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1330 GtkWidget
*whbox_up
;
1331 GtkWidget
*whbox_down
;
1333 /* If the number of buttons is greater than 4, make two rows of buttons
1334 instead. This looks better. */
1335 int make_two_rows
= total_buttons
> 4;
1337 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1338 left_buttons
= total_buttons
- right_buttons
;
1340 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1341 gtk_widget_set_name (wdialog
, "emacs-dialog");
1346 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1347 whbox_up
= gtk_hbox_new (FALSE
, 0);
1348 whbox_down
= gtk_hbox_new (FALSE
, 0);
1350 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1351 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1352 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1354 cur_box
= GTK_BOX (whbox_up
);
1357 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1358 G_CALLBACK (dialog_delete_callback
), 0);
1362 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1363 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1366 for (item
= wv
->contents
; item
; item
= item
->next
)
1368 char *utf8_label
= get_utf8_string (item
->value
);
1372 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1374 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1375 /* This is the text part of the dialog. */
1376 w
= gtk_label_new (utf8_label
);
1377 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1378 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1379 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1381 /* Try to make dialog look better. Must realize first so
1382 the widget can calculate the size it needs. */
1383 gtk_widget_realize (w
);
1384 gtk_widget_size_request (w
, &req
);
1385 gtk_box_set_spacing (wvbox
, req
.height
);
1386 if (item
->value
&& strlen (item
->value
) > 0)
1387 button_spacing
= 2*req
.width
/strlen (item
->value
);
1391 /* This is one button to add to the dialog. */
1392 w
= gtk_button_new_with_label (utf8_label
);
1393 if (! item
->enabled
)
1394 gtk_widget_set_sensitive (w
, FALSE
);
1396 g_signal_connect (G_OBJECT (w
), "clicked",
1397 select_cb
, item
->call_data
);
1399 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1400 if (++button_nr
== left_buttons
)
1403 cur_box
= GTK_BOX (whbox_down
);
1405 gtk_box_pack_start (cur_box
,
1413 g_free (utf8_label
);
1419 struct xg_dialog_data
1427 /* Function that is called when the file or font dialogs pop down.
1428 W is the dialog widget, RESPONSE is the response code.
1429 USER_DATA is what we passed in to g_signal_connect. */
1432 xg_dialog_response_cb (GtkDialog
*w
,
1436 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1437 dd
->response
= response
;
1438 g_main_loop_quit (dd
->loop
);
1442 /* Destroy the dialog. This makes it pop down. */
1445 pop_down_dialog (Lisp_Object arg
)
1447 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1448 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1451 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1452 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1454 g_main_loop_quit (dd
->loop
);
1455 g_main_loop_unref (dd
->loop
);
1462 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1463 We pass in DATA as gpointer* so we can use this as a callback. */
1466 xg_maybe_add_timer (gpointer data
)
1468 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1469 EMACS_TIME next_time
= timer_check (1);
1470 long secs
= EMACS_SECS (next_time
);
1471 long usecs
= EMACS_USECS (next_time
);
1475 if (secs
>= 0 && usecs
>= 0 && secs
< ((guint
)-1)/1000)
1477 dd
->timerid
= g_timeout_add (secs
* 1000 + usecs
/1000,
1485 /* Pops up a modal dialog W and waits for response.
1486 We don't use gtk_dialog_run because we want to process emacs timers.
1487 The dialog W is not destroyed when this function returns. */
1490 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1492 int count
= SPECPDL_INDEX ();
1493 struct xg_dialog_data dd
;
1495 xg_set_screen (w
, f
);
1496 gtk_window_set_transient_for (GTK_WINDOW (w
),
1497 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1498 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1499 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1501 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1502 dd
.response
= GTK_RESPONSE_CANCEL
;
1506 g_signal_connect (G_OBJECT (w
),
1508 G_CALLBACK (xg_dialog_response_cb
),
1510 /* Don't destroy the widget if closed by the window manager close button. */
1511 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1512 gtk_widget_show (w
);
1514 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1516 (void) xg_maybe_add_timer (&dd
);
1517 g_main_loop_run (dd
.loop
);
1520 unbind_to (count
, Qnil
);
1526 /***********************************************************************
1527 File dialog functions
1528 ***********************************************************************/
1529 /* Return non-zero if the old file selection dialog is being used.
1530 Return zero if not. */
1533 xg_uses_old_file_dialog (void)
1535 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1536 extern int x_gtk_use_old_file_dialog
;
1537 return x_gtk_use_old_file_dialog
;
1544 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1546 /* Return the selected file for file chooser dialog W.
1547 The returned string must be free:d. */
1550 xg_get_file_name_from_chooser (GtkWidget
*w
)
1552 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1555 /* Callback called when the "Show hidden files" toggle is pressed.
1556 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1559 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1561 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1563 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1564 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1568 /* Callback called when a property changes in a file chooser.
1569 GOBJECT is the file chooser dialog, ARG1 describes the property.
1570 USER_DATA is the toggle widget in the file chooser dialog.
1571 We use this to update the "Show hidden files" toggle when the user
1572 changes that property by right clicking in the file list. */
1575 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1577 extern int x_gtk_show_hidden_files
;
1579 if (strcmp (arg1
->name
, "show-hidden") == 0)
1581 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1582 gboolean visible
, toggle_on
;
1584 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1585 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1587 if (!!visible
!= !!toggle_on
)
1589 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1590 G_CALLBACK (xg_toggle_visibility_cb
),
1592 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1593 g_signal_handlers_unblock_by_func
1594 (G_OBJECT (wtoggle
),
1595 G_CALLBACK (xg_toggle_visibility_cb
),
1598 x_gtk_show_hidden_files
= visible
;
1602 /* Read a file name from the user using a file chooser dialog.
1603 F is the current frame.
1604 PROMPT is a prompt to show to the user. May not be NULL.
1605 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1606 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1607 file. *FUNC is set to a function that can be used to retrieve the
1608 selected file name from the returned widget.
1610 Returns the created widget. */
1613 xg_get_file_with_chooser (FRAME_PTR f
,
1615 char *default_filename
,
1616 int mustmatch_p
, int only_dir_p
,
1617 xg_get_file_func
*func
)
1621 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1622 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1623 GtkFileChooserAction action
= (mustmatch_p
?
1624 GTK_FILE_CHOOSER_ACTION_OPEN
:
1625 GTK_FILE_CHOOSER_ACTION_SAVE
);
1626 extern int x_gtk_show_hidden_files
;
1627 extern int x_gtk_file_dialog_help_text
;
1631 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1633 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1634 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1635 (mustmatch_p
|| only_dir_p
?
1636 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1639 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1641 wbox
= gtk_vbox_new (FALSE
, 0);
1642 gtk_widget_show (wbox
);
1643 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1645 if (x_gtk_show_hidden_files
)
1647 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1648 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1650 gtk_widget_show (wtoggle
);
1651 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1652 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1653 g_signal_connect (G_OBJECT (filewin
), "notify",
1654 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1656 if (x_gtk_file_dialog_help_text
)
1659 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1660 Show the C-l help text only for versions < 2.10. */
1661 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1662 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1663 strcat (message
, "\nIf you don't like this file selector, use the "
1664 "corresponding\nkey binding or customize "
1665 "use-file-dialog to turn it off.");
1667 wmessage
= gtk_label_new (message
);
1668 gtk_widget_show (wmessage
);
1671 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1672 if (x_gtk_file_dialog_help_text
)
1673 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1674 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1676 if (default_filename
)
1679 struct gcpro gcpro1
;
1680 char *utf8_filename
;
1683 file
= build_string (default_filename
);
1685 /* File chooser does not understand ~/... in the file name. It must be
1686 an absolute name starting with /. */
1687 if (default_filename
[0] != '/')
1688 file
= Fexpand_file_name (file
, Qnil
);
1690 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1691 if (! NILP (Ffile_directory_p (file
)))
1692 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1696 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1698 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1700 char *cp
= strrchr (utf8_filename
, '/');
1702 else cp
= utf8_filename
;
1703 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1710 *func
= xg_get_file_name_from_chooser
;
1714 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1716 /* Return the selected file for file selector dialog W.
1717 The returned string must be free:d. */
1720 xg_get_file_name_from_selector (GtkWidget
*w
)
1722 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1723 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1726 /* Create a file selection dialog.
1727 F is the current frame.
1728 PROMPT is a prompt to show to the user. May not be NULL.
1729 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1730 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1731 file. *FUNC is set to a function that can be used to retrieve the
1732 selected file name from the returned widget.
1734 Returns the created widget. */
1737 xg_get_file_with_selection (FRAME_PTR f
,
1739 char *default_filename
,
1740 int mustmatch_p
, int only_dir_p
,
1741 xg_get_file_func
*func
)
1744 GtkFileSelection
*filesel
;
1746 filewin
= gtk_file_selection_new (prompt
);
1747 filesel
= GTK_FILE_SELECTION (filewin
);
1749 if (default_filename
)
1750 gtk_file_selection_set_filename (filesel
, default_filename
);
1754 /* The selection_entry part of filesel is not documented. */
1755 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1756 gtk_file_selection_hide_fileop_buttons (filesel
);
1759 *func
= xg_get_file_name_from_selector
;
1763 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1765 /* Read a file name from the user using a file dialog, either the old
1766 file selection dialog, or the new file chooser dialog. Which to use
1767 depends on what the GTK version used has, and what the value of
1768 gtk-use-old-file-dialog.
1769 F is the current frame.
1770 PROMPT is a prompt to show to the user. May not be NULL.
1771 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1772 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1775 Returns a file name or NULL if no file was selected.
1776 The returned string must be freed by the caller. */
1779 xg_get_file_name (FRAME_PTR f
,
1781 char *default_filename
,
1787 int filesel_done
= 0;
1788 xg_get_file_func func
;
1790 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1791 /* I really don't know why this is needed, but without this the GLIBC add on
1792 library linuxthreads hangs when the Gnome file chooser backend creates
1794 sigblock (sigmask (__SIGRTMIN
));
1795 #endif /* HAVE_GTK_AND_PTHREAD */
1797 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1799 if (xg_uses_old_file_dialog ())
1800 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1801 mustmatch_p
, only_dir_p
, &func
);
1803 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1804 mustmatch_p
, only_dir_p
, &func
);
1806 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1807 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1808 mustmatch_p
, only_dir_p
, &func
);
1809 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1811 gtk_widget_set_name (w
, "emacs-filedialog");
1813 filesel_done
= xg_dialog_run (f
, w
);
1815 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1816 sigunblock (sigmask (__SIGRTMIN
));
1819 if (filesel_done
== GTK_RESPONSE_OK
)
1822 gtk_widget_destroy (w
);
1826 #ifdef HAVE_FREETYPE
1827 /* Pop up a GTK font selector and return the name of the font the user
1828 selects, as a C string. The returned font name follows GTK's own
1831 `FAMILY [VALUE1 VALUE2] SIZE'
1833 This can be parsed using font_parse_fcname in font.c.
1834 DEFAULT_NAME, if non-zero, is the default font name. */
1837 xg_get_font_name (FRAME_PTR f
, const char *default_name
)
1840 char *fontname
= NULL
;
1843 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1844 sigblock (sigmask (__SIGRTMIN
));
1845 #endif /* HAVE_GTK_AND_PTHREAD */
1847 w
= gtk_font_selection_dialog_new ("Pick a font");
1849 default_name
= "Monospace 10";
1850 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1853 gtk_widget_set_name (w
, "emacs-fontdialog");
1855 done
= xg_dialog_run (f
, w
);
1857 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1858 sigunblock (sigmask (__SIGRTMIN
));
1861 if (done
== GTK_RESPONSE_OK
)
1862 fontname
= gtk_font_selection_dialog_get_font_name
1863 (GTK_FONT_SELECTION_DIALOG (w
));
1865 gtk_widget_destroy (w
);
1868 #endif /* HAVE_FREETYPE */
1872 /***********************************************************************
1874 ***********************************************************************/
1876 /* The name of menu items that can be used for customization. Since GTK
1877 RC files are very crude and primitive, we have to set this on all
1878 menu item names so a user can easily customize menu items. */
1880 #define MENU_ITEM_NAME "emacs-menuitem"
1883 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1884 during GC. The next member points to the items. */
1885 static xg_list_node xg_menu_cb_list
;
1887 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1888 during GC. The next member points to the items. */
1889 static xg_list_node xg_menu_item_cb_list
;
1891 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1892 F is the frame CL_DATA will be initialized for.
1893 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1895 The menu bar and all sub menus under the menu bar in a frame
1896 share the same structure, hence the reference count.
1898 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1899 allocated xg_menu_cb_data if CL_DATA is NULL. */
1901 static xg_menu_cb_data
*
1902 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
1906 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1908 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1909 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1910 cl_data
->highlight_cb
= highlight_cb
;
1911 cl_data
->ref_count
= 0;
1913 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1916 cl_data
->ref_count
++;
1921 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1922 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1924 When the menu bar is updated, menu items may have been added and/or
1925 removed, so menu_bar_vector and menu_bar_items_used change. We must
1926 then update CL_DATA since it is used to determine which menu
1927 item that is invoked in the menu.
1928 HIGHLIGHT_CB could change, there is no check that the same
1929 function is given when modifying a menu bar as was given when
1930 creating the menu bar. */
1933 update_cl_data (xg_menu_cb_data
*cl_data
,
1935 GCallback highlight_cb
)
1940 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1941 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1942 cl_data
->highlight_cb
= highlight_cb
;
1946 /* Decrease reference count for CL_DATA.
1947 If reference count is zero, free CL_DATA. */
1950 unref_cl_data (xg_menu_cb_data
*cl_data
)
1952 if (cl_data
&& cl_data
->ref_count
> 0)
1954 cl_data
->ref_count
--;
1955 if (cl_data
->ref_count
== 0)
1957 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1963 /* Function that marks all lisp data during GC. */
1970 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1971 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1973 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1975 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1977 if (! NILP (cb_data
->help
))
1978 mark_object (cb_data
->help
);
1983 /* Callback called when a menu item is destroyed. Used to free data.
1984 W is the widget that is being destroyed (not used).
1985 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1988 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
1992 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1993 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1998 /* Callback called when the pointer enters/leaves a menu item.
1999 W is the parent of the menu item.
2000 EVENT is either an enter event or leave event.
2001 CLIENT_DATA is not used.
2003 Returns FALSE to tell GTK to keep processing this event. */
2006 menuitem_highlight_callback (GtkWidget
*w
,
2007 GdkEventCrossing
*event
,
2008 gpointer client_data
)
2011 GtkWidget
*subwidget
;
2012 xg_menu_item_cb_data
*data
;
2014 ev
.crossing
= *event
;
2015 subwidget
= gtk_get_event_widget (&ev
);
2016 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
2020 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2022 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2023 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2024 (*func
) (subwidget
, call_data
);
2031 /* Callback called when a menu is destroyed. Used to free data.
2032 W is the widget that is being destroyed (not used).
2033 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2036 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2038 unref_cl_data ((xg_menu_cb_data
*) client_data
);
2041 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2042 must be non-NULL) and can be inserted into a menu item.
2044 Returns the GtkHBox. */
2047 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2053 wbox
= gtk_hbox_new (FALSE
, 0);
2054 wlbl
= gtk_label_new (utf8_label
);
2055 wkey
= gtk_label_new (utf8_key
);
2057 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2058 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2060 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2061 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2063 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2064 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2065 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2070 /* Make and return a menu item widget with the key to the right.
2071 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2072 UTF8_KEY is the text representing the key binding.
2073 ITEM is the widget_value describing the menu item.
2075 GROUP is an in/out parameter. If the menu item to be created is not
2076 part of any radio menu group, *GROUP contains NULL on entry and exit.
2077 If the menu item to be created is part of a radio menu group, on entry
2078 *GROUP contains the group to use, or NULL if this is the first item
2079 in the group. On exit, *GROUP contains the radio item group.
2081 Unfortunately, keys don't line up as nicely as in Motif,
2082 but the MacOS X version doesn't either, so I guess that is OK. */
2085 make_menu_item (const char *utf8_label
,
2086 const char *utf8_key
,
2091 GtkWidget
*wtoadd
= 0;
2093 /* It has been observed that some menu items have a NULL name field.
2094 This will lead to this function being called with a NULL utf8_label.
2095 GTK crashes on that so we set a blank label. Why there is a NULL
2096 name remains to be investigated. */
2097 if (! utf8_label
) utf8_label
= " ";
2100 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2102 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2105 if (utf8_key
) w
= gtk_check_menu_item_new ();
2106 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2107 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2109 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2111 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2112 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2113 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2115 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2120 if (utf8_key
) w
= gtk_menu_item_new ();
2121 else w
= gtk_menu_item_new_with_label (utf8_label
);
2124 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2125 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2130 /* Return non-zero if LABEL specifies a separator (GTK only has one
2133 static const char* separator_names
[] = {
2138 "single-dashed-line",
2139 "double-dashed-line",
2141 "shadow-etched-out",
2142 "shadow-etched-in-dash",
2143 "shadow-etched-out-dash",
2144 "shadow-double-etched-in",
2145 "shadow-double-etched-out",
2146 "shadow-double-etched-in-dash",
2147 "shadow-double-etched-out-dash",
2152 xg_separator_p (const char *label
)
2154 if (! label
) return 0;
2155 else if (strlen (label
) > 3
2156 && strncmp (label
, "--", 2) == 0
2162 for (i
= 0; separator_names
[i
]; ++i
)
2163 if (strcmp (label
, separator_names
[i
]) == 0)
2168 /* Old-style separator, maybe. It's a separator if it contains
2170 while (*label
== '-')
2172 if (*label
== 0) return 1;
2178 static int xg_detached_menus
;
2180 /* Returns non-zero if there are detached menus. */
2183 xg_have_tear_offs (void)
2185 return xg_detached_menus
> 0;
2188 /* Callback invoked when a detached menu window is removed. Here we
2189 decrease the xg_detached_menus count.
2190 WIDGET is the top level window that is removed (the parent of the menu).
2191 CLIENT_DATA is not used. */
2194 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2196 if (xg_detached_menus
> 0) --xg_detached_menus
;
2199 /* Callback invoked when a menu is detached. It increases the
2200 xg_detached_menus count.
2201 WIDGET is the GtkTearoffMenuItem.
2202 CLIENT_DATA is not used. */
2205 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2207 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2208 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2210 ++xg_detached_menus
;
2211 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2213 G_CALLBACK (tearoff_remove
), 0);
2218 /* Create a menu item widget, and connect the callbacks.
2219 ITEM decribes the menu item.
2220 F is the frame the created menu belongs to.
2221 SELECT_CB is the callback to use when a menu item is selected.
2222 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2223 CL_DATA points to the callback data to be used for this menu.
2224 GROUP is an in/out parameter. If the menu item to be created is not
2225 part of any radio menu group, *GROUP contains NULL on entry and exit.
2226 If the menu item to be created is part of a radio menu group, on entry
2227 *GROUP contains the group to use, or NULL if this is the first item
2228 in the group. On exit, *GROUP contains the radio item group.
2230 Returns the created GtkWidget. */
2233 xg_create_one_menuitem (widget_value
*item
,
2235 GCallback select_cb
,
2236 GCallback highlight_cb
,
2237 xg_menu_cb_data
*cl_data
,
2243 xg_menu_item_cb_data
*cb_data
;
2245 utf8_label
= get_utf8_string (item
->name
);
2246 utf8_key
= get_utf8_string (item
->key
);
2248 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2250 if (utf8_label
) g_free (utf8_label
);
2251 if (utf8_key
) g_free (utf8_key
);
2253 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2255 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2257 cb_data
->select_id
= 0;
2258 cb_data
->help
= item
->help
;
2259 cb_data
->cl_data
= cl_data
;
2260 cb_data
->call_data
= item
->call_data
;
2262 g_signal_connect (G_OBJECT (w
),
2264 G_CALLBACK (menuitem_destroy_callback
),
2267 /* Put cb_data in widget, so we can get at it when modifying menubar */
2268 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2270 /* final item, not a submenu */
2271 if (item
->call_data
&& ! item
->contents
)
2275 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2281 /* Create a full menu tree specified by DATA.
2282 F is the frame the created menu belongs to.
2283 SELECT_CB is the callback to use when a menu item is selected.
2284 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2285 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2286 POP_UP_P is non-zero if we shall create a popup menu.
2287 MENU_BAR_P is non-zero if we shall create a menu bar.
2288 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2289 if MENU_BAR_P is non-zero.
2290 TOPMENU is the topmost GtkWidget that others shall be placed under.
2291 It may be NULL, in that case we create the appropriate widget
2292 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2293 CL_DATA is the callback data we shall use for this menu, or NULL
2294 if we haven't set the first callback yet.
2295 NAME is the name to give to the top level menu if this function
2296 creates it. May be NULL to not set any name.
2298 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2301 This function calls itself to create submenus. */
2304 create_menus (widget_value
*data
,
2306 GCallback select_cb
,
2307 GCallback deactivate_cb
,
2308 GCallback highlight_cb
,
2313 xg_menu_cb_data
*cl_data
,
2317 GtkWidget
*wmenu
= topmenu
;
2318 GSList
*group
= NULL
;
2324 wmenu
= gtk_menu_new ();
2325 xg_set_screen (wmenu
, f
);
2326 /* Connect this to the menu instead of items so we get enter/leave for
2327 disabled items also. TODO: Still does not get enter/leave for
2328 disabled items in detached menus. */
2329 g_signal_connect (G_OBJECT (wmenu
),
2330 "enter-notify-event",
2331 G_CALLBACK (menuitem_highlight_callback
),
2333 g_signal_connect (G_OBJECT (wmenu
),
2334 "leave-notify-event",
2335 G_CALLBACK (menuitem_highlight_callback
),
2340 wmenu
= gtk_menu_bar_new ();
2341 /* Set width of menu bar to a small value so it doesn't enlarge
2342 a small initial frame size. The width will be set to the
2343 width of the frame later on when it is added to a container.
2344 height -1: Natural height. */
2345 gtk_widget_set_size_request (wmenu
, 1, -1);
2348 /* Put cl_data on the top menu for easier access. */
2349 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2350 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2351 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2352 G_CALLBACK (menu_destroy_callback
), cl_data
);
2355 gtk_widget_set_name (wmenu
, name
);
2358 g_signal_connect (G_OBJECT (wmenu
),
2359 "selection-done", deactivate_cb
, 0);
2362 if (! menu_bar_p
&& add_tearoff_p
)
2364 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2365 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2367 g_signal_connect (G_OBJECT (tearoff
), "activate",
2368 G_CALLBACK (tearoff_activate
), 0);
2371 for (item
= data
; item
; item
= item
->next
)
2375 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2376 && !xg_separator_p (item
->name
))
2379 /* A title for a popup. We do the same as GTK does when
2380 creating titles, but it does not look good. */
2382 utf8_label
= get_utf8_string (item
->name
);
2384 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2385 w
= gtk_menu_item_new_with_label (utf8_label
);
2386 gtk_widget_set_sensitive (w
, FALSE
);
2387 if (utf8_label
) g_free (utf8_label
);
2389 else if (xg_separator_p (item
->name
))
2392 /* GTK only have one separator type. */
2393 w
= gtk_separator_menu_item_new ();
2397 w
= xg_create_one_menuitem (item
,
2399 item
->contents
? 0 : select_cb
,
2404 /* Create a possibly empty submenu for menu bar items, since some
2405 themes don't highlight items correctly without it. */
2406 if (item
->contents
|| menu_bar_p
)
2408 GtkWidget
*submenu
= create_menus (item
->contents
,
2419 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2423 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2424 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2430 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2431 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2432 with some text and buttons.
2433 F is the frame the created item belongs to.
2434 NAME is the name to use for the top widget.
2435 VAL is a widget_value structure describing items to be created.
2436 SELECT_CB is the callback to use when a menu item is selected or
2437 a dialog button is pressed.
2438 DEACTIVATE_CB is the callback to use when an item is deactivated.
2439 For a menu, when a sub menu is not shown anymore, for a dialog it is
2440 called when the dialog is popped down.
2441 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2443 Returns the widget created. */
2446 xg_create_widget (const char *type
, const char *name
, FRAME_PTR f
, widget_value
*val
,
2447 GCallback select_cb
, GCallback deactivate_cb
,
2448 GCallback highlight_cb
)
2451 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2452 int pop_up_p
= strcmp (type
, "popup") == 0;
2454 if (strcmp (type
, "dialog") == 0)
2456 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2457 xg_set_screen (w
, f
);
2458 gtk_window_set_transient_for (GTK_WINDOW (w
),
2459 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2460 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2461 gtk_widget_set_name (w
, "emacs-dialog");
2462 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2464 else if (menu_bar_p
|| pop_up_p
)
2466 w
= create_menus (val
->contents
,
2478 /* Set the cursor to an arrow for popup menus when they are mapped.
2479 This is done by default for menu bar menus. */
2482 /* Must realize so the GdkWindow inside the widget is created. */
2483 gtk_widget_realize (w
);
2484 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2489 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2496 /* Return the label for menu item WITEM. */
2499 xg_get_menu_item_label (GtkMenuItem
*witem
)
2501 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2502 return gtk_label_get_label (wlabel
);
2505 /* Return non-zero if the menu item WITEM has the text LABEL. */
2508 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2511 char *utf8_label
= get_utf8_string (label
);
2512 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2514 if (! old_label
&& ! utf8_label
)
2516 else if (old_label
&& utf8_label
)
2517 is_same
= strcmp (utf8_label
, old_label
) == 0;
2519 if (utf8_label
) g_free (utf8_label
);
2524 /* Destroy widgets in LIST. */
2527 xg_destroy_widgets (GList
*list
)
2531 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2533 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2535 /* Destroying the widget will remove it from the container it is in. */
2536 gtk_widget_destroy (w
);
2540 /* Update the top level names in MENUBAR (i.e. not submenus).
2541 F is the frame the menu bar belongs to.
2542 *LIST is a list with the current menu bar names (menu item widgets).
2543 ITER is the item within *LIST that shall be updated.
2544 POS is the numerical position, starting at 0, of ITER in *LIST.
2545 VAL describes what the menu bar shall look like after the update.
2546 SELECT_CB is the callback to use when a menu item is selected.
2547 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2548 CL_DATA points to the callback data to be used for this menu bar.
2550 This function calls itself to walk through the menu bar names. */
2553 xg_update_menubar (GtkWidget
*menubar
,
2559 GCallback select_cb
,
2560 GCallback deactivate_cb
,
2561 GCallback highlight_cb
,
2562 xg_menu_cb_data
*cl_data
)
2564 if (! iter
&& ! val
)
2566 else if (iter
&& ! val
)
2568 /* Item(s) have been removed. Remove all remaining items. */
2569 xg_destroy_widgets (iter
);
2571 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2572 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2573 gtk_menu_item_new_with_label (""),
2579 else if (! iter
&& val
)
2581 /* Item(s) added. Add all new items in one call. */
2582 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2583 0, 1, 0, menubar
, cl_data
, 0);
2589 /* Below this neither iter or val is NULL */
2590 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2592 /* This item is still the same, check next item. */
2594 iter
= g_list_next (iter
);
2597 else /* This item is changed. */
2599 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2600 GtkMenuItem
*witem2
= 0;
2601 int val_in_menubar
= 0;
2602 int iter_in_new_menubar
= 0;
2606 /* See if the changed entry (val) is present later in the menu bar */
2608 iter2
&& ! val_in_menubar
;
2609 iter2
= g_list_next (iter2
))
2611 witem2
= GTK_MENU_ITEM (iter2
->data
);
2612 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2615 /* See if the current entry (iter) is present later in the
2616 specification for the new menu bar. */
2617 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2618 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2620 if (val_in_menubar
&& ! iter_in_new_menubar
)
2624 /* This corresponds to:
2629 g_object_ref (G_OBJECT (witem
));
2630 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2631 gtk_widget_destroy (GTK_WIDGET (witem
));
2633 /* Must get new list since the old changed. */
2634 g_list_free (*list
);
2635 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2636 while (nr
-- > 0) iter
= g_list_next (iter
);
2638 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2640 /* This corresponds to:
2643 Rename B to X. This might seem to be a strange thing to do,
2644 since if there is a menu under B it will be totally wrong for X.
2645 But consider editing a C file. Then there is a C-mode menu
2646 (corresponds to B above).
2647 If then doing C-x C-f the minibuf menu (X above) replaces the
2648 C-mode menu. When returning from the minibuffer, we get
2649 back the C-mode menu. Thus we do:
2650 Rename B to X (C-mode to minibuf menu)
2651 Rename X to B (minibuf to C-mode menu).
2652 If the X menu hasn't been invoked, the menu under B
2653 is up to date when leaving the minibuffer. */
2654 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2655 char *utf8_label
= get_utf8_string (val
->name
);
2656 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2658 gtk_label_set_text (wlabel
, utf8_label
);
2660 /* If this item has a submenu that has been detached, change
2661 the title in the WM decorations also. */
2662 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2663 /* Set the title of the detached window. */
2664 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2666 if (utf8_label
) g_free (utf8_label
);
2667 iter
= g_list_next (iter
);
2671 else if (! val_in_menubar
&& iter_in_new_menubar
)
2673 /* This corresponds to:
2680 GtkWidget
*w
= xg_create_one_menuitem (val
,
2687 /* Create a possibly empty submenu for menu bar items, since some
2688 themes don't highlight items correctly without it. */
2689 GtkWidget
*submenu
= create_menus (NULL
, f
,
2690 select_cb
, deactivate_cb
,
2692 0, 0, 0, 0, cl_data
, 0);
2693 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2694 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2695 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2697 g_list_free (*list
);
2698 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2699 while (nr
-- > 0) iter
= g_list_next (iter
);
2700 iter
= g_list_next (iter
);
2704 else /* if (val_in_menubar && iter_in_new_menubar) */
2707 /* This corresponds to:
2712 g_object_ref (G_OBJECT (witem2
));
2713 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2714 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2715 GTK_WIDGET (witem2
), pos
);
2716 g_object_unref (G_OBJECT (witem2
));
2718 g_list_free (*list
);
2719 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2720 while (nr
-- > 0) iter
= g_list_next (iter
);
2721 if (iter
) iter
= g_list_next (iter
);
2727 /* Update the rest of the menu bar. */
2728 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2729 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2732 /* Update the menu item W so it corresponds to VAL.
2733 SELECT_CB is the callback to use when a menu item is selected.
2734 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2735 CL_DATA is the data to set in the widget for menu invocation. */
2738 xg_update_menu_item (widget_value
*val
,
2740 GCallback select_cb
,
2741 GCallback highlight_cb
,
2742 xg_menu_cb_data
*cl_data
)
2749 const char *old_label
= 0;
2750 const char *old_key
= 0;
2751 xg_menu_item_cb_data
*cb_data
;
2753 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2754 utf8_label
= get_utf8_string (val
->name
);
2755 utf8_key
= get_utf8_string (val
->key
);
2757 /* See if W is a menu item with a key. See make_menu_item above. */
2758 if (GTK_IS_HBOX (wchild
))
2760 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2762 wlbl
= GTK_LABEL (list
->data
);
2763 wkey
= GTK_LABEL (list
->next
->data
);
2768 /* Remove the key and keep just the label. */
2769 g_object_ref (G_OBJECT (wlbl
));
2770 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2771 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2772 g_object_unref (G_OBJECT (wlbl
));
2777 else /* Just a label. */
2779 wlbl
= GTK_LABEL (wchild
);
2781 /* Check if there is now a key. */
2784 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2785 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2787 wlbl
= GTK_LABEL (list
->data
);
2788 wkey
= GTK_LABEL (list
->next
->data
);
2791 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2792 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2797 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2798 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2800 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2801 gtk_label_set_text (wkey
, utf8_key
);
2803 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2804 gtk_label_set_text (wlbl
, utf8_label
);
2806 if (utf8_key
) g_free (utf8_key
);
2807 if (utf8_label
) g_free (utf8_label
);
2809 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2810 gtk_widget_set_sensitive (w
, FALSE
);
2811 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2812 gtk_widget_set_sensitive (w
, TRUE
);
2814 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2818 cb_data
->call_data
= val
->call_data
;
2819 cb_data
->help
= val
->help
;
2820 cb_data
->cl_data
= cl_data
;
2822 /* We assume the callback functions don't change. */
2823 if (val
->call_data
&& ! val
->contents
)
2825 /* This item shall have a select callback. */
2826 if (! cb_data
->select_id
)
2828 = g_signal_connect (G_OBJECT (w
), "activate",
2829 select_cb
, cb_data
);
2831 else if (cb_data
->select_id
)
2833 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2834 cb_data
->select_id
= 0;
2839 /* Update the toggle menu item W so it corresponds to VAL. */
2842 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
2844 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2847 /* Update the radio menu item W so it corresponds to VAL. */
2850 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
2852 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2855 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2856 SUBMENU may be NULL, in that case a new menu is created.
2857 F is the frame the menu bar belongs to.
2858 VAL describes the contents of the menu bar.
2859 SELECT_CB is the callback to use when a menu item is selected.
2860 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2861 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2862 CL_DATA is the call back data to use for any newly created items.
2864 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2868 xg_update_submenu (GtkWidget
*submenu
,
2871 GCallback select_cb
,
2872 GCallback deactivate_cb
,
2873 GCallback highlight_cb
,
2874 xg_menu_cb_data
*cl_data
)
2876 GtkWidget
*newsub
= submenu
;
2880 int has_tearoff_p
= 0;
2881 GList
*first_radio
= 0;
2884 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2886 for (cur
= val
, iter
= list
;
2888 iter
= g_list_next (iter
), cur
= cur
->next
)
2890 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2892 /* Skip tearoff items, they have no counterpart in val. */
2893 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2896 iter
= g_list_next (iter
);
2897 if (iter
) w
= GTK_WIDGET (iter
->data
);
2901 /* Remember first radio button in a group. If we get a mismatch in
2902 a radio group we must rebuild the whole group so that the connections
2903 in GTK becomes correct. */
2904 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2906 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2907 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2910 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2912 if (! xg_separator_p (cur
->name
))
2915 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2917 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2919 xg_update_toggle_item (cur
, w
);
2920 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2922 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2924 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2926 xg_update_radio_item (cur
, w
);
2927 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2929 else if (GTK_IS_MENU_ITEM (w
))
2931 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2934 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2935 xg_separator_p (cur
->name
))
2938 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2940 sub
= gtk_menu_item_get_submenu (witem
);
2941 if (sub
&& ! cur
->contents
)
2943 /* Not a submenu anymore. */
2944 g_object_ref (G_OBJECT (sub
));
2945 remove_submenu (witem
);
2946 gtk_widget_destroy (sub
);
2948 else if (cur
->contents
)
2952 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2953 select_cb
, deactivate_cb
,
2954 highlight_cb
, cl_data
);
2956 /* If this item just became a submenu, we must set it. */
2958 gtk_menu_item_set_submenu (witem
, nsub
);
2963 /* Structural difference. Remove everything from here and down
2969 /* Remove widgets from first structual change. */
2972 /* If we are adding new menu items below, we must remove from
2973 first radio button so that radio groups become correct. */
2974 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2975 else xg_destroy_widgets (iter
);
2980 /* More items added. Create them. */
2981 newsub
= create_menus (cur
,
2994 if (list
) g_list_free (list
);
2999 /* Update the MENUBAR.
3000 F is the frame the menu bar belongs to.
3001 VAL describes the contents of the menu bar.
3002 If DEEP_P is non-zero, rebuild all but the top level menu names in
3003 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3004 SELECT_CB is the callback to use when a menu item is selected.
3005 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3006 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3009 xg_modify_menubar_widgets (GtkWidget
*menubar
, FRAME_PTR f
, widget_value
*val
,
3011 GCallback select_cb
, GCallback deactivate_cb
,
3012 GCallback highlight_cb
)
3014 xg_menu_cb_data
*cl_data
;
3015 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3019 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
3022 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3023 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3029 /* Update all sub menus.
3030 We must keep the submenus (GTK menu item widgets) since the
3031 X Window in the XEvent that activates the menu are those widgets. */
3033 /* Update cl_data, menu_item things in F may have changed. */
3034 update_cl_data (cl_data
, f
, highlight_cb
);
3036 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3041 GtkMenuItem
*witem
= 0;
3043 /* Find sub menu that corresponds to val and update it. */
3044 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3046 witem
= GTK_MENU_ITEM (iter
->data
);
3047 if (xg_item_label_same_p (witem
, cur
->name
))
3049 sub
= gtk_menu_item_get_submenu (witem
);
3054 newsub
= xg_update_submenu (sub
,
3061 /* sub may still be NULL. If we just updated non deep and added
3062 a new menu bar item, it has no sub menu yet. So we set the
3063 newly created sub menu under witem. */
3064 if (newsub
!= sub
&& witem
!= 0)
3066 xg_set_screen (newsub
, f
);
3067 gtk_menu_item_set_submenu (witem
, newsub
);
3073 gtk_widget_show_all (menubar
);
3076 /* Recompute all the widgets of frame F, when the menu bar has been
3077 changed. Value is non-zero if widgets were updated. */
3080 xg_update_frame_menubar (FRAME_PTR f
)
3082 struct x_output
*x
= f
->output_data
.x
;
3085 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3088 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3089 return 0; /* Already done this, happens for frames created invisible. */
3093 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3095 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3097 gtk_widget_show_all (x
->menubar_widget
);
3098 gtk_widget_size_request (x
->menubar_widget
, &req
);
3099 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3100 xg_height_or_width_changed (f
);
3106 /* Get rid of the menu bar of frame F, and free its storage.
3107 This is used when deleting a frame, and when turning off the menu bar. */
3110 free_frame_menubar (FRAME_PTR f
)
3112 struct x_output
*x
= f
->output_data
.x
;
3114 if (x
->menubar_widget
)
3118 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3119 /* The menubar and its children shall be deleted when removed from
3121 x
->menubar_widget
= 0;
3122 FRAME_MENUBAR_HEIGHT (f
) = 0;
3123 xg_height_or_width_changed (f
);
3129 xg_event_is_for_menubar (FRAME_PTR f
, XEvent
*event
)
3131 struct x_output
*x
= f
->output_data
.x
;
3140 if (! x
->menubar_widget
) return 0;
3142 if (! (event
->xbutton
.x
>= 0
3143 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3144 && event
->xbutton
.y
>= 0
3145 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3146 && event
->xbutton
.same_screen
))
3149 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3150 gw
= gdk_xid_table_lookup_for_display (gdpy
, event
->xbutton
.window
);
3152 gevent
.any
.window
= gw
;
3153 gwdesc
= gtk_get_event_widget (&gevent
);
3154 if (! gwdesc
) return 0;
3155 if (! GTK_IS_MENU_BAR (gwdesc
)
3156 && ! GTK_IS_MENU_ITEM (gwdesc
)
3157 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3160 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3161 if (! list
) return 0;
3162 rec
.x
= event
->xbutton
.x
;
3163 rec
.y
= event
->xbutton
.y
;
3167 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3169 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3170 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3174 return iter
== 0 ? 0 : 1;
3179 /***********************************************************************
3180 Scroll bar functions
3181 ***********************************************************************/
3184 /* Setting scroll bar values invokes the callback. Use this variable
3185 to indicate that callback should do nothing. */
3187 int xg_ignore_gtk_scrollbar
;
3189 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3190 may be larger than 32 bits. Keep a mapping from integer index to widget
3191 pointers to get around the 32 bit limitation. */
3195 GtkWidget
**widgets
;
3200 /* Grow this much every time we need to allocate more */
3202 #define ID_TO_WIDGET_INCR 32
3204 /* Store the widget pointer W in id_to_widget and return the integer index. */
3207 xg_store_widget_in_map (GtkWidget
*w
)
3211 if (id_to_widget
.max_size
== id_to_widget
.used
)
3213 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3215 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
3216 sizeof (GtkWidget
*)*new_size
);
3218 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3219 id_to_widget
.widgets
[i
] = 0;
3220 id_to_widget
.max_size
= new_size
;
3223 /* Just loop over the array and find a free place. After all,
3224 how many scroll bars are we creating? Should be a small number.
3225 The check above guarantees we will find a free place. */
3226 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3228 if (! id_to_widget
.widgets
[i
])
3230 id_to_widget
.widgets
[i
] = w
;
3231 ++id_to_widget
.used
;
3237 /* Should never end up here */
3241 /* Remove pointer at IDX from id_to_widget.
3242 Called when scroll bar is destroyed. */
3245 xg_remove_widget_from_map (int idx
)
3247 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3249 id_to_widget
.widgets
[idx
] = 0;
3250 --id_to_widget
.used
;
3254 /* Get the widget pointer at IDX from id_to_widget. */
3257 xg_get_widget_from_map (int idx
)
3259 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3260 return id_to_widget
.widgets
[idx
];
3265 /* Return the scrollbar id for X Window WID on display DPY.
3266 Return -1 if WID not in id_to_widget. */
3269 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3274 w
= xg_win_to_widget (dpy
, wid
);
3278 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3279 if (id_to_widget
.widgets
[idx
] == w
)
3286 /* Callback invoked when scroll bar WIDGET is destroyed.
3287 DATA is the index into id_to_widget for WIDGET.
3288 We free pointer to last scroll bar values here and remove the index. */
3291 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3293 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
3294 xg_remove_widget_from_map (id
);
3297 /* Create a scroll bar widget for frame F. Store the scroll bar
3299 SCROLL_CALLBACK is the callback to invoke when the value of the
3301 END_CALLBACK is the callback to invoke when scrolling ends.
3302 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3303 to set resources for the widget. */
3306 xg_create_scroll_bar (FRAME_PTR f
,
3307 struct scroll_bar
*bar
,
3308 GCallback scroll_callback
,
3309 GCallback end_callback
,
3310 const char *scroll_bar_name
)
3317 /* Page, step increment values are not so important here, they
3318 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3319 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3322 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3323 webox
= gtk_event_box_new ();
3324 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3325 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3326 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3328 scroll_id
= xg_store_widget_in_map (wscroll
);
3330 /* The EMACS_INT cast avoids a warning. */
3331 g_signal_connect (G_OBJECT (wscroll
),
3333 G_CALLBACK (xg_gtk_scroll_destroy
),
3334 (gpointer
) (EMACS_INT
) scroll_id
);
3335 g_signal_connect (G_OBJECT (wscroll
),
3339 g_signal_connect (G_OBJECT (wscroll
),
3340 "button-release-event",
3344 /* The scroll bar widget does not draw on a window of its own. Instead
3345 it draws on the parent window, in this case the edit widget. So
3346 whenever the edit widget is cleared, the scroll bar needs to redraw
3347 also, which causes flicker. Put an event box between the edit widget
3348 and the scroll bar, so the scroll bar instead draws itself on the
3349 event box window. */
3350 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3351 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3354 /* Set the cursor to an arrow. */
3355 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3357 bar
->x_window
= scroll_id
;
3360 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3363 xg_remove_scroll_bar (FRAME_PTR f
, int scrollbar_id
)
3365 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3368 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3369 gtk_widget_destroy (w
);
3370 gtk_widget_destroy (wparent
);
3371 SET_FRAME_GARBAGED (f
);
3375 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3377 TOP/LEFT are the new pixel positions where the bar shall appear.
3378 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3381 xg_update_scrollbar_pos (FRAME_PTR f
,
3389 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3393 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3394 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3397 /* Clear out old position. */
3398 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3399 if (gtk_widget_get_parent (wparent
) == wfixed
)
3401 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3402 "x", &oldx
, "y", &oldy
, NULL
);
3403 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3406 /* Move and resize to new values. */
3407 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3408 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3411 /* No room. Hide scroll bar as some themes output a warning if
3412 the height is less than the min size. */
3413 gtk_widget_hide (wparent
);
3414 gtk_widget_hide (wscroll
);
3418 gtk_widget_show_all (wparent
);
3419 gtk_widget_set_size_request (wscroll
, width
, height
);
3421 gtk_widget_queue_draw (wfixed
);
3422 gdk_window_process_all_updates ();
3423 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3425 /* Clear under old scroll bar position. This must be done after
3426 the gtk_widget_queue_draw and gdk_window_process_all_updates
3428 x_clear_area (FRAME_X_DISPLAY (f
),
3430 oldx
, oldy
, oldw
, oldh
, 0);
3433 /* GTK does not redraw until the main loop is entered again, but
3434 if there are no X events pending we will not enter it. So we sync
3435 here to get some events. */
3438 SET_FRAME_GARBAGED (f
);
3439 cancel_mouse_face (f
);
3443 /* Set the thumb size and position of scroll bar BAR. We are currently
3444 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3447 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3452 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3454 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3456 if (wscroll
&& NILP (bar
->dragging
))
3465 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3467 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3468 rather than the real portion value. This makes the thumb less likely
3469 to resize and that looks better. */
3470 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3471 /* When the thumb is at the bottom, position == whole.
3472 So we need to increase `whole' to make space for the thumb. */
3479 top
= (gdouble
) position
/ whole
;
3480 shown
= (gdouble
) portion
/ whole
;
3483 size
= shown
* XG_SB_RANGE
;
3484 size
= min (size
, XG_SB_RANGE
);
3485 size
= max (size
, 1);
3487 value
= top
* XG_SB_RANGE
;
3488 value
= min (value
, XG_SB_MAX
- size
);
3489 value
= max (value
, XG_SB_MIN
);
3491 /* Assume all lines are of equal size. */
3492 new_step
= size
/ max (1, FRAME_LINES (f
));
3494 if ((int) gtk_adjustment_get_page_size (adj
) != size
3495 || (int) gtk_adjustment_get_step_increment (adj
) != new_step
)
3497 gtk_adjustment_set_page_size (adj
, size
);
3498 gtk_adjustment_set_step_increment (adj
, new_step
);
3499 /* Assume a page increment is about 95% of the page size */
3500 gtk_adjustment_set_page_increment (adj
,(int) (0.95*size
));
3504 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3508 /* gtk_range_set_value invokes the callback. Set
3509 ignore_gtk_scrollbar to make the callback do nothing */
3510 xg_ignore_gtk_scrollbar
= 1;
3512 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3513 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3515 gtk_adjustment_changed (adj
);
3517 xg_ignore_gtk_scrollbar
= 0;
3524 /* Return non-zero if EVENT is for a scroll bar in frame F.
3525 When the same X window is used for several Gtk+ widgets, we cannot
3526 say for sure based on the X window alone if an event is for the
3527 frame. This function does additional checks.
3529 Return non-zero if the event is for a scroll bar, zero otherwise. */
3532 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3536 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3538 /* Check if press occurred outside the edit widget. */
3539 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3540 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3541 != gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3544 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3545 || event
->type
== MotionNotify
))
3547 /* If we are releasing or moving the scroll bar, it has the grab. */
3548 GtkWidget
*w
= gtk_grab_get_current ();
3549 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3557 /***********************************************************************
3559 ***********************************************************************/
3560 /* The key for the data we put in the GtkImage widgets. The data is
3561 the image used by Emacs. We use this to see if we need to update
3562 the GtkImage with a new image. */
3563 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3565 /* The key for storing the latest modifiers so the activate callback can
3567 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3569 /* The key for storing the button widget in its proxy menu item. */
3570 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3572 /* The key for the data we put in the GtkImage widgets. The data is
3573 the stock name used by Emacs. We use this to see if we need to update
3574 the GtkImage with a new image. */
3575 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3577 /* As above, but this is used for named theme widgets, as opposed to
3579 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3581 /* Callback function invoked when a tool bar item is pressed.
3582 W is the button widget in the tool bar that got pressed,
3583 CLIENT_DATA is an integer that is the index of the button in the
3584 tool bar. 0 is the first button. */
3587 xg_tool_bar_button_cb (GtkWidget
*widget
,
3588 GdkEventButton
*event
,
3591 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3592 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3593 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3598 /* Callback function invoked when a tool bar item is pressed.
3599 W is the button widget in the tool bar that got pressed,
3600 CLIENT_DATA is an integer that is the index of the button in the
3601 tool bar. 0 is the first button. */
3604 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3606 /* The EMACS_INT cast avoids a warning. */
3607 int idx
= (int) (EMACS_INT
) client_data
;
3608 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3609 XG_TOOL_BAR_LAST_MODIFIER
);
3611 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3612 Lisp_Object key
, frame
;
3613 struct input_event event
;
3616 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3619 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3621 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3622 XSETFRAME (frame
, f
);
3624 /* We generate two events here. The first one is to set the prefix
3625 to `(tool_bar)', see keyboard.c. */
3626 event
.kind
= TOOL_BAR_EVENT
;
3627 event
.frame_or_window
= frame
;
3629 kbd_buffer_store_event (&event
);
3631 event
.kind
= TOOL_BAR_EVENT
;
3632 event
.frame_or_window
= frame
;
3634 /* Convert between the modifier bits GDK uses and the modifier bits
3635 Emacs uses. This assumes GDK and X masks are the same, which they are when
3637 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3638 kbd_buffer_store_event (&event
);
3640 /* Return focus to the frame after we have clicked on a detached
3642 Fx_focus_frame (frame
);
3645 /* Callback function invoked when a tool bar item is pressed in a detached
3646 tool bar or the overflow drop down menu.
3647 We just call xg_tool_bar_callback.
3648 W is the menu item widget that got pressed,
3649 CLIENT_DATA is an integer that is the index of the button in the
3650 tool bar. 0 is the first button. */
3653 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3655 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3656 XG_TOOL_BAR_PROXY_BUTTON
));
3657 xg_tool_bar_callback (wbutton
, client_data
);
3662 xg_tool_bar_help_callback (GtkWidget
*w
,
3663 GdkEventCrossing
*event
,
3664 gpointer client_data
);
3666 /* This callback is called when a help is to be shown for an item in
3667 the detached tool bar when the detached tool bar it is not expanded. */
3670 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3671 GdkEventCrossing
*event
,
3672 gpointer client_data
)
3674 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3675 XG_TOOL_BAR_PROXY_BUTTON
));
3677 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3681 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3683 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3684 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3685 GtkWidget
*c2
= (GtkWidget
*) clist
->next
->data
;
3686 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3687 g_list_free (clist
);
3688 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3692 /* This callback is called when a tool item should create a proxy item,
3693 such as for the overflow menu. Also called when the tool bar is detached.
3694 If we don't create a proxy menu item, the detached tool bar will be
3698 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3700 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (toolitem
));
3701 GtkButton
*wbutton
= GTK_BUTTON (gtk_bin_get_child (GTK_BIN (weventbox
)));
3702 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
3704 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3705 GtkImage
*wimage
= GTK_IMAGE (c1
);
3706 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3707 (gtk_label_get_text (wlbl
));
3708 GtkWidget
*wmenuimage
;
3711 if (gtk_button_get_use_stock (wbutton
))
3712 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3713 GTK_ICON_SIZE_MENU
);
3716 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3717 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3719 if (store_type
== GTK_IMAGE_STOCK
)
3722 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3723 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3725 else if (store_type
== GTK_IMAGE_ICON_SET
)
3727 GtkIconSet
*icon_set
;
3728 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3729 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3730 GTK_ICON_SIZE_MENU
);
3732 else if (store_type
== GTK_IMAGE_PIXBUF
)
3737 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3740 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3742 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3743 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3744 GDK_INTERP_BILINEAR
);
3746 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3750 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3754 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3756 const gchar
*icon_name
;
3757 GtkIconSize icon_size
;
3759 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3760 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3761 GTK_ICON_SIZE_MENU
);
3765 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3770 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3772 g_signal_connect (G_OBJECT (wmenuitem
),
3774 G_CALLBACK (xg_tool_bar_proxy_callback
),
3778 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3779 (gpointer
) wbutton
);
3780 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3781 gtk_widget_set_sensitive (wmenuitem
,
3782 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
3784 /* Use enter/leave notify to show help. We use the events
3785 rather than the GtkButton specific signals "enter" and
3786 "leave", so we can have only one callback. The event
3787 will tell us what kind of event it is. */
3788 g_signal_connect (G_OBJECT (wmenuitem
),
3789 "enter-notify-event",
3790 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3792 g_signal_connect (G_OBJECT (wmenuitem
),
3793 "leave-notify-event",
3794 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3800 /* This callback is called when a tool bar is detached. We must set
3801 the height of the tool bar to zero when this happens so frame sizes
3802 are correctly calculated.
3803 WBOX is the handle box widget that enables detach/attach of the tool bar.
3804 W is the tool bar widget.
3805 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3808 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
3810 gpointer client_data
)
3812 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3813 extern int x_gtk_whole_detached_tool_bar
;
3815 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3820 GtkRequisition req
, req2
;
3821 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3822 gtk_widget_size_request (GTK_WIDGET (wbox
), &req
);
3823 gtk_widget_size_request (w
, &req2
);
3824 req
.width
-= req2
.width
;
3825 req
.height
-= req2
.height
;
3826 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
3827 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
3828 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
3829 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
3830 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
3831 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
3832 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
3833 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
3834 xg_height_or_width_changed (f
);
3838 /* This callback is called when a tool bar is reattached. We must set
3839 the height of the tool bar when this happens so frame sizes
3840 are correctly calculated.
3841 WBOX is the handle box widget that enables detach/attach of the tool bar.
3842 W is the tool bar widget.
3843 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3846 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
3848 gpointer client_data
)
3850 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3851 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3855 GtkRequisition req
, req2
;
3856 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3857 gtk_widget_size_request (GTK_WIDGET (wbox
), &req
);
3858 gtk_widget_size_request (w
, &req2
);
3859 req
.width
+= req2
.width
;
3860 req
.height
+= req2
.height
;
3861 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
3862 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
3863 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
3864 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
3865 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
3866 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
3867 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
3868 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
3869 xg_height_or_width_changed (f
);
3873 /* This callback is called when the mouse enters or leaves a tool bar item.
3874 It is used for displaying and hiding the help text.
3875 W is the tool bar item, a button.
3876 EVENT is either an enter event or leave event.
3877 CLIENT_DATA is an integer that is the index of the button in the
3878 tool bar. 0 is the first button.
3880 Returns FALSE to tell GTK to keep processing this event. */
3883 xg_tool_bar_help_callback (GtkWidget
*w
,
3884 GdkEventCrossing
*event
,
3885 gpointer client_data
)
3887 /* The EMACS_INT cast avoids a warning. */
3888 int idx
= (int) (EMACS_INT
) client_data
;
3889 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3890 Lisp_Object help
, frame
;
3892 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3895 if (event
->type
== GDK_ENTER_NOTIFY
)
3897 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3898 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3901 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3906 XSETFRAME (frame
, f
);
3907 kbd_buffer_store_help_event (frame
, help
);
3913 /* This callback is called when a tool bar item shall be redrawn.
3914 It modifies the expose event so that the GtkImage widget redraws the
3915 whole image. This to overcome a bug that makes GtkImage draw the image
3916 in the wrong place when it tries to redraw just a part of the image.
3917 W is the GtkImage to be redrawn.
3918 EVENT is the expose event for W.
3919 CLIENT_DATA is unused.
3921 Returns FALSE to tell GTK to keep processing this event. */
3924 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
3925 GdkEventExpose
*event
,
3926 gpointer client_data
)
3930 gdk_drawable_get_size (event
->window
, &width
, &height
);
3932 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3933 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3935 event
->area
.x
= max (0, event
->area
.x
);
3936 event
->area
.y
= max (0, event
->area
.y
);
3938 event
->area
.width
= max (width
, event
->area
.width
);
3939 event
->area
.height
= max (height
, event
->area
.height
);
3944 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
3945 #define toolbar_set_orientation(w, o) \
3946 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
3948 #define toolbar_set_orientation(w, o) \
3949 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
3952 /* Attach a tool bar to frame F. */
3955 xg_pack_tool_bar (FRAME_PTR f
, Lisp_Object pos
)
3957 struct x_output
*x
= f
->output_data
.x
;
3958 int into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
3960 toolbar_set_orientation (x
->toolbar_widget
,
3962 ? GTK_ORIENTATION_VERTICAL
3963 : GTK_ORIENTATION_HORIZONTAL
);
3964 if (!x
->handlebox_widget
)
3966 x
->handlebox_widget
= gtk_handle_box_new ();
3967 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3968 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3969 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3970 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3971 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3977 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
3979 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), x
->handlebox_widget
,
3982 if (EQ (pos
, Qleft
))
3983 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
3984 x
->handlebox_widget
,
3986 x
->toolbar_in_hbox
= 1;
3990 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3991 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
3993 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3997 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
3998 x
->handlebox_widget
,
4000 x
->toolbar_in_hbox
= 0;
4004 /* Create a tool bar for frame F. */
4007 xg_create_tool_bar (FRAME_PTR f
)
4009 struct x_output
*x
= f
->output_data
.x
;
4011 x
->toolbar_widget
= gtk_toolbar_new ();
4012 x
->toolbar_detached
= 0;
4014 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4016 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4017 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4021 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4023 /* Find the right-to-left image named by RTL in the tool bar images for F.
4024 Returns IMAGE if RTL is not found. */
4027 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
4030 Lisp_Object file
, rtl_name
;
4031 struct gcpro gcpro1
, gcpro2
;
4032 GCPRO2 (file
, rtl_name
);
4034 rtl_name
= Ffile_name_nondirectory (rtl
);
4036 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4038 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4039 if (!NILP (file
= file_for_image (rtl_image
)))
4041 file
= call1 (intern ("file-name-sans-extension"),
4042 Ffile_name_nondirectory (file
));
4043 if (EQ (Fequal (file
, rtl_name
), Qt
))
4054 static GtkToolItem
*
4055 xg_make_tool_item (FRAME_PTR f
,
4057 GtkWidget
**wbutton
,
4061 GtkToolItem
*ti
= gtk_tool_item_new ();
4062 Lisp_Object style
= Ftool_bar_get_system_style ();
4063 int both_horiz
= EQ (style
, Qboth_horiz
);
4064 int text_image
= EQ (style
, Qtext_image_horiz
);
4066 GtkWidget
*vb
= both_horiz
|| text_image
4067 ? gtk_hbox_new (FALSE
, 0) : gtk_vbox_new (FALSE
, 0);
4068 GtkWidget
*wb
= gtk_button_new ();
4069 GtkWidget
*weventbox
= gtk_event_box_new ();
4071 if (wimage
&& ! text_image
)
4072 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4074 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4076 if (wimage
&& text_image
)
4077 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4079 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4080 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4081 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4082 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4083 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4087 /* The EMACS_INT cast avoids a warning. */
4088 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4089 G_CALLBACK (xg_tool_bar_menu_proxy
),
4090 (gpointer
) (EMACS_INT
) i
);
4092 g_signal_connect (G_OBJECT (wb
), "clicked",
4093 G_CALLBACK (xg_tool_bar_callback
),
4094 (gpointer
) (EMACS_INT
) i
);
4096 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4098 /* Catch expose events to overcome an annoying redraw bug, see
4099 comment for xg_tool_bar_item_expose_callback. */
4100 g_signal_connect (G_OBJECT (ti
),
4102 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4105 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4107 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
4108 no distinction based on modifiers in the activate callback,
4109 so we have to do it ourselves. */
4110 g_signal_connect (wb
, "button-release-event",
4111 G_CALLBACK (xg_tool_bar_button_cb
),
4114 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4116 /* Use enter/leave notify to show help. We use the events
4117 rather than the GtkButton specific signals "enter" and
4118 "leave", so we can have only one callback. The event
4119 will tell us what kind of event it is. */
4120 /* The EMACS_INT cast avoids a warning. */
4121 g_signal_connect (G_OBJECT (weventbox
),
4122 "enter-notify-event",
4123 G_CALLBACK (xg_tool_bar_help_callback
),
4124 (gpointer
) (EMACS_INT
) i
);
4125 g_signal_connect (G_OBJECT (weventbox
),
4126 "leave-notify-event",
4127 G_CALLBACK (xg_tool_bar_help_callback
),
4128 (gpointer
) (EMACS_INT
) i
);
4131 if (wbutton
) *wbutton
= wb
;
4137 xg_show_toolbar_item (GtkToolItem
*ti
)
4139 Lisp_Object style
= Ftool_bar_get_system_style ();
4140 int both_horiz
= EQ (style
, Qboth_horiz
);
4141 int text_image
= EQ (style
, Qtext_image_horiz
);
4143 int horiz
= both_horiz
|| text_image
;
4144 int show_label
= ! EQ (style
, Qimage
);
4145 int show_image
= ! EQ (style
, Qtext
);
4147 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
4148 GtkWidget
*wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
4149 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
4151 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4152 GtkWidget
*new_box
= NULL
;
4154 if (GTK_IS_VBOX (vb
) && horiz
)
4155 new_box
= gtk_hbox_new (FALSE
, 0);
4156 else if (GTK_IS_HBOX (vb
) && !horiz
&& show_label
&& show_image
)
4157 new_box
= gtk_vbox_new (FALSE
, 0);
4159 if (!new_box
&& horiz
)
4160 gtk_box_reorder_child (GTK_BOX (vb
), wlbl
, text_image
? 0 : 1);
4163 g_object_ref (G_OBJECT (wimage
));
4164 g_object_ref (G_OBJECT (wlbl
));
4165 gtk_container_remove (GTK_CONTAINER (vb
), wimage
);
4166 gtk_container_remove (GTK_CONTAINER (vb
), wlbl
);
4167 gtk_widget_destroy (GTK_WIDGET (vb
));
4169 gtk_box_pack_start (GTK_BOX (new_box
), wimage
, TRUE
, TRUE
, 0);
4170 gtk_box_pack_start (GTK_BOX (new_box
), wlbl
, TRUE
, TRUE
, 0);
4172 gtk_box_pack_start (GTK_BOX (new_box
), wimage
, TRUE
, TRUE
, 0);
4173 gtk_container_add (GTK_CONTAINER (wbutton
), new_box
);
4174 g_object_unref (G_OBJECT (wimage
));
4175 g_object_unref (G_OBJECT (wlbl
));
4179 if (show_label
) gtk_widget_show (wlbl
);
4180 else gtk_widget_hide (wlbl
);
4181 if (show_image
) gtk_widget_show (wimage
);
4182 else gtk_widget_hide (wimage
);
4183 gtk_widget_show (GTK_WIDGET (weventbox
));
4184 gtk_widget_show (GTK_WIDGET (vb
));
4185 gtk_widget_show (GTK_WIDGET (wbutton
));
4186 gtk_widget_show (GTK_WIDGET (ti
));
4190 xg_update_tool_bar_sizes (FRAME_PTR f
)
4192 struct x_output
*x
= f
->output_data
.x
;
4194 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4196 gtk_widget_size_request (GTK_WIDGET (x
->handlebox_widget
), &req
);
4197 if (x
->toolbar_in_hbox
)
4200 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4201 x
->handlebox_widget
,
4202 "position", &pos
, NULL
);
4203 if (pos
== 0) nl
= req
.width
;
4204 else nr
= req
.width
;
4209 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4210 x
->handlebox_widget
,
4211 "position", &pos
, NULL
);
4212 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4213 else nb
= req
.height
;
4216 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4217 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4218 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4219 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4221 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4222 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4223 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4224 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4225 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4226 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4234 /* Update the tool bar for frame F. Add new buttons and remove old. */
4237 update_frame_tool_bar (FRAME_PTR f
)
4240 struct x_output
*x
= f
->output_data
.x
;
4241 int hmargin
= 0, vmargin
= 0;
4242 GtkToolbar
*wtoolbar
;
4244 GtkTextDirection dir
;
4245 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
4247 if (! FRAME_GTK_WIDGET (f
))
4252 if (INTEGERP (Vtool_bar_button_margin
)
4253 && XINT (Vtool_bar_button_margin
) > 0)
4255 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4256 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4258 else if (CONSP (Vtool_bar_button_margin
))
4260 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
4261 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
4262 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4264 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
4265 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
4266 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4269 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4270 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4271 i.e. zero. This means that margins less than
4272 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4273 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4274 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4276 if (! x
->toolbar_widget
)
4277 xg_create_tool_bar (f
);
4279 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4280 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4282 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4284 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4285 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4289 struct image
*img
= NULL
;
4291 Lisp_Object stock
= Qnil
;
4292 GtkStockItem stock_item
;
4293 char *stock_name
= NULL
;
4294 char *icon_name
= NULL
;
4296 GtkWidget
*wbutton
= NULL
;
4297 GtkWidget
*weventbox
;
4298 Lisp_Object specified_file
;
4299 const char *label
= (STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4300 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
)) : "");
4302 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), i
);
4306 weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
4307 wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
4311 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4313 /* Ignore invalid image specifications. */
4314 if (!valid_image_p (image
))
4316 if (wbutton
) gtk_widget_hide (wbutton
);
4320 specified_file
= file_for_image (image
);
4321 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4322 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4324 if (STRINGP (stock
))
4326 stock_name
= SSDATA (stock
);
4327 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4329 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4330 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4332 icon_name
= stock_name
+ 2;
4336 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4339 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4341 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4342 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4350 if (stock_name
== NULL
&& icon_name
== NULL
)
4352 /* No stock image, or stock item not known. Try regular image. */
4354 /* If image is a vector, choose the image according to the
4356 if (dir
== GTK_TEXT_DIR_RTL
4357 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4360 image
= find_rtl_image (f
, image
, rtl
);
4363 if (VECTORP (image
))
4367 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4368 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4371 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4372 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4374 xassert (ASIZE (image
) >= idx
);
4375 image
= AREF (image
, idx
);
4380 img_id
= lookup_image (f
, image
);
4381 img
= IMAGE_FROM_ID (f
, img_id
);
4382 prepare_image_for_display (f
, img
);
4384 if (img
->load_failed_p
|| img
->pixmap
== None
)
4387 gtk_widget_hide_all (GTK_WIDGET (ti
));
4390 /* Insert an empty (non-image) button */
4391 ti
= xg_make_tool_item (f
, NULL
, NULL
, "", i
);
4392 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, -1);
4403 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4404 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4405 (gpointer
) xstrdup (stock_name
),
4406 (GDestroyNotify
) xfree
);
4410 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4411 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4412 (gpointer
) xstrdup (icon_name
),
4413 (GDestroyNotify
) xfree
);
4417 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4418 /* Save the image so we can see if an update is needed when
4419 this function is called again. */
4420 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4421 (gpointer
)img
->pixmap
);
4424 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4425 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
);
4426 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, -1);
4427 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4431 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
4433 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4435 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
4436 XG_TOOL_BAR_IMAGE_DATA
);
4437 gpointer old_stock_name
= g_object_get_data (G_OBJECT (wimage
),
4438 XG_TOOL_BAR_STOCK_NAME
);
4439 gpointer old_icon_name
= g_object_get_data (G_OBJECT (wimage
),
4440 XG_TOOL_BAR_ICON_NAME
);
4441 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4443 (! old_stock_name
|| strcmp (old_stock_name
, stock_name
) != 0))
4445 gtk_image_set_from_stock (GTK_IMAGE (wimage
),
4446 stock_name
, icon_size
);
4447 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4448 (gpointer
) xstrdup (stock_name
),
4449 (GDestroyNotify
) xfree
);
4450 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4452 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4455 else if (icon_name
&&
4456 (! old_icon_name
|| strcmp (old_icon_name
, icon_name
) != 0))
4458 gtk_image_set_from_icon_name (GTK_IMAGE (wimage
),
4459 icon_name
, icon_size
);
4460 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4461 (gpointer
) xstrdup (icon_name
),
4462 (GDestroyNotify
) xfree
);
4463 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4465 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4468 else if (img
&& old_img
!= img
->pixmap
)
4470 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
,
4471 GTK_IMAGE (wimage
));
4472 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4473 (gpointer
)img
->pixmap
);
4475 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4477 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4481 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
4483 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4485 xg_show_toolbar_item (ti
);
4490 /* Remove buttons not longer needed. We just hide them so they
4491 can be reused later on. */
4494 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), i
++);
4495 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
4496 } while (ti
!= NULL
);
4498 if (f
->n_tool_bar_items
!= 0)
4501 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4502 gtk_widget_show (x
->toolbar_widget
);
4503 gtk_widget_show (x
->handlebox_widget
);
4504 if (xg_update_tool_bar_sizes (f
))
4505 xg_height_or_width_changed (f
);
4511 /* Deallocate all resources for the tool bar on frame F.
4512 Remove the tool bar. */
4515 free_frame_tool_bar (FRAME_PTR f
)
4517 struct x_output
*x
= f
->output_data
.x
;
4519 if (x
->toolbar_widget
)
4521 int is_packed
= x
->handlebox_widget
!= 0;
4523 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4524 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4527 if (x
->toolbar_in_hbox
)
4528 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4529 x
->handlebox_widget
);
4531 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4532 x
->handlebox_widget
);
4535 gtk_widget_destroy (x
->toolbar_widget
);
4537 x
->toolbar_widget
= 0;
4538 x
->handlebox_widget
= 0;
4539 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4540 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4542 xg_height_or_width_changed (f
);
4549 xg_change_toolbar_position (FRAME_PTR f
, Lisp_Object pos
)
4551 struct x_output
*x
= f
->output_data
.x
;
4553 if (! x
->toolbar_widget
|| ! x
->handlebox_widget
)
4557 g_object_ref (x
->handlebox_widget
);
4558 if (x
->toolbar_in_hbox
)
4559 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4560 x
->handlebox_widget
);
4562 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4563 x
->handlebox_widget
);
4564 xg_pack_tool_bar (f
, pos
);
4565 g_object_unref (x
->handlebox_widget
);
4566 if (xg_update_tool_bar_sizes (f
))
4567 xg_height_or_width_changed (f
);
4575 /***********************************************************************
4577 ***********************************************************************/
4579 xg_initialize (void)
4581 GtkBindingSet
*binding_set
;
4584 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4585 we keep it permanently linked in. */
4590 xg_ignore_gtk_scrollbar
= 0;
4591 xg_detached_menus
= 0;
4592 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4593 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4595 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4596 id_to_widget
.widgets
= 0;
4598 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4599 bindings. It doesn't seem to be any way to remove properties,
4600 so we set it to VoidSymbol which in X means "no key". */
4601 gtk_settings_set_string_property (gtk_settings_get_default (),
4602 "gtk-menu-bar-accel",
4606 /* Make GTK text input widgets use Emacs style keybindings. This is
4608 gtk_settings_set_string_property (gtk_settings_get_default (),
4609 "gtk-key-theme-name",
4613 /* Make dialogs close on C-g. Since file dialog inherits from
4614 dialog, this works for them also. */
4615 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4616 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4619 /* Make menus close on C-g. */
4620 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4621 (GTK_TYPE_MENU_SHELL
));
4622 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4626 #endif /* USE_GTK */
4628 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
4629 (do not change this comment) */