1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2011 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
28 #include "blockinput.h"
29 #include "syssignal.h"
32 #include "termhooks.h"
36 #include <gdk/gdkkeysyms.h>
37 #include "xsettings.h"
40 #include <X11/Xft/Xft.h>
43 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
44 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
46 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
47 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
49 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
50 #define gtk_widget_set_has_window(w, b) \
51 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
53 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
54 #define gtk_dialog_get_action_area(w) ((w)->action_area)
55 #define gtk_dialog_get_content_area(w) ((w)->vbox)
57 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
58 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
60 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
61 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
62 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
63 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
64 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
66 #if GTK_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 11
67 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
69 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
72 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
75 /***********************************************************************
76 Display handling functions
77 ***********************************************************************/
79 /* Keep track of the default display, or NULL if there is none. Emacs
80 may close all its displays. */
82 static GdkDisplay
*gdpy_def
;
84 /* When the GTK widget W is to be created on a display for F that
85 is not the default display, set the display for W.
86 W can be a GtkMenu or a GtkWindow widget. */
89 xg_set_screen (GtkWidget
*w
, FRAME_PTR f
)
91 if (FRAME_X_DISPLAY (f
) != GDK_DISPLAY ())
93 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
94 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
97 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
99 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
104 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
105 *DPY is set to NULL if the display can't be opened.
107 Returns non-zero if display could be opened, zero if display could not
108 be opened, and less than zero if the GTK version doesn't support
112 xg_display_open (char *display_name
, Display
**dpy
)
116 gdpy
= gdk_display_open (display_name
);
117 if (!gdpy_def
&& gdpy
)
120 gdk_display_manager_set_default_display (gdk_display_manager_get (),
124 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
128 /* Close display DPY. */
131 xg_display_close (Display
*dpy
)
133 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
135 /* If this is the default display, try to change it before closing.
136 If there is no other display to use, gdpy_def is set to NULL, and
137 the next call to xg_display_open resets the default display. */
138 if (gdk_display_get_default () == gdpy
)
140 struct x_display_info
*dpyinfo
;
141 GdkDisplay
*gdpy_new
= NULL
;
143 /* Find another display. */
144 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
145 if (dpyinfo
->display
!= dpy
)
147 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
148 gdk_display_manager_set_default_display (gdk_display_manager_get (),
155 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
156 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
157 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
158 can continue running, but there will be memory leaks. */
159 g_object_run_dispose (G_OBJECT (gdpy
));
161 /* This seems to be fixed in GTK 2.10. */
162 gdk_display_close (gdpy
);
167 /***********************************************************************
169 ***********************************************************************/
170 /* The next two variables and functions are taken from lwlib. */
171 static widget_value
*widget_value_free_list
;
172 static int malloc_cpt
;
174 /* Allocate a widget_value structure, either by taking one from the
175 widget_value_free_list or by malloc:ing a new one.
177 Return a pointer to the allocated structure. */
180 malloc_widget_value (void)
183 if (widget_value_free_list
)
185 wv
= widget_value_free_list
;
186 widget_value_free_list
= wv
->free_list
;
191 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
194 memset (wv
, 0, sizeof (widget_value
));
198 /* This is analogous to free. It frees only what was allocated
199 by malloc_widget_value, and no substructures. */
202 free_widget_value (widget_value
*wv
)
209 /* When the number of already allocated cells is too big,
216 wv
->free_list
= widget_value_free_list
;
217 widget_value_free_list
= wv
;
222 /* Create and return the cursor to be used for popup menus and
223 scroll bars on display DPY. */
226 xg_create_default_cursor (Display
*dpy
)
228 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
229 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
232 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
235 xg_get_pixbuf_from_pix_and_mask (GdkPixmap
*gpix
,
240 GdkPixbuf
*icon_buf
, *tmp_buf
;
242 gdk_drawable_get_size (gpix
, &width
, &height
);
243 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
244 0, 0, 0, 0, width
, height
);
245 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
246 g_object_unref (G_OBJECT (tmp_buf
));
250 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
255 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
256 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
257 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
258 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
261 for (y
= 0; y
< height
; ++y
)
263 guchar
*iconptr
, *maskptr
;
266 iconptr
= pixels
+ y
* rowstride
;
267 maskptr
= mask_pixels
+ y
* mask_rowstride
;
269 for (x
= 0; x
< width
; ++x
)
271 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
272 just R is sufficient. */
274 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
276 iconptr
+= rowstride
/width
;
277 maskptr
+= mask_rowstride
/width
;
281 g_object_unref (G_OBJECT (mask_buf
));
288 file_for_image (Lisp_Object image
)
290 Lisp_Object specified_file
= Qnil
;
293 for (tail
= XCDR (image
);
294 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
295 tail
= XCDR (XCDR (tail
)))
296 if (EQ (XCAR (tail
), QCfile
))
297 specified_file
= XCAR (XCDR (tail
));
299 return specified_file
;
302 /* For the image defined in IMG, make and return a GtkImage. For displays with
303 8 planes or less we must make a GdkPixbuf and apply the mask manually.
304 Otherwise the highlightning and dimming the tool bar code in GTK does
305 will look bad. For display with more than 8 planes we just use the
306 pixmap and mask directly. For monochrome displays, GTK doesn't seem
307 able to use external pixmaps, it looks bad whatever we do.
308 The image is defined on the display where frame F is.
309 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
310 If OLD_WIDGET is NULL, a new widget is constructed and returned.
311 If OLD_WIDGET is not NULL, that widget is modified. */
314 xg_get_image_for_pixmap (FRAME_PTR f
,
317 GtkImage
*old_widget
)
325 /* If we have a file, let GTK do all the image handling.
326 This seems to be the only way to make insensitive and activated icons
327 look good in all cases. */
328 Lisp_Object specified_file
= file_for_image (img
->spec
);
331 /* We already loaded the image once before calling this
332 function, so this only fails if the image file has been removed.
333 In that case, use the pixmap already loaded. */
335 if (STRINGP (specified_file
)
336 && STRINGP (file
= x_find_image_file (specified_file
)))
339 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
341 gtk_image_set_from_file (old_widget
, SSDATA (file
));
343 return GTK_WIDGET (old_widget
);
346 /* No file, do the image handling ourselves. This will look very bad
347 on a monochrome display, and sometimes bad on all displays with
350 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
351 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
352 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
354 /* This is a workaround to make icons look good on pseudo color
355 displays. Apparently GTK expects the images to have an alpha
356 channel. If they don't, insensitive and activated icons will
357 look bad. This workaround does not work on monochrome displays,
358 and is strictly not needed on true color/static color displays (i.e.
359 16 bits and higher). But we do it anyway so we get a pixbuf that is
360 not associated with the img->pixmap. The img->pixmap may be removed
361 by clearing the image cache and then the tool bar redraw fails, since
362 Gtk+ assumes the pixmap is always there. */
363 cmap
= gtk_widget_get_colormap (widget
);
364 icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
367 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
369 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
371 g_object_unref (G_OBJECT (icon_buf
));
373 g_object_unref (G_OBJECT (gpix
));
374 if (gmask
) g_object_unref (G_OBJECT (gmask
));
376 return GTK_WIDGET (old_widget
);
380 /* Set CURSOR on W and all widgets W contain. We must do like this
381 for scroll bars and menu because they create widgets internally,
382 and it is those widgets that are visible. */
385 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
387 GdkWindow
*window
= gtk_widget_get_window(w
);
388 GList
*children
= gdk_window_peek_children (window
);
390 gdk_window_set_cursor (window
, cursor
);
392 /* The scroll bar widget has more than one GDK window (had to look at
393 the source to figure this out), and there is no way to set cursor
394 on widgets in GTK. So we must set the cursor for all GDK windows.
397 for ( ; children
; children
= g_list_next (children
))
398 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
401 /* Insert NODE into linked LIST. */
404 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
406 xg_list_node
*list_start
= list
->next
;
408 if (list_start
) list_start
->prev
= node
;
409 node
->next
= list_start
;
414 /* Remove NODE from linked LIST. */
417 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
419 xg_list_node
*list_start
= list
->next
;
420 if (node
== list_start
)
422 list
->next
= node
->next
;
423 if (list
->next
) list
->next
->prev
= 0;
427 node
->prev
->next
= node
->next
;
428 if (node
->next
) node
->next
->prev
= node
->prev
;
432 /* Allocate and return a utf8 version of STR. If STR is already
433 utf8 or NULL, just return a copy of STR.
434 A new string is allocated and the caller must free the result
438 get_utf8_string (const char *str
)
442 if (!str
) return NULL
;
444 /* If not UTF-8, try current locale. */
445 if (!g_utf8_validate (str
, -1, NULL
))
446 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
448 return g_strdup (str
);
452 /* Probably some control characters in str. Escape them. */
456 unsigned char *p
= (unsigned char *)str
;
458 GError
*error
= NULL
;
460 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
461 &bytes_written
, &error
))
462 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
465 p
+= bytes_written
+1;
466 g_error_free (error
);
472 g_error_free (error
);
477 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
478 p
= (unsigned char *)str
;
480 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
481 &bytes_written
, &error
))
482 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
484 strncpy (up
, (char *)p
, bytes_written
);
485 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
486 up
[bytes_written
+4] = '\0';
487 up
+= bytes_written
+4;
488 p
+= bytes_written
+1;
489 g_error_free (error
);
495 strcat (utf8_str
, cp
);
500 g_error_free (error
);
507 /* Check for special colors used in face spec for region face.
508 The colors are fetched from the Gtk+ theme.
509 Return 1 if color was found, 0 if not. */
512 xg_check_special_colors (struct frame
*f
,
513 const char *color_name
,
517 if (FRAME_GTK_WIDGET (f
))
519 if (strcmp ("gtk_selection_bg_color", color_name
) == 0)
521 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
522 color
->red
= gsty
->bg
[GTK_STATE_SELECTED
].red
;
523 color
->green
= gsty
->bg
[GTK_STATE_SELECTED
].green
;
524 color
->blue
= gsty
->bg
[GTK_STATE_SELECTED
].blue
;
525 color
->pixel
= gsty
->bg
[GTK_STATE_SELECTED
].pixel
;
528 else if (strcmp ("gtk_selection_fg_color", color_name
) == 0)
530 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
531 color
->red
= gsty
->fg
[GTK_STATE_SELECTED
].red
;
532 color
->green
= gsty
->fg
[GTK_STATE_SELECTED
].green
;
533 color
->blue
= gsty
->fg
[GTK_STATE_SELECTED
].blue
;
534 color
->pixel
= gsty
->fg
[GTK_STATE_SELECTED
].pixel
;
544 /***********************************************************************
546 ***********************************************************************/
547 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
548 We use that to pop down the tooltip. This happens if Gtk+ for some
549 reason wants to change or hide the tooltip. */
551 #ifdef USE_GTK_TOOLTIP
554 hierarchy_ch_cb (GtkWidget
*widget
,
555 GtkWidget
*previous_toplevel
,
558 FRAME_PTR f
= (FRAME_PTR
) user_data
;
559 struct x_output
*x
= f
->output_data
.x
;
560 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
562 if (! top
|| ! GTK_IS_WINDOW (top
))
563 gtk_widget_hide (previous_toplevel
);
566 /* Callback called when Gtk+ thinks a tooltip should be displayed.
567 We use it to get the tooltip window and the tooltip widget so
568 we can manipulate the ourselves.
570 Return FALSE ensures that the tooltip is not shown. */
573 qttip_cb (GtkWidget
*widget
,
576 gboolean keyboard_mode
,
580 FRAME_PTR f
= (FRAME_PTR
) user_data
;
581 struct x_output
*x
= f
->output_data
.x
;
582 if (x
->ttip_widget
== NULL
)
584 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
585 x
->ttip_widget
= tooltip
;
586 g_object_ref (G_OBJECT (tooltip
));
587 x
->ttip_lbl
= gtk_label_new ("");
588 g_object_ref (G_OBJECT (x
->ttip_lbl
));
589 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
590 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
591 /* ATK needs an empty title for some reason. */
592 gtk_window_set_title (x
->ttip_window
, "");
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. */
964 xg_create_frame_widgets (FRAME_PTR f
)
967 GtkWidget
*wvbox
, *whbox
;
975 if (FRAME_X_EMBEDDED_P (f
))
976 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
978 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
980 xg_set_screen (wtop
, f
);
982 wvbox
= gtk_vbox_new (FALSE
, 0);
983 whbox
= gtk_hbox_new (FALSE
, 0);
984 f
->gwfixed
= wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
986 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
988 if (wtop
) gtk_widget_destroy (wtop
);
989 if (wvbox
) gtk_widget_destroy (wvbox
);
990 if (whbox
) gtk_widget_destroy (whbox
);
991 if (wfixed
) gtk_widget_destroy (wfixed
);
997 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
998 gtk_widget_set_name (wtop
, EMACS_CLASS
);
999 gtk_widget_set_name (wvbox
, "pane");
1000 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1002 /* If this frame has a title or name, set it in the title bar. */
1003 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1004 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1006 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1008 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1009 FRAME_GTK_WIDGET (f
) = wfixed
;
1010 f
->output_data
.x
->vbox_widget
= wvbox
;
1011 f
->output_data
.x
->hbox_widget
= whbox
;
1013 gtk_widget_set_has_window (wfixed
, TRUE
);
1015 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1016 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1017 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1019 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1020 update_frame_tool_bar (f
);
1022 /* We don't want this widget double buffered, because we draw on it
1023 with regular X drawing primitives, so from a GTK/GDK point of
1024 view, the widget is totally blank. When an expose comes, this
1025 will make the widget blank, and then Emacs redraws it. This flickers
1026 a lot, so we turn off double buffering. */
1027 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1029 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1030 SSDATA (Vx_resource_name
),
1031 SSDATA (Vx_resource_class
));
1033 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1034 GTK is to destroy the widget. We want Emacs to do that instead. */
1035 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1036 G_CALLBACK (gtk_true
), 0);
1038 /* Convert our geometry parameters into a geometry string
1040 GTK will itself handle calculating the real position this way. */
1041 xg_set_geometry (f
);
1043 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1045 gtk_widget_add_events (wfixed
,
1046 GDK_POINTER_MOTION_MASK
1048 | GDK_BUTTON_PRESS_MASK
1049 | GDK_BUTTON_RELEASE_MASK
1050 | GDK_KEY_PRESS_MASK
1051 | GDK_ENTER_NOTIFY_MASK
1052 | GDK_LEAVE_NOTIFY_MASK
1053 | GDK_FOCUS_CHANGE_MASK
1054 | GDK_STRUCTURE_MASK
1055 | GDK_VISIBILITY_NOTIFY_MASK
);
1057 /* Must realize the windows so the X window gets created. It is used
1058 by callers of this function. */
1059 gtk_widget_realize (wfixed
);
1060 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1062 /* Since GTK clears its window by filling with the background color,
1063 we must keep X and GTK background in sync. */
1064 xg_pix_to_gcolor (wfixed
, FRAME_BACKGROUND_PIXEL (f
), &bg
);
1065 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
1067 /* Also, do not let any background pixmap to be set, this looks very
1068 bad as Emacs overwrites the background pixmap with its own idea
1069 of background color. */
1070 style
= gtk_widget_get_modifier_style (wfixed
);
1072 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1073 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1074 gtk_widget_modify_style (wfixed
, style
);
1076 #ifdef USE_GTK_TOOLTIP
1077 /* Steal a tool tip window we can move ourselves. */
1078 f
->output_data
.x
->ttip_widget
= 0;
1079 f
->output_data
.x
->ttip_lbl
= 0;
1080 f
->output_data
.x
->ttip_window
= 0;
1081 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1082 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1086 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1087 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1088 /* Only connect this signal once per screen. */
1089 if (! g_signal_handler_find (G_OBJECT (gs
),
1090 G_SIGNAL_MATCH_FUNC
,
1092 G_CALLBACK (style_changed_cb
),
1095 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1096 G_CALLBACK (style_changed_cb
),
1097 gdk_screen_get_display (screen
));
1107 xg_free_frame_widgets (FRAME_PTR f
)
1109 if (FRAME_GTK_OUTER_WIDGET (f
))
1111 struct x_output
*x
= f
->output_data
.x
;
1112 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1113 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1114 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1115 #ifdef USE_GTK_TOOLTIP
1117 gtk_widget_destroy (x
->ttip_lbl
);
1119 g_object_unref (G_OBJECT (x
->ttip_widget
));
1124 /* Set the normal size hints for the window manager, for frame F.
1125 FLAGS is the flags word to use--or 0 meaning preserve the flags
1126 that the window now has.
1127 If USER_POSITION is nonzero, we set the User Position
1128 flag (this is useful when FLAGS is 0). */
1131 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
1133 /* Must use GTK routines here, otherwise GTK resets the size hints
1134 to its own defaults. */
1135 GdkGeometry size_hints
;
1136 gint hint_flags
= 0;
1137 int base_width
, base_height
;
1138 int min_rows
= 0, min_cols
= 0;
1139 int win_gravity
= f
->win_gravity
;
1141 /* Don't set size hints during initialization; that apparently leads
1142 to a race condition. See the thread at
1143 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1144 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1149 memset (&size_hints
, 0, sizeof (size_hints
));
1150 f
->output_data
.x
->size_hints
= size_hints
;
1151 f
->output_data
.x
->hint_flags
= hint_flags
;
1154 flags
= f
->size_hint_flags
;
1156 size_hints
= f
->output_data
.x
->size_hints
;
1157 hint_flags
= f
->output_data
.x
->hint_flags
;
1159 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1160 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1161 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1163 hint_flags
|= GDK_HINT_BASE_SIZE
;
1164 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0) + FRAME_TOOLBAR_WIDTH (f
);
1165 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
1166 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1168 check_frame_size (f
, &min_rows
, &min_cols
);
1170 size_hints
.base_width
= base_width
;
1171 size_hints
.base_height
= base_height
;
1172 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1173 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1175 /* These currently have a one to one mapping with the X values, but I
1176 don't think we should rely on that. */
1177 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1178 size_hints
.win_gravity
= 0;
1179 if (win_gravity
== NorthWestGravity
)
1180 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1181 else if (win_gravity
== NorthGravity
)
1182 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1183 else if (win_gravity
== NorthEastGravity
)
1184 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1185 else if (win_gravity
== WestGravity
)
1186 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1187 else if (win_gravity
== CenterGravity
)
1188 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1189 else if (win_gravity
== EastGravity
)
1190 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1191 else if (win_gravity
== SouthWestGravity
)
1192 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1193 else if (win_gravity
== SouthGravity
)
1194 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1195 else if (win_gravity
== SouthEastGravity
)
1196 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1197 else if (win_gravity
== StaticGravity
)
1198 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1202 hint_flags
&= ~GDK_HINT_POS
;
1203 hint_flags
|= GDK_HINT_USER_POS
;
1206 if (hint_flags
!= f
->output_data
.x
->hint_flags
1207 || memcmp (&size_hints
,
1208 &f
->output_data
.x
->size_hints
,
1209 sizeof (size_hints
)) != 0)
1212 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1213 NULL
, &size_hints
, hint_flags
);
1214 f
->output_data
.x
->size_hints
= size_hints
;
1215 f
->output_data
.x
->hint_flags
= hint_flags
;
1220 /* Change background color of a frame.
1221 Since GTK uses the background color to clear the window, we must
1222 keep the GTK and X colors in sync.
1223 F is the frame to change,
1224 BG is the pixel value to change to. */
1227 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
1229 if (FRAME_GTK_WIDGET (f
))
1234 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
1235 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
1241 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1242 functions so GTK does not overwrite the icon. */
1245 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1247 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1248 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
1249 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
1250 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
1252 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1257 /***********************************************************************
1259 ***********************************************************************/
1260 /* Return the dialog title to use for a dialog of type KEY.
1261 This is the encoding used by lwlib. We use the same for GTK. */
1264 get_dialog_title (char key
)
1266 const char *title
= "";
1274 title
= "Information";
1293 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1294 the dialog, but return TRUE so the event does not propagate further
1295 in GTK. This prevents GTK from destroying the dialog widget automatically
1296 and we can always destrou the widget manually, regardles of how
1297 it was popped down (button press or WM_DELETE_WINDOW).
1298 W is the dialog widget.
1299 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1300 user_data is NULL (not used).
1302 Returns TRUE to end propagation of event. */
1305 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1307 gtk_widget_unmap (w
);
1311 /* Create a popup dialog window. See also xg_create_widget below.
1312 WV is a widget_value describing the dialog.
1313 SELECT_CB is the callback to use when a button has been pressed.
1314 DEACTIVATE_CB is the callback to use when the dialog pops down.
1316 Returns the GTK dialog widget. */
1319 create_dialog (widget_value
*wv
,
1320 GCallback select_cb
,
1321 GCallback deactivate_cb
)
1323 const char *title
= get_dialog_title (wv
->name
[0]);
1324 int total_buttons
= wv
->name
[1] - '0';
1325 int right_buttons
= wv
->name
[4] - '0';
1328 int button_spacing
= 10;
1329 GtkWidget
*wdialog
= gtk_dialog_new ();
1330 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1331 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1334 GtkWidget
*whbox_up
;
1335 GtkWidget
*whbox_down
;
1337 /* If the number of buttons is greater than 4, make two rows of buttons
1338 instead. This looks better. */
1339 int make_two_rows
= total_buttons
> 4;
1341 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1342 left_buttons
= total_buttons
- right_buttons
;
1344 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1345 gtk_widget_set_name (wdialog
, "emacs-dialog");
1350 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1351 whbox_up
= gtk_hbox_new (FALSE
, 0);
1352 whbox_down
= gtk_hbox_new (FALSE
, 0);
1354 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1355 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1356 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1358 cur_box
= GTK_BOX (whbox_up
);
1361 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1362 G_CALLBACK (dialog_delete_callback
), 0);
1366 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1367 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1370 for (item
= wv
->contents
; item
; item
= item
->next
)
1372 char *utf8_label
= get_utf8_string (item
->value
);
1376 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1378 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1379 /* This is the text part of the dialog. */
1380 w
= gtk_label_new (utf8_label
);
1381 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1382 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1383 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1385 /* Try to make dialog look better. Must realize first so
1386 the widget can calculate the size it needs. */
1387 gtk_widget_realize (w
);
1388 gtk_widget_size_request (w
, &req
);
1389 gtk_box_set_spacing (wvbox
, req
.height
);
1390 if (item
->value
&& strlen (item
->value
) > 0)
1391 button_spacing
= 2*req
.width
/strlen (item
->value
);
1395 /* This is one button to add to the dialog. */
1396 w
= gtk_button_new_with_label (utf8_label
);
1397 if (! item
->enabled
)
1398 gtk_widget_set_sensitive (w
, FALSE
);
1400 g_signal_connect (G_OBJECT (w
), "clicked",
1401 select_cb
, item
->call_data
);
1403 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1404 if (++button_nr
== left_buttons
)
1407 cur_box
= GTK_BOX (whbox_down
);
1409 gtk_box_pack_start (cur_box
,
1417 g_free (utf8_label
);
1423 struct xg_dialog_data
1431 /* Function that is called when the file or font dialogs pop down.
1432 W is the dialog widget, RESPONSE is the response code.
1433 USER_DATA is what we passed in to g_signal_connect. */
1436 xg_dialog_response_cb (GtkDialog
*w
,
1440 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1441 dd
->response
= response
;
1442 g_main_loop_quit (dd
->loop
);
1446 /* Destroy the dialog. This makes it pop down. */
1449 pop_down_dialog (Lisp_Object arg
)
1451 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1452 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1455 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1456 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1458 g_main_loop_quit (dd
->loop
);
1459 g_main_loop_unref (dd
->loop
);
1466 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1467 We pass in DATA as gpointer* so we can use this as a callback. */
1470 xg_maybe_add_timer (gpointer data
)
1472 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1473 EMACS_TIME next_time
= timer_check (1);
1474 long secs
= EMACS_SECS (next_time
);
1475 long usecs
= EMACS_USECS (next_time
);
1479 if (secs
>= 0 && usecs
>= 0 && secs
< ((guint
)-1)/1000)
1481 dd
->timerid
= g_timeout_add (secs
* 1000 + usecs
/1000,
1489 /* Pops up a modal dialog W and waits for response.
1490 We don't use gtk_dialog_run because we want to process emacs timers.
1491 The dialog W is not destroyed when this function returns. */
1494 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1496 int count
= SPECPDL_INDEX ();
1497 struct xg_dialog_data dd
;
1499 xg_set_screen (w
, f
);
1500 gtk_window_set_transient_for (GTK_WINDOW (w
),
1501 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1502 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1503 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1505 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1506 dd
.response
= GTK_RESPONSE_CANCEL
;
1510 g_signal_connect (G_OBJECT (w
),
1512 G_CALLBACK (xg_dialog_response_cb
),
1514 /* Don't destroy the widget if closed by the window manager close button. */
1515 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1516 gtk_widget_show (w
);
1518 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1520 (void) xg_maybe_add_timer (&dd
);
1521 g_main_loop_run (dd
.loop
);
1524 unbind_to (count
, Qnil
);
1530 /***********************************************************************
1531 File dialog functions
1532 ***********************************************************************/
1533 /* Return non-zero if the old file selection dialog is being used.
1534 Return zero if not. */
1537 xg_uses_old_file_dialog (void)
1539 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1540 return x_gtk_use_old_file_dialog
;
1547 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1549 /* Return the selected file for file chooser dialog W.
1550 The returned string must be free:d. */
1553 xg_get_file_name_from_chooser (GtkWidget
*w
)
1555 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1558 /* Callback called when the "Show hidden files" toggle is pressed.
1559 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1562 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1564 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1566 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1567 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1571 /* Callback called when a property changes in a file chooser.
1572 GOBJECT is the file chooser dialog, ARG1 describes the property.
1573 USER_DATA is the toggle widget in the file chooser dialog.
1574 We use this to update the "Show hidden files" toggle when the user
1575 changes that property by right clicking in the file list. */
1578 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1580 if (strcmp (arg1
->name
, "show-hidden") == 0)
1582 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1583 gboolean visible
, toggle_on
;
1585 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1586 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1588 if (!!visible
!= !!toggle_on
)
1590 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1591 G_CALLBACK (xg_toggle_visibility_cb
),
1593 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1594 g_signal_handlers_unblock_by_func
1595 (G_OBJECT (wtoggle
),
1596 G_CALLBACK (xg_toggle_visibility_cb
),
1599 x_gtk_show_hidden_files
= visible
;
1603 /* Read a file name from the user using a file chooser dialog.
1604 F is the current frame.
1605 PROMPT is a prompt to show to the user. May not be NULL.
1606 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1607 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1608 file. *FUNC is set to a function that can be used to retrieve the
1609 selected file name from the returned widget.
1611 Returns the created widget. */
1614 xg_get_file_with_chooser (FRAME_PTR f
,
1616 char *default_filename
,
1617 int mustmatch_p
, int only_dir_p
,
1618 xg_get_file_func
*func
)
1622 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1623 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1624 GtkFileChooserAction action
= (mustmatch_p
?
1625 GTK_FILE_CHOOSER_ACTION_OPEN
:
1626 GTK_FILE_CHOOSER_ACTION_SAVE
);
1629 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1631 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1632 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1633 (mustmatch_p
|| only_dir_p
?
1634 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1637 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1639 wbox
= gtk_vbox_new (FALSE
, 0);
1640 gtk_widget_show (wbox
);
1641 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1643 if (x_gtk_show_hidden_files
)
1645 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1646 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1648 gtk_widget_show (wtoggle
);
1649 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1650 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1651 g_signal_connect (G_OBJECT (filewin
), "notify",
1652 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1654 if (x_gtk_file_dialog_help_text
)
1657 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1658 Show the C-l help text only for versions < 2.10. */
1659 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1660 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1661 strcat (message
, "\nIf you don't like this file selector, use the "
1662 "corresponding\nkey binding or customize "
1663 "use-file-dialog to turn it off.");
1665 wmessage
= gtk_label_new (message
);
1666 gtk_widget_show (wmessage
);
1669 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1670 if (x_gtk_file_dialog_help_text
)
1671 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1672 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1674 if (default_filename
)
1677 struct gcpro gcpro1
;
1678 char *utf8_filename
;
1681 file
= build_string (default_filename
);
1683 /* File chooser does not understand ~/... in the file name. It must be
1684 an absolute name starting with /. */
1685 if (default_filename
[0] != '/')
1686 file
= Fexpand_file_name (file
, Qnil
);
1688 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1689 if (! NILP (Ffile_directory_p (file
)))
1690 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1694 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1696 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1698 char *cp
= strrchr (utf8_filename
, '/');
1700 else cp
= utf8_filename
;
1701 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1708 *func
= xg_get_file_name_from_chooser
;
1712 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1714 /* Return the selected file for file selector dialog W.
1715 The returned string must be free:d. */
1718 xg_get_file_name_from_selector (GtkWidget
*w
)
1720 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1721 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1724 /* Create a file selection dialog.
1725 F is the current frame.
1726 PROMPT is a prompt to show to the user. May not be NULL.
1727 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1728 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1729 file. *FUNC is set to a function that can be used to retrieve the
1730 selected file name from the returned widget.
1732 Returns the created widget. */
1735 xg_get_file_with_selection (FRAME_PTR f
,
1737 char *default_filename
,
1738 int mustmatch_p
, int only_dir_p
,
1739 xg_get_file_func
*func
)
1742 GtkFileSelection
*filesel
;
1744 filewin
= gtk_file_selection_new (prompt
);
1745 filesel
= GTK_FILE_SELECTION (filewin
);
1747 if (default_filename
)
1748 gtk_file_selection_set_filename (filesel
, default_filename
);
1752 /* The selection_entry part of filesel is not documented. */
1753 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1754 gtk_file_selection_hide_fileop_buttons (filesel
);
1757 *func
= xg_get_file_name_from_selector
;
1761 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1763 /* Read a file name from the user using a file dialog, either the old
1764 file selection dialog, or the new file chooser dialog. Which to use
1765 depends on what the GTK version used has, and what the value of
1766 gtk-use-old-file-dialog.
1767 F is the current frame.
1768 PROMPT is a prompt to show to the user. May not be NULL.
1769 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1770 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1773 Returns a file name or NULL if no file was selected.
1774 The returned string must be freed by the caller. */
1777 xg_get_file_name (FRAME_PTR f
,
1779 char *default_filename
,
1785 int filesel_done
= 0;
1786 xg_get_file_func func
;
1788 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1789 /* I really don't know why this is needed, but without this the GLIBC add on
1790 library linuxthreads hangs when the Gnome file chooser backend creates
1792 sigblock (sigmask (__SIGRTMIN
));
1793 #endif /* HAVE_GTK_AND_PTHREAD */
1795 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1797 if (xg_uses_old_file_dialog ())
1798 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1799 mustmatch_p
, only_dir_p
, &func
);
1801 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1802 mustmatch_p
, only_dir_p
, &func
);
1804 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1805 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1806 mustmatch_p
, only_dir_p
, &func
);
1807 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1809 gtk_widget_set_name (w
, "emacs-filedialog");
1811 filesel_done
= xg_dialog_run (f
, w
);
1813 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1814 sigunblock (sigmask (__SIGRTMIN
));
1817 if (filesel_done
== GTK_RESPONSE_OK
)
1820 gtk_widget_destroy (w
);
1824 #ifdef HAVE_FREETYPE
1825 /* Pop up a GTK font selector and return the name of the font the user
1826 selects, as a C string. The returned font name follows GTK's own
1829 `FAMILY [VALUE1 VALUE2] SIZE'
1831 This can be parsed using font_parse_fcname in font.c.
1832 DEFAULT_NAME, if non-zero, is the default font name. */
1835 xg_get_font_name (FRAME_PTR f
, const char *default_name
)
1838 char *fontname
= NULL
;
1841 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1842 sigblock (sigmask (__SIGRTMIN
));
1843 #endif /* HAVE_GTK_AND_PTHREAD */
1845 w
= gtk_font_selection_dialog_new ("Pick a font");
1847 default_name
= "Monospace 10";
1848 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1851 gtk_widget_set_name (w
, "emacs-fontdialog");
1853 done
= xg_dialog_run (f
, w
);
1855 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1856 sigunblock (sigmask (__SIGRTMIN
));
1859 if (done
== GTK_RESPONSE_OK
)
1860 fontname
= gtk_font_selection_dialog_get_font_name
1861 (GTK_FONT_SELECTION_DIALOG (w
));
1863 gtk_widget_destroy (w
);
1866 #endif /* HAVE_FREETYPE */
1870 /***********************************************************************
1872 ***********************************************************************/
1874 /* The name of menu items that can be used for customization. Since GTK
1875 RC files are very crude and primitive, we have to set this on all
1876 menu item names so a user can easily customize menu items. */
1878 #define MENU_ITEM_NAME "emacs-menuitem"
1881 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1882 during GC. The next member points to the items. */
1883 static xg_list_node xg_menu_cb_list
;
1885 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1886 during GC. The next member points to the items. */
1887 static xg_list_node xg_menu_item_cb_list
;
1889 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1890 F is the frame CL_DATA will be initialized for.
1891 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1893 The menu bar and all sub menus under the menu bar in a frame
1894 share the same structure, hence the reference count.
1896 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1897 allocated xg_menu_cb_data if CL_DATA is NULL. */
1899 static xg_menu_cb_data
*
1900 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
1904 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1906 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1907 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1908 cl_data
->highlight_cb
= highlight_cb
;
1909 cl_data
->ref_count
= 0;
1911 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1914 cl_data
->ref_count
++;
1919 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1920 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1922 When the menu bar is updated, menu items may have been added and/or
1923 removed, so menu_bar_vector and menu_bar_items_used change. We must
1924 then update CL_DATA since it is used to determine which menu
1925 item that is invoked in the menu.
1926 HIGHLIGHT_CB could change, there is no check that the same
1927 function is given when modifying a menu bar as was given when
1928 creating the menu bar. */
1931 update_cl_data (xg_menu_cb_data
*cl_data
,
1933 GCallback highlight_cb
)
1938 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1939 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1940 cl_data
->highlight_cb
= highlight_cb
;
1944 /* Decrease reference count for CL_DATA.
1945 If reference count is zero, free CL_DATA. */
1948 unref_cl_data (xg_menu_cb_data
*cl_data
)
1950 if (cl_data
&& cl_data
->ref_count
> 0)
1952 cl_data
->ref_count
--;
1953 if (cl_data
->ref_count
== 0)
1955 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1961 /* Function that marks all lisp data during GC. */
1968 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1969 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1971 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1973 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1975 if (! NILP (cb_data
->help
))
1976 mark_object (cb_data
->help
);
1981 /* Callback called when a menu item is destroyed. Used to free data.
1982 W is the widget that is being destroyed (not used).
1983 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1986 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
1990 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1991 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1996 /* Callback called when the pointer enters/leaves a menu item.
1997 W is the parent of the menu item.
1998 EVENT is either an enter event or leave event.
1999 CLIENT_DATA is not used.
2001 Returns FALSE to tell GTK to keep processing this event. */
2004 menuitem_highlight_callback (GtkWidget
*w
,
2005 GdkEventCrossing
*event
,
2006 gpointer client_data
)
2009 GtkWidget
*subwidget
;
2010 xg_menu_item_cb_data
*data
;
2012 ev
.crossing
= *event
;
2013 subwidget
= gtk_get_event_widget (&ev
);
2014 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
2018 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2020 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2021 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2022 (*func
) (subwidget
, call_data
);
2029 /* Callback called when a menu is destroyed. Used to free data.
2030 W is the widget that is being destroyed (not used).
2031 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2034 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2036 unref_cl_data ((xg_menu_cb_data
*) client_data
);
2039 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2040 must be non-NULL) and can be inserted into a menu item.
2042 Returns the GtkHBox. */
2045 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2051 wbox
= gtk_hbox_new (FALSE
, 0);
2052 wlbl
= gtk_label_new (utf8_label
);
2053 wkey
= gtk_label_new (utf8_key
);
2055 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2056 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2058 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2059 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2061 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2062 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2063 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2068 /* Make and return a menu item widget with the key to the right.
2069 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2070 UTF8_KEY is the text representing the key binding.
2071 ITEM is the widget_value describing the menu item.
2073 GROUP is an in/out parameter. If the menu item to be created is not
2074 part of any radio menu group, *GROUP contains NULL on entry and exit.
2075 If the menu item to be created is part of a radio menu group, on entry
2076 *GROUP contains the group to use, or NULL if this is the first item
2077 in the group. On exit, *GROUP contains the radio item group.
2079 Unfortunately, keys don't line up as nicely as in Motif,
2080 but the MacOS X version doesn't either, so I guess that is OK. */
2083 make_menu_item (const char *utf8_label
,
2084 const char *utf8_key
,
2089 GtkWidget
*wtoadd
= 0;
2091 /* It has been observed that some menu items have a NULL name field.
2092 This will lead to this function being called with a NULL utf8_label.
2093 GTK crashes on that so we set a blank label. Why there is a NULL
2094 name remains to be investigated. */
2095 if (! utf8_label
) utf8_label
= " ";
2098 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2100 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2103 if (utf8_key
) w
= gtk_check_menu_item_new ();
2104 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2105 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2107 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2109 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2110 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2111 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2113 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2118 if (utf8_key
) w
= gtk_menu_item_new ();
2119 else w
= gtk_menu_item_new_with_label (utf8_label
);
2122 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2123 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2128 static int xg_detached_menus
;
2130 /* Returns non-zero if there are detached menus. */
2133 xg_have_tear_offs (void)
2135 return xg_detached_menus
> 0;
2138 /* Callback invoked when a detached menu window is removed. Here we
2139 decrease the xg_detached_menus count.
2140 WIDGET is the top level window that is removed (the parent of the menu).
2141 CLIENT_DATA is not used. */
2144 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2146 if (xg_detached_menus
> 0) --xg_detached_menus
;
2149 /* Callback invoked when a menu is detached. It increases the
2150 xg_detached_menus count.
2151 WIDGET is the GtkTearoffMenuItem.
2152 CLIENT_DATA is not used. */
2155 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2157 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2158 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2160 ++xg_detached_menus
;
2161 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2163 G_CALLBACK (tearoff_remove
), 0);
2168 /* Create a menu item widget, and connect the callbacks.
2169 ITEM decribes the menu item.
2170 F is the frame the created menu belongs to.
2171 SELECT_CB is the callback to use when a menu item is selected.
2172 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2173 CL_DATA points to the callback data to be used for this menu.
2174 GROUP is an in/out parameter. If the menu item to be created is not
2175 part of any radio menu group, *GROUP contains NULL on entry and exit.
2176 If the menu item to be created is part of a radio menu group, on entry
2177 *GROUP contains the group to use, or NULL if this is the first item
2178 in the group. On exit, *GROUP contains the radio item group.
2180 Returns the created GtkWidget. */
2183 xg_create_one_menuitem (widget_value
*item
,
2185 GCallback select_cb
,
2186 GCallback highlight_cb
,
2187 xg_menu_cb_data
*cl_data
,
2193 xg_menu_item_cb_data
*cb_data
;
2195 utf8_label
= get_utf8_string (item
->name
);
2196 utf8_key
= get_utf8_string (item
->key
);
2198 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2200 if (utf8_label
) g_free (utf8_label
);
2201 if (utf8_key
) g_free (utf8_key
);
2203 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2205 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2207 cb_data
->select_id
= 0;
2208 cb_data
->help
= item
->help
;
2209 cb_data
->cl_data
= cl_data
;
2210 cb_data
->call_data
= item
->call_data
;
2212 g_signal_connect (G_OBJECT (w
),
2214 G_CALLBACK (menuitem_destroy_callback
),
2217 /* Put cb_data in widget, so we can get at it when modifying menubar */
2218 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2220 /* final item, not a submenu */
2221 if (item
->call_data
&& ! item
->contents
)
2225 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2231 /* Create a full menu tree specified by DATA.
2232 F is the frame the created menu belongs to.
2233 SELECT_CB is the callback to use when a menu item is selected.
2234 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2235 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2236 POP_UP_P is non-zero if we shall create a popup menu.
2237 MENU_BAR_P is non-zero if we shall create a menu bar.
2238 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2239 if MENU_BAR_P is non-zero.
2240 TOPMENU is the topmost GtkWidget that others shall be placed under.
2241 It may be NULL, in that case we create the appropriate widget
2242 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2243 CL_DATA is the callback data we shall use for this menu, or NULL
2244 if we haven't set the first callback yet.
2245 NAME is the name to give to the top level menu if this function
2246 creates it. May be NULL to not set any name.
2248 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2251 This function calls itself to create submenus. */
2254 create_menus (widget_value
*data
,
2256 GCallback select_cb
,
2257 GCallback deactivate_cb
,
2258 GCallback highlight_cb
,
2263 xg_menu_cb_data
*cl_data
,
2267 GtkWidget
*wmenu
= topmenu
;
2268 GSList
*group
= NULL
;
2274 wmenu
= gtk_menu_new ();
2275 xg_set_screen (wmenu
, f
);
2276 /* Connect this to the menu instead of items so we get enter/leave for
2277 disabled items also. TODO: Still does not get enter/leave for
2278 disabled items in detached menus. */
2279 g_signal_connect (G_OBJECT (wmenu
),
2280 "enter-notify-event",
2281 G_CALLBACK (menuitem_highlight_callback
),
2283 g_signal_connect (G_OBJECT (wmenu
),
2284 "leave-notify-event",
2285 G_CALLBACK (menuitem_highlight_callback
),
2290 wmenu
= gtk_menu_bar_new ();
2291 /* Set width of menu bar to a small value so it doesn't enlarge
2292 a small initial frame size. The width will be set to the
2293 width of the frame later on when it is added to a container.
2294 height -1: Natural height. */
2295 gtk_widget_set_size_request (wmenu
, 1, -1);
2298 /* Put cl_data on the top menu for easier access. */
2299 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2300 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2301 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2302 G_CALLBACK (menu_destroy_callback
), cl_data
);
2305 gtk_widget_set_name (wmenu
, name
);
2308 g_signal_connect (G_OBJECT (wmenu
),
2309 "selection-done", deactivate_cb
, 0);
2312 if (! menu_bar_p
&& add_tearoff_p
)
2314 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2315 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2317 g_signal_connect (G_OBJECT (tearoff
), "activate",
2318 G_CALLBACK (tearoff_activate
), 0);
2321 for (item
= data
; item
; item
= item
->next
)
2325 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2326 && !menu_separator_name_p (item
->name
))
2329 /* A title for a popup. We do the same as GTK does when
2330 creating titles, but it does not look good. */
2332 utf8_label
= get_utf8_string (item
->name
);
2334 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2335 w
= gtk_menu_item_new_with_label (utf8_label
);
2336 gtk_widget_set_sensitive (w
, FALSE
);
2337 if (utf8_label
) g_free (utf8_label
);
2339 else if (menu_separator_name_p (item
->name
))
2342 /* GTK only have one separator type. */
2343 w
= gtk_separator_menu_item_new ();
2347 w
= xg_create_one_menuitem (item
,
2349 item
->contents
? 0 : select_cb
,
2354 /* Create a possibly empty submenu for menu bar items, since some
2355 themes don't highlight items correctly without it. */
2356 if (item
->contents
|| menu_bar_p
)
2358 GtkWidget
*submenu
= create_menus (item
->contents
,
2369 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2373 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2374 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2380 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2381 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2382 with some text and buttons.
2383 F is the frame the created item belongs to.
2384 NAME is the name to use for the top widget.
2385 VAL is a widget_value structure describing items to be created.
2386 SELECT_CB is the callback to use when a menu item is selected or
2387 a dialog button is pressed.
2388 DEACTIVATE_CB is the callback to use when an item is deactivated.
2389 For a menu, when a sub menu is not shown anymore, for a dialog it is
2390 called when the dialog is popped down.
2391 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2393 Returns the widget created. */
2396 xg_create_widget (const char *type
, const char *name
, FRAME_PTR f
, widget_value
*val
,
2397 GCallback select_cb
, GCallback deactivate_cb
,
2398 GCallback highlight_cb
)
2401 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2402 int pop_up_p
= strcmp (type
, "popup") == 0;
2404 if (strcmp (type
, "dialog") == 0)
2406 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2407 xg_set_screen (w
, f
);
2408 gtk_window_set_transient_for (GTK_WINDOW (w
),
2409 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2410 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2411 gtk_widget_set_name (w
, "emacs-dialog");
2412 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2414 else if (menu_bar_p
|| pop_up_p
)
2416 w
= create_menus (val
->contents
,
2428 /* Set the cursor to an arrow for popup menus when they are mapped.
2429 This is done by default for menu bar menus. */
2432 /* Must realize so the GdkWindow inside the widget is created. */
2433 gtk_widget_realize (w
);
2434 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2439 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2446 /* Return the label for menu item WITEM. */
2449 xg_get_menu_item_label (GtkMenuItem
*witem
)
2451 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2452 return gtk_label_get_label (wlabel
);
2455 /* Return non-zero if the menu item WITEM has the text LABEL. */
2458 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2461 char *utf8_label
= get_utf8_string (label
);
2462 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2464 if (! old_label
&& ! utf8_label
)
2466 else if (old_label
&& utf8_label
)
2467 is_same
= strcmp (utf8_label
, old_label
) == 0;
2469 if (utf8_label
) g_free (utf8_label
);
2474 /* Destroy widgets in LIST. */
2477 xg_destroy_widgets (GList
*list
)
2481 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2483 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2485 /* Destroying the widget will remove it from the container it is in. */
2486 gtk_widget_destroy (w
);
2490 /* Update the top level names in MENUBAR (i.e. not submenus).
2491 F is the frame the menu bar belongs to.
2492 *LIST is a list with the current menu bar names (menu item widgets).
2493 ITER is the item within *LIST that shall be updated.
2494 POS is the numerical position, starting at 0, of ITER in *LIST.
2495 VAL describes what the menu bar shall look like after the update.
2496 SELECT_CB is the callback to use when a menu item is selected.
2497 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2498 CL_DATA points to the callback data to be used for this menu bar.
2500 This function calls itself to walk through the menu bar names. */
2503 xg_update_menubar (GtkWidget
*menubar
,
2509 GCallback select_cb
,
2510 GCallback deactivate_cb
,
2511 GCallback highlight_cb
,
2512 xg_menu_cb_data
*cl_data
)
2514 if (! iter
&& ! val
)
2516 else if (iter
&& ! val
)
2518 /* Item(s) have been removed. Remove all remaining items. */
2519 xg_destroy_widgets (iter
);
2521 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2522 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2523 gtk_menu_item_new_with_label (""),
2529 else if (! iter
&& val
)
2531 /* Item(s) added. Add all new items in one call. */
2532 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2533 0, 1, 0, menubar
, cl_data
, 0);
2539 /* Below this neither iter or val is NULL */
2540 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2542 /* This item is still the same, check next item. */
2544 iter
= g_list_next (iter
);
2547 else /* This item is changed. */
2549 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2550 GtkMenuItem
*witem2
= 0;
2551 int val_in_menubar
= 0;
2552 int iter_in_new_menubar
= 0;
2556 /* See if the changed entry (val) is present later in the menu bar */
2558 iter2
&& ! val_in_menubar
;
2559 iter2
= g_list_next (iter2
))
2561 witem2
= GTK_MENU_ITEM (iter2
->data
);
2562 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2565 /* See if the current entry (iter) is present later in the
2566 specification for the new menu bar. */
2567 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2568 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2570 if (val_in_menubar
&& ! iter_in_new_menubar
)
2574 /* This corresponds to:
2579 g_object_ref (G_OBJECT (witem
));
2580 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2581 gtk_widget_destroy (GTK_WIDGET (witem
));
2583 /* Must get new list since the old changed. */
2584 g_list_free (*list
);
2585 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2586 while (nr
-- > 0) iter
= g_list_next (iter
);
2588 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2590 /* This corresponds to:
2593 Rename B to X. This might seem to be a strange thing to do,
2594 since if there is a menu under B it will be totally wrong for X.
2595 But consider editing a C file. Then there is a C-mode menu
2596 (corresponds to B above).
2597 If then doing C-x C-f the minibuf menu (X above) replaces the
2598 C-mode menu. When returning from the minibuffer, we get
2599 back the C-mode menu. Thus we do:
2600 Rename B to X (C-mode to minibuf menu)
2601 Rename X to B (minibuf to C-mode menu).
2602 If the X menu hasn't been invoked, the menu under B
2603 is up to date when leaving the minibuffer. */
2604 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2605 char *utf8_label
= get_utf8_string (val
->name
);
2606 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2608 gtk_label_set_text (wlabel
, utf8_label
);
2610 /* If this item has a submenu that has been detached, change
2611 the title in the WM decorations also. */
2612 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2613 /* Set the title of the detached window. */
2614 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2616 if (utf8_label
) g_free (utf8_label
);
2617 iter
= g_list_next (iter
);
2621 else if (! val_in_menubar
&& iter_in_new_menubar
)
2623 /* This corresponds to:
2630 GtkWidget
*w
= xg_create_one_menuitem (val
,
2637 /* Create a possibly empty submenu for menu bar items, since some
2638 themes don't highlight items correctly without it. */
2639 GtkWidget
*submenu
= create_menus (NULL
, f
,
2640 select_cb
, deactivate_cb
,
2642 0, 0, 0, 0, cl_data
, 0);
2643 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2644 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2645 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2647 g_list_free (*list
);
2648 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2649 while (nr
-- > 0) iter
= g_list_next (iter
);
2650 iter
= g_list_next (iter
);
2654 else /* if (val_in_menubar && iter_in_new_menubar) */
2657 /* This corresponds to:
2662 g_object_ref (G_OBJECT (witem2
));
2663 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2664 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2665 GTK_WIDGET (witem2
), pos
);
2666 g_object_unref (G_OBJECT (witem2
));
2668 g_list_free (*list
);
2669 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2670 while (nr
-- > 0) iter
= g_list_next (iter
);
2671 if (iter
) iter
= g_list_next (iter
);
2677 /* Update the rest of the menu bar. */
2678 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2679 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2682 /* Update the menu item W so it corresponds to VAL.
2683 SELECT_CB is the callback to use when a menu item is selected.
2684 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2685 CL_DATA is the data to set in the widget for menu invocation. */
2688 xg_update_menu_item (widget_value
*val
,
2690 GCallback select_cb
,
2691 GCallback highlight_cb
,
2692 xg_menu_cb_data
*cl_data
)
2699 const char *old_label
= 0;
2700 const char *old_key
= 0;
2701 xg_menu_item_cb_data
*cb_data
;
2703 wchild
= XG_BIN_CHILD (w
);
2704 utf8_label
= get_utf8_string (val
->name
);
2705 utf8_key
= get_utf8_string (val
->key
);
2707 /* See if W is a menu item with a key. See make_menu_item above. */
2708 if (GTK_IS_HBOX (wchild
))
2710 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2712 wlbl
= GTK_LABEL (list
->data
);
2713 wkey
= GTK_LABEL (list
->next
->data
);
2718 /* Remove the key and keep just the label. */
2719 g_object_ref (G_OBJECT (wlbl
));
2720 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2721 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2722 g_object_unref (G_OBJECT (wlbl
));
2727 else /* Just a label. */
2729 wlbl
= GTK_LABEL (wchild
);
2731 /* Check if there is now a key. */
2734 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2735 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2737 wlbl
= GTK_LABEL (list
->data
);
2738 wkey
= GTK_LABEL (list
->next
->data
);
2741 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2742 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2747 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2748 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2750 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2751 gtk_label_set_text (wkey
, utf8_key
);
2753 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2754 gtk_label_set_text (wlbl
, utf8_label
);
2756 if (utf8_key
) g_free (utf8_key
);
2757 if (utf8_label
) g_free (utf8_label
);
2759 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2760 gtk_widget_set_sensitive (w
, FALSE
);
2761 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2762 gtk_widget_set_sensitive (w
, TRUE
);
2764 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2768 cb_data
->call_data
= val
->call_data
;
2769 cb_data
->help
= val
->help
;
2770 cb_data
->cl_data
= cl_data
;
2772 /* We assume the callback functions don't change. */
2773 if (val
->call_data
&& ! val
->contents
)
2775 /* This item shall have a select callback. */
2776 if (! cb_data
->select_id
)
2778 = g_signal_connect (G_OBJECT (w
), "activate",
2779 select_cb
, cb_data
);
2781 else if (cb_data
->select_id
)
2783 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2784 cb_data
->select_id
= 0;
2789 /* Update the toggle menu item W so it corresponds to VAL. */
2792 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
2794 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2797 /* Update the radio menu item W so it corresponds to VAL. */
2800 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
2802 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2805 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2806 SUBMENU may be NULL, in that case a new menu is created.
2807 F is the frame the menu bar belongs to.
2808 VAL describes the contents of the menu bar.
2809 SELECT_CB is the callback to use when a menu item is selected.
2810 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2811 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2812 CL_DATA is the call back data to use for any newly created items.
2814 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2818 xg_update_submenu (GtkWidget
*submenu
,
2821 GCallback select_cb
,
2822 GCallback deactivate_cb
,
2823 GCallback highlight_cb
,
2824 xg_menu_cb_data
*cl_data
)
2826 GtkWidget
*newsub
= submenu
;
2830 int has_tearoff_p
= 0;
2831 GList
*first_radio
= 0;
2834 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2836 for (cur
= val
, iter
= list
;
2838 iter
= g_list_next (iter
), cur
= cur
->next
)
2840 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2842 /* Skip tearoff items, they have no counterpart in val. */
2843 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2846 iter
= g_list_next (iter
);
2847 if (iter
) w
= GTK_WIDGET (iter
->data
);
2851 /* Remember first radio button in a group. If we get a mismatch in
2852 a radio group we must rebuild the whole group so that the connections
2853 in GTK becomes correct. */
2854 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2856 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2857 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2860 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2862 if (! menu_separator_name_p (cur
->name
))
2865 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2867 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2869 xg_update_toggle_item (cur
, w
);
2870 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2872 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2874 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2876 xg_update_radio_item (cur
, w
);
2877 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2879 else if (GTK_IS_MENU_ITEM (w
))
2881 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2884 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2885 menu_separator_name_p (cur
->name
))
2888 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2890 sub
= gtk_menu_item_get_submenu (witem
);
2891 if (sub
&& ! cur
->contents
)
2893 /* Not a submenu anymore. */
2894 g_object_ref (G_OBJECT (sub
));
2895 remove_submenu (witem
);
2896 gtk_widget_destroy (sub
);
2898 else if (cur
->contents
)
2902 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2903 select_cb
, deactivate_cb
,
2904 highlight_cb
, cl_data
);
2906 /* If this item just became a submenu, we must set it. */
2908 gtk_menu_item_set_submenu (witem
, nsub
);
2913 /* Structural difference. Remove everything from here and down
2919 /* Remove widgets from first structual change. */
2922 /* If we are adding new menu items below, we must remove from
2923 first radio button so that radio groups become correct. */
2924 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2925 else xg_destroy_widgets (iter
);
2930 /* More items added. Create them. */
2931 newsub
= create_menus (cur
,
2944 if (list
) g_list_free (list
);
2949 /* Update the MENUBAR.
2950 F is the frame the menu bar belongs to.
2951 VAL describes the contents of the menu bar.
2952 If DEEP_P is non-zero, rebuild all but the top level menu names in
2953 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2954 SELECT_CB is the callback to use when a menu item is selected.
2955 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2956 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2959 xg_modify_menubar_widgets (GtkWidget
*menubar
, FRAME_PTR f
, widget_value
*val
,
2961 GCallback select_cb
, GCallback deactivate_cb
,
2962 GCallback highlight_cb
)
2964 xg_menu_cb_data
*cl_data
;
2965 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2969 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2972 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2973 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2979 /* Update all sub menus.
2980 We must keep the submenus (GTK menu item widgets) since the
2981 X Window in the XEvent that activates the menu are those widgets. */
2983 /* Update cl_data, menu_item things in F may have changed. */
2984 update_cl_data (cl_data
, f
, highlight_cb
);
2986 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2991 GtkMenuItem
*witem
= 0;
2993 /* Find sub menu that corresponds to val and update it. */
2994 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2996 witem
= GTK_MENU_ITEM (iter
->data
);
2997 if (xg_item_label_same_p (witem
, cur
->name
))
2999 sub
= gtk_menu_item_get_submenu (witem
);
3004 newsub
= xg_update_submenu (sub
,
3011 /* sub may still be NULL. If we just updated non deep and added
3012 a new menu bar item, it has no sub menu yet. So we set the
3013 newly created sub menu under witem. */
3014 if (newsub
!= sub
&& witem
!= 0)
3016 xg_set_screen (newsub
, f
);
3017 gtk_menu_item_set_submenu (witem
, newsub
);
3023 gtk_widget_show_all (menubar
);
3026 /* Callback called when the menu bar W is mapped.
3027 Used to find the height of the menu bar if we didn't get it
3028 after showing the widget. */
3031 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3034 FRAME_PTR f
= (FRAME_PTR
) user_data
;
3035 gtk_widget_size_request (w
, &req
);
3036 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3038 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3039 xg_height_or_width_changed (f
);
3043 /* Recompute all the widgets of frame F, when the menu bar has been
3044 changed. Value is non-zero if widgets were updated. */
3047 xg_update_frame_menubar (FRAME_PTR f
)
3049 struct x_output
*x
= f
->output_data
.x
;
3052 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3055 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3056 return 0; /* Already done this, happens for frames created invisible. */
3060 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3062 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3064 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3065 gtk_widget_show_all (x
->menubar_widget
);
3066 gtk_widget_size_request (x
->menubar_widget
, &req
);
3068 /* If menu bar doesn't know its height yet, cheat a little so the frame
3069 doesn't jump so much when resized later in menubar_map_cb. */
3070 if (req
.height
== 0)
3073 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3075 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3076 xg_height_or_width_changed (f
);
3083 /* Get rid of the menu bar of frame F, and free its storage.
3084 This is used when deleting a frame, and when turning off the menu bar. */
3087 free_frame_menubar (FRAME_PTR f
)
3089 struct x_output
*x
= f
->output_data
.x
;
3091 if (x
->menubar_widget
)
3095 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3096 /* The menubar and its children shall be deleted when removed from
3098 x
->menubar_widget
= 0;
3099 FRAME_MENUBAR_HEIGHT (f
) = 0;
3100 xg_height_or_width_changed (f
);
3106 xg_event_is_for_menubar (FRAME_PTR f
, XEvent
*event
)
3108 struct x_output
*x
= f
->output_data
.x
;
3117 if (! x
->menubar_widget
) return 0;
3119 if (! (event
->xbutton
.x
>= 0
3120 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3121 && event
->xbutton
.y
>= 0
3122 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3123 && event
->xbutton
.same_screen
))
3126 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3127 gw
= gdk_xid_table_lookup_for_display (gdpy
, event
->xbutton
.window
);
3129 gevent
.any
.window
= gw
;
3130 gwdesc
= gtk_get_event_widget (&gevent
);
3131 if (! gwdesc
) return 0;
3132 if (! GTK_IS_MENU_BAR (gwdesc
)
3133 && ! GTK_IS_MENU_ITEM (gwdesc
)
3134 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3137 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3138 if (! list
) return 0;
3139 rec
.x
= event
->xbutton
.x
;
3140 rec
.y
= event
->xbutton
.y
;
3144 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3146 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3147 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3151 return iter
== 0 ? 0 : 1;
3156 /***********************************************************************
3157 Scroll bar functions
3158 ***********************************************************************/
3161 /* Setting scroll bar values invokes the callback. Use this variable
3162 to indicate that callback should do nothing. */
3164 int xg_ignore_gtk_scrollbar
;
3166 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3167 may be larger than 32 bits. Keep a mapping from integer index to widget
3168 pointers to get around the 32 bit limitation. */
3172 GtkWidget
**widgets
;
3177 /* Grow this much every time we need to allocate more */
3179 #define ID_TO_WIDGET_INCR 32
3181 /* Store the widget pointer W in id_to_widget and return the integer index. */
3184 xg_store_widget_in_map (GtkWidget
*w
)
3188 if (id_to_widget
.max_size
== id_to_widget
.used
)
3190 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3192 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
3193 sizeof (GtkWidget
*)*new_size
);
3195 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3196 id_to_widget
.widgets
[i
] = 0;
3197 id_to_widget
.max_size
= new_size
;
3200 /* Just loop over the array and find a free place. After all,
3201 how many scroll bars are we creating? Should be a small number.
3202 The check above guarantees we will find a free place. */
3203 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3205 if (! id_to_widget
.widgets
[i
])
3207 id_to_widget
.widgets
[i
] = w
;
3208 ++id_to_widget
.used
;
3214 /* Should never end up here */
3218 /* Remove pointer at IDX from id_to_widget.
3219 Called when scroll bar is destroyed. */
3222 xg_remove_widget_from_map (int idx
)
3224 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3226 id_to_widget
.widgets
[idx
] = 0;
3227 --id_to_widget
.used
;
3231 /* Get the widget pointer at IDX from id_to_widget. */
3234 xg_get_widget_from_map (int idx
)
3236 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3237 return id_to_widget
.widgets
[idx
];
3242 /* Return the scrollbar id for X Window WID on display DPY.
3243 Return -1 if WID not in id_to_widget. */
3246 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3251 w
= xg_win_to_widget (dpy
, wid
);
3255 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3256 if (id_to_widget
.widgets
[idx
] == w
)
3263 /* Callback invoked when scroll bar WIDGET is destroyed.
3264 DATA is the index into id_to_widget for WIDGET.
3265 We free pointer to last scroll bar values here and remove the index. */
3268 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3270 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
3271 xg_remove_widget_from_map (id
);
3274 /* Create a scroll bar widget for frame F. Store the scroll bar
3276 SCROLL_CALLBACK is the callback to invoke when the value of the
3278 END_CALLBACK is the callback to invoke when scrolling ends.
3279 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3280 to set resources for the widget. */
3283 xg_create_scroll_bar (FRAME_PTR f
,
3284 struct scroll_bar
*bar
,
3285 GCallback scroll_callback
,
3286 GCallback end_callback
,
3287 const char *scroll_bar_name
)
3294 /* Page, step increment values are not so important here, they
3295 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3296 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3299 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3300 webox
= gtk_event_box_new ();
3301 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3302 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3303 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3305 scroll_id
= xg_store_widget_in_map (wscroll
);
3307 /* The EMACS_INT cast avoids a warning. */
3308 g_signal_connect (G_OBJECT (wscroll
),
3310 G_CALLBACK (xg_gtk_scroll_destroy
),
3311 (gpointer
) (EMACS_INT
) scroll_id
);
3312 g_signal_connect (G_OBJECT (wscroll
),
3316 g_signal_connect (G_OBJECT (wscroll
),
3317 "button-release-event",
3321 /* The scroll bar widget does not draw on a window of its own. Instead
3322 it draws on the parent window, in this case the edit widget. So
3323 whenever the edit widget is cleared, the scroll bar needs to redraw
3324 also, which causes flicker. Put an event box between the edit widget
3325 and the scroll bar, so the scroll bar instead draws itself on the
3326 event box window. */
3327 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3328 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3331 /* Set the cursor to an arrow. */
3332 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3334 bar
->x_window
= scroll_id
;
3337 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3340 xg_remove_scroll_bar (FRAME_PTR f
, int scrollbar_id
)
3342 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3345 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3346 gtk_widget_destroy (w
);
3347 gtk_widget_destroy (wparent
);
3348 SET_FRAME_GARBAGED (f
);
3352 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3354 TOP/LEFT are the new pixel positions where the bar shall appear.
3355 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3358 xg_update_scrollbar_pos (FRAME_PTR f
,
3366 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3370 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3371 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3374 /* Clear out old position. */
3375 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3376 if (gtk_widget_get_parent (wparent
) == wfixed
)
3378 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3379 "x", &oldx
, "y", &oldy
, NULL
);
3380 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3383 /* Move and resize to new values. */
3384 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3385 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3388 /* No room. Hide scroll bar as some themes output a warning if
3389 the height is less than the min size. */
3390 gtk_widget_hide (wparent
);
3391 gtk_widget_hide (wscroll
);
3395 gtk_widget_show_all (wparent
);
3396 gtk_widget_set_size_request (wscroll
, width
, height
);
3398 gtk_widget_queue_draw (wfixed
);
3399 gdk_window_process_all_updates ();
3400 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3402 /* Clear under old scroll bar position. This must be done after
3403 the gtk_widget_queue_draw and gdk_window_process_all_updates
3405 x_clear_area (FRAME_X_DISPLAY (f
),
3407 oldx
, oldy
, oldw
, oldh
, 0);
3410 /* GTK does not redraw until the main loop is entered again, but
3411 if there are no X events pending we will not enter it. So we sync
3412 here to get some events. */
3415 SET_FRAME_GARBAGED (f
);
3416 cancel_mouse_face (f
);
3420 /* Set the thumb size and position of scroll bar BAR. We are currently
3421 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3424 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3429 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3431 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3433 if (wscroll
&& NILP (bar
->dragging
))
3442 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3444 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3445 rather than the real portion value. This makes the thumb less likely
3446 to resize and that looks better. */
3447 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3448 /* When the thumb is at the bottom, position == whole.
3449 So we need to increase `whole' to make space for the thumb. */
3456 top
= (gdouble
) position
/ whole
;
3457 shown
= (gdouble
) portion
/ whole
;
3460 size
= shown
* XG_SB_RANGE
;
3461 size
= min (size
, XG_SB_RANGE
);
3462 size
= max (size
, 1);
3464 value
= top
* XG_SB_RANGE
;
3465 value
= min (value
, XG_SB_MAX
- size
);
3466 value
= max (value
, XG_SB_MIN
);
3468 /* Assume all lines are of equal size. */
3469 new_step
= size
/ max (1, FRAME_LINES (f
));
3471 if ((int) gtk_adjustment_get_page_size (adj
) != size
3472 || (int) gtk_adjustment_get_step_increment (adj
) != new_step
)
3474 gtk_adjustment_set_page_size (adj
, size
);
3475 gtk_adjustment_set_step_increment (adj
, new_step
);
3476 /* Assume a page increment is about 95% of the page size */
3477 gtk_adjustment_set_page_increment (adj
,(int) (0.95*size
));
3481 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3485 /* gtk_range_set_value invokes the callback. Set
3486 ignore_gtk_scrollbar to make the callback do nothing */
3487 xg_ignore_gtk_scrollbar
= 1;
3489 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3490 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3492 gtk_adjustment_changed (adj
);
3494 xg_ignore_gtk_scrollbar
= 0;
3501 /* Return non-zero if EVENT is for a scroll bar in frame F.
3502 When the same X window is used for several Gtk+ widgets, we cannot
3503 say for sure based on the X window alone if an event is for the
3504 frame. This function does additional checks.
3506 Return non-zero if the event is for a scroll bar, zero otherwise. */
3509 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3513 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3515 /* Check if press occurred outside the edit widget. */
3516 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3517 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3518 != gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3521 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3522 || event
->type
== MotionNotify
))
3524 /* If we are releasing or moving the scroll bar, it has the grab. */
3525 GtkWidget
*w
= gtk_grab_get_current ();
3526 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3534 /***********************************************************************
3536 ***********************************************************************/
3537 /* The key for the data we put in the GtkImage widgets. The data is
3538 the image used by Emacs. We use this to see if we need to update
3539 the GtkImage with a new image. */
3540 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3542 /* The key for storing the latest modifiers so the activate callback can
3544 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3546 /* The key for storing the button widget in its proxy menu item. */
3547 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3549 /* The key for the data we put in the GtkImage widgets. The data is
3550 the stock name used by Emacs. We use this to see if we need to update
3551 the GtkImage with a new image. */
3552 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3554 /* As above, but this is used for named theme widgets, as opposed to
3556 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3558 /* Callback function invoked when a tool bar item is pressed.
3559 W is the button widget in the tool bar that got pressed,
3560 CLIENT_DATA is an integer that is the index of the button in the
3561 tool bar. 0 is the first button. */
3564 xg_tool_bar_button_cb (GtkWidget
*widget
,
3565 GdkEventButton
*event
,
3568 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3569 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3570 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3575 /* Callback function invoked when a tool bar item is pressed.
3576 W is the button widget in the tool bar that got pressed,
3577 CLIENT_DATA is an integer that is the index of the button in the
3578 tool bar. 0 is the first button. */
3581 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3583 /* The EMACS_INT cast avoids a warning. */
3584 int idx
= (int) (EMACS_INT
) client_data
;
3585 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3586 XG_TOOL_BAR_LAST_MODIFIER
);
3588 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3589 Lisp_Object key
, frame
;
3590 struct input_event event
;
3593 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3596 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3598 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3599 XSETFRAME (frame
, f
);
3601 /* We generate two events here. The first one is to set the prefix
3602 to `(tool_bar)', see keyboard.c. */
3603 event
.kind
= TOOL_BAR_EVENT
;
3604 event
.frame_or_window
= frame
;
3606 kbd_buffer_store_event (&event
);
3608 event
.kind
= TOOL_BAR_EVENT
;
3609 event
.frame_or_window
= frame
;
3611 /* Convert between the modifier bits GDK uses and the modifier bits
3612 Emacs uses. This assumes GDK and X masks are the same, which they are when
3614 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3615 kbd_buffer_store_event (&event
);
3617 /* Return focus to the frame after we have clicked on a detached
3619 Fx_focus_frame (frame
);
3622 /* Callback function invoked when a tool bar item is pressed in a detached
3623 tool bar or the overflow drop down menu.
3624 We just call xg_tool_bar_callback.
3625 W is the menu item widget that got pressed,
3626 CLIENT_DATA is an integer that is the index of the button in the
3627 tool bar. 0 is the first button. */
3630 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3632 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3633 XG_TOOL_BAR_PROXY_BUTTON
));
3634 xg_tool_bar_callback (wbutton
, client_data
);
3639 xg_tool_bar_help_callback (GtkWidget
*w
,
3640 GdkEventCrossing
*event
,
3641 gpointer client_data
);
3643 /* This callback is called when a help is to be shown for an item in
3644 the detached tool bar when the detached tool bar it is not expanded. */
3647 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3648 GdkEventCrossing
*event
,
3649 gpointer client_data
)
3651 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3652 XG_TOOL_BAR_PROXY_BUTTON
));
3654 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3658 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3660 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3661 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3662 GtkWidget
*c2
= clist
->next
? (GtkWidget
*) clist
->next
->data
: NULL
;
3664 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3665 g_list_free (clist
);
3666 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3670 /* This callback is called when a tool item should create a proxy item,
3671 such as for the overflow menu. Also called when the tool bar is detached.
3672 If we don't create a proxy menu item, the detached tool bar will be
3676 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3678 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
3679 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
3681 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3682 GtkImage
*wimage
= GTK_IMAGE (c1
);
3683 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3684 (gtk_label_get_text (wlbl
));
3685 GtkWidget
*wmenuimage
;
3688 if (gtk_button_get_use_stock (wbutton
))
3689 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3690 GTK_ICON_SIZE_MENU
);
3693 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3694 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3696 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
3698 if (store_type
== GTK_IMAGE_STOCK
)
3701 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3702 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3704 else if (store_type
== GTK_IMAGE_ICON_SET
)
3706 GtkIconSet
*icon_set
;
3707 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3708 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3709 GTK_ICON_SIZE_MENU
);
3711 else if (store_type
== GTK_IMAGE_PIXBUF
)
3716 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3719 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3721 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3722 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3723 GDK_INTERP_BILINEAR
);
3725 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3729 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3733 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3735 const gchar
*icon_name
;
3736 GtkIconSize icon_size
;
3738 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3739 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3740 GTK_ICON_SIZE_MENU
);
3744 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3749 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3751 g_signal_connect (G_OBJECT (wmenuitem
),
3753 G_CALLBACK (xg_tool_bar_proxy_callback
),
3757 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3758 (gpointer
) wbutton
);
3759 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3760 gtk_widget_set_sensitive (wmenuitem
,
3761 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
3763 /* Use enter/leave notify to show help. We use the events
3764 rather than the GtkButton specific signals "enter" and
3765 "leave", so we can have only one callback. The event
3766 will tell us what kind of event it is. */
3767 g_signal_connect (G_OBJECT (wmenuitem
),
3768 "enter-notify-event",
3769 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3771 g_signal_connect (G_OBJECT (wmenuitem
),
3772 "leave-notify-event",
3773 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3779 /* This callback is called when a tool bar is detached. We must set
3780 the height of the tool bar to zero when this happens so frame sizes
3781 are correctly calculated.
3782 WBOX is the handle box widget that enables detach/attach of the tool bar.
3783 W is the tool bar widget.
3784 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3787 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
3789 gpointer client_data
)
3791 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3793 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3798 GtkRequisition req
, req2
;
3799 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3800 gtk_widget_size_request (GTK_WIDGET (wbox
), &req
);
3801 gtk_widget_size_request (w
, &req2
);
3802 req
.width
-= req2
.width
;
3803 req
.height
-= req2
.height
;
3804 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
3805 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
3806 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
3807 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
3808 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
3809 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
3810 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
3811 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
3812 xg_height_or_width_changed (f
);
3816 /* This callback is called when a tool bar is reattached. We must set
3817 the height of the tool bar when this happens so frame sizes
3818 are correctly calculated.
3819 WBOX is the handle box widget that enables detach/attach of the tool bar.
3820 W is the tool bar widget.
3821 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3824 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
3826 gpointer client_data
)
3828 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3829 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3833 GtkRequisition req
, req2
;
3834 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3835 gtk_widget_size_request (GTK_WIDGET (wbox
), &req
);
3836 gtk_widget_size_request (w
, &req2
);
3837 req
.width
+= req2
.width
;
3838 req
.height
+= req2
.height
;
3839 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
3840 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
3841 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
3842 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
3843 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
3844 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
3845 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
3846 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
3847 xg_height_or_width_changed (f
);
3851 /* This callback is called when the mouse enters or leaves a tool bar item.
3852 It is used for displaying and hiding the help text.
3853 W is the tool bar item, a button.
3854 EVENT is either an enter event or leave event.
3855 CLIENT_DATA is an integer that is the index of the button in the
3856 tool bar. 0 is the first button.
3858 Returns FALSE to tell GTK to keep processing this event. */
3861 xg_tool_bar_help_callback (GtkWidget
*w
,
3862 GdkEventCrossing
*event
,
3863 gpointer client_data
)
3865 /* The EMACS_INT cast avoids a warning. */
3866 int idx
= (int) (EMACS_INT
) client_data
;
3867 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3868 Lisp_Object help
, frame
;
3870 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3873 if (event
->type
== GDK_ENTER_NOTIFY
)
3875 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3876 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3879 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3884 XSETFRAME (frame
, f
);
3885 kbd_buffer_store_help_event (frame
, help
);
3891 /* This callback is called when a tool bar item shall be redrawn.
3892 It modifies the expose event so that the GtkImage widget redraws the
3893 whole image. This to overcome a bug that makes GtkImage draw the image
3894 in the wrong place when it tries to redraw just a part of the image.
3895 W is the GtkImage to be redrawn.
3896 EVENT is the expose event for W.
3897 CLIENT_DATA is unused.
3899 Returns FALSE to tell GTK to keep processing this event. */
3902 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
3903 GdkEventExpose
*event
,
3904 gpointer client_data
)
3908 gdk_drawable_get_size (event
->window
, &width
, &height
);
3910 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3911 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3913 event
->area
.x
= max (0, event
->area
.x
);
3914 event
->area
.y
= max (0, event
->area
.y
);
3916 event
->area
.width
= max (width
, event
->area
.width
);
3917 event
->area
.height
= max (height
, event
->area
.height
);
3922 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
3923 #define toolbar_set_orientation(w, o) \
3924 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
3926 #define toolbar_set_orientation(w, o) \
3927 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
3930 /* Attach a tool bar to frame F. */
3933 xg_pack_tool_bar (FRAME_PTR f
, Lisp_Object pos
)
3935 struct x_output
*x
= f
->output_data
.x
;
3936 int into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
3938 toolbar_set_orientation (x
->toolbar_widget
,
3940 ? GTK_ORIENTATION_VERTICAL
3941 : GTK_ORIENTATION_HORIZONTAL
);
3942 if (!x
->handlebox_widget
)
3944 x
->handlebox_widget
= gtk_handle_box_new ();
3945 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3946 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3947 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3948 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3949 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3955 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
3957 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), x
->handlebox_widget
,
3960 if (EQ (pos
, Qleft
))
3961 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
3962 x
->handlebox_widget
,
3964 x
->toolbar_in_hbox
= 1;
3968 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3969 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
3971 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3975 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
3976 x
->handlebox_widget
,
3978 x
->toolbar_in_hbox
= 0;
3982 /* Create a tool bar for frame F. */
3985 xg_create_tool_bar (FRAME_PTR f
)
3987 struct x_output
*x
= f
->output_data
.x
;
3989 x
->toolbar_widget
= gtk_toolbar_new ();
3990 x
->toolbar_detached
= 0;
3992 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3994 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3995 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
3999 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4001 /* Find the right-to-left image named by RTL in the tool bar images for F.
4002 Returns IMAGE if RTL is not found. */
4005 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
4008 Lisp_Object file
, rtl_name
;
4009 struct gcpro gcpro1
, gcpro2
;
4010 GCPRO2 (file
, rtl_name
);
4012 rtl_name
= Ffile_name_nondirectory (rtl
);
4014 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4016 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4017 if (!NILP (file
= file_for_image (rtl_image
)))
4019 file
= call1 (intern ("file-name-sans-extension"),
4020 Ffile_name_nondirectory (file
));
4021 if (EQ (Fequal (file
, rtl_name
), Qt
))
4032 static GtkToolItem
*
4033 xg_make_tool_item (FRAME_PTR f
,
4035 GtkWidget
**wbutton
,
4037 int i
, int horiz
, int text_image
)
4039 GtkToolItem
*ti
= gtk_tool_item_new ();
4040 GtkWidget
*vb
= horiz
? gtk_hbox_new (FALSE
, 0) : gtk_vbox_new (FALSE
, 0);
4041 GtkWidget
*wb
= gtk_button_new ();
4042 GtkWidget
*weventbox
= gtk_event_box_new ();
4044 if (wimage
&& !text_image
)
4045 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4047 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4048 if (wimage
&& text_image
)
4049 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4051 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4052 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4053 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4054 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4055 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4059 /* The EMACS_INT cast avoids a warning. */
4060 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4061 G_CALLBACK (xg_tool_bar_menu_proxy
),
4062 (gpointer
) (EMACS_INT
) i
);
4064 g_signal_connect (G_OBJECT (wb
), "clicked",
4065 G_CALLBACK (xg_tool_bar_callback
),
4066 (gpointer
) (EMACS_INT
) i
);
4068 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4070 /* Catch expose events to overcome an annoying redraw bug, see
4071 comment for xg_tool_bar_item_expose_callback. */
4072 g_signal_connect (G_OBJECT (ti
),
4074 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4077 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4079 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
4080 no distinction based on modifiers in the activate callback,
4081 so we have to do it ourselves. */
4082 g_signal_connect (wb
, "button-release-event",
4083 G_CALLBACK (xg_tool_bar_button_cb
),
4086 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4088 /* Use enter/leave notify to show help. We use the events
4089 rather than the GtkButton specific signals "enter" and
4090 "leave", so we can have only one callback. The event
4091 will tell us what kind of event it is. */
4092 /* The EMACS_INT cast avoids a warning. */
4093 g_signal_connect (G_OBJECT (weventbox
),
4094 "enter-notify-event",
4095 G_CALLBACK (xg_tool_bar_help_callback
),
4096 (gpointer
) (EMACS_INT
) i
);
4097 g_signal_connect (G_OBJECT (weventbox
),
4098 "leave-notify-event",
4099 G_CALLBACK (xg_tool_bar_help_callback
),
4100 (gpointer
) (EMACS_INT
) i
);
4103 if (wbutton
) *wbutton
= wb
;
4109 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4110 const char *icon_name
, const struct image
*img
,
4111 const char *label
, int horiz
)
4115 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4116 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4118 /* Check if the tool icon matches. */
4121 old
= g_object_get_data (G_OBJECT (wimage
),
4122 XG_TOOL_BAR_STOCK_NAME
);
4123 if (!old
|| strcmp (old
, stock_name
))
4128 old
= g_object_get_data (G_OBJECT (wimage
),
4129 XG_TOOL_BAR_ICON_NAME
);
4130 if (!old
|| strcmp (old
, icon_name
))
4136 = (Pixmap
) g_object_get_data (G_OBJECT (wimage
),
4137 XG_TOOL_BAR_IMAGE_DATA
);
4138 if (old_img
!= img
->pixmap
)
4142 /* Check button configuration and label. */
4143 if ((horiz
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
))
4144 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4147 /* Ensure label is correct. */
4149 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4154 xg_update_tool_bar_sizes (FRAME_PTR f
)
4156 struct x_output
*x
= f
->output_data
.x
;
4158 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4160 gtk_widget_size_request (GTK_WIDGET (x
->handlebox_widget
), &req
);
4161 if (x
->toolbar_in_hbox
)
4164 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4165 x
->handlebox_widget
,
4166 "position", &pos
, NULL
);
4167 if (pos
== 0) nl
= req
.width
;
4168 else nr
= req
.width
;
4173 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4174 x
->handlebox_widget
,
4175 "position", &pos
, NULL
);
4176 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4177 else nb
= req
.height
;
4180 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4181 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4182 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4183 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4185 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4186 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4187 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4188 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4189 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4190 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4198 /* Update the tool bar for frame F. Add new buttons and remove old. */
4201 update_frame_tool_bar (FRAME_PTR f
)
4204 struct x_output
*x
= f
->output_data
.x
;
4205 int hmargin
= 0, vmargin
= 0;
4206 GtkToolbar
*wtoolbar
;
4208 GtkTextDirection dir
;
4209 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
4212 int text_image
, horiz
;
4214 if (! FRAME_GTK_WIDGET (f
))
4219 if (INTEGERP (Vtool_bar_button_margin
)
4220 && XINT (Vtool_bar_button_margin
) > 0)
4222 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4223 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4225 else if (CONSP (Vtool_bar_button_margin
))
4227 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
4228 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
4229 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4231 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
4232 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
4233 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4236 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4237 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4238 i.e. zero. This means that margins less than
4239 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4240 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4241 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4243 if (! x
->toolbar_widget
)
4244 xg_create_tool_bar (f
);
4246 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4247 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4249 style
= Ftool_bar_get_system_style ();
4250 text_image
= EQ (style
, Qtext_image_horiz
);
4251 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4253 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4255 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4256 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4260 struct image
*img
= NULL
;
4262 Lisp_Object stock
= Qnil
;
4263 GtkStockItem stock_item
;
4264 char *stock_name
= NULL
;
4265 char *icon_name
= NULL
;
4267 GtkWidget
*wbutton
= NULL
;
4268 Lisp_Object specified_file
;
4269 int vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4271 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4272 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4273 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4276 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4278 /* If this is a separator, use a gtk separator item. */
4279 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4281 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4284 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4286 ti
= gtk_separator_tool_item_new ();
4287 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4293 /* Otherwise, the tool-bar item is an ordinary button. */
4295 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4297 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4301 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4303 /* Ignore invalid image specifications. */
4304 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4305 if (!valid_image_p (image
))
4308 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4313 specified_file
= file_for_image (image
);
4314 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4315 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4317 if (STRINGP (stock
))
4319 stock_name
= SSDATA (stock
);
4320 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4322 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4323 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4325 icon_name
= stock_name
+ 2;
4329 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4332 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4334 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4335 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4343 if (stock_name
== NULL
&& icon_name
== NULL
)
4345 /* No stock image, or stock item not known. Try regular
4346 image. If image is a vector, choose it according to the
4348 if (dir
== GTK_TEXT_DIR_RTL
4349 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4351 image
= find_rtl_image (f
, image
, rtl
);
4353 if (VECTORP (image
))
4357 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4358 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4361 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4362 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4364 xassert (ASIZE (image
) >= idx
);
4365 image
= AREF (image
, idx
);
4370 img_id
= lookup_image (f
, image
);
4371 img
= IMAGE_FROM_ID (f
, img_id
);
4372 prepare_image_for_display (f
, img
);
4374 if (img
->load_failed_p
|| img
->pixmap
== None
)
4377 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4383 /* If there is an existing widget, check if it's stale; if so,
4384 remove it and make a new tool item from scratch. */
4385 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4388 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4397 /* Save the image so we can see if an update is needed the
4398 next time we call xg_tool_item_match_p. */
4399 if (EQ (style
, Qtext
))
4401 else if (stock_name
)
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 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4419 (gpointer
)img
->pixmap
);
4422 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4423 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4424 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4429 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4433 /* Remove buttons not longer needed. */
4436 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4438 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4439 } while (ti
!= NULL
);
4441 if (f
->n_tool_bar_items
!= 0)
4444 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4445 gtk_widget_show_all (GTK_WIDGET (x
->handlebox_widget
));
4446 if (xg_update_tool_bar_sizes (f
))
4447 xg_height_or_width_changed (f
);
4453 /* Deallocate all resources for the tool bar on frame F.
4454 Remove the tool bar. */
4457 free_frame_tool_bar (FRAME_PTR f
)
4459 struct x_output
*x
= f
->output_data
.x
;
4461 if (x
->toolbar_widget
)
4463 int is_packed
= x
->handlebox_widget
!= 0;
4465 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4466 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4469 if (x
->toolbar_in_hbox
)
4470 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4471 x
->handlebox_widget
);
4473 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4474 x
->handlebox_widget
);
4477 gtk_widget_destroy (x
->toolbar_widget
);
4479 x
->toolbar_widget
= 0;
4480 x
->handlebox_widget
= 0;
4481 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4482 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4484 xg_height_or_width_changed (f
);
4491 xg_change_toolbar_position (FRAME_PTR f
, Lisp_Object pos
)
4493 struct x_output
*x
= f
->output_data
.x
;
4495 if (! x
->toolbar_widget
|| ! x
->handlebox_widget
)
4499 g_object_ref (x
->handlebox_widget
);
4500 if (x
->toolbar_in_hbox
)
4501 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4502 x
->handlebox_widget
);
4504 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4505 x
->handlebox_widget
);
4506 xg_pack_tool_bar (f
, pos
);
4507 g_object_unref (x
->handlebox_widget
);
4508 if (xg_update_tool_bar_sizes (f
))
4509 xg_height_or_width_changed (f
);
4517 /***********************************************************************
4519 ***********************************************************************/
4521 xg_initialize (void)
4523 GtkBindingSet
*binding_set
;
4526 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4527 we keep it permanently linked in. */
4532 xg_ignore_gtk_scrollbar
= 0;
4533 xg_detached_menus
= 0;
4534 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4535 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4537 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4538 id_to_widget
.widgets
= 0;
4540 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4541 bindings. It doesn't seem to be any way to remove properties,
4542 so we set it to VoidSymbol which in X means "no key". */
4543 gtk_settings_set_string_property (gtk_settings_get_default (),
4544 "gtk-menu-bar-accel",
4548 /* Make GTK text input widgets use Emacs style keybindings. This is
4550 gtk_settings_set_string_property (gtk_settings_get_default (),
4551 "gtk-key-theme-name",
4555 /* Make dialogs close on C-g. Since file dialog inherits from
4556 dialog, this works for them also. */
4557 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4558 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4561 /* Make menus close on C-g. */
4562 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4563 (GTK_TYPE_MENU_SHELL
));
4564 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4568 #endif /* USE_GTK */