1 /* Functions for creating and updating GTK widgets.
2 Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
29 #include "blockinput.h"
30 #include "syssignal.h"
34 #include "termhooks.h"
38 #include <gdk/gdkkeysyms.h>
41 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
42 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
44 /* Avoid "differ in sign" warnings */
45 #define SSDATA(x) ((char *) SDATA (x))
48 /***********************************************************************
49 Display handling functions
50 ***********************************************************************/
52 #ifdef HAVE_GTK_MULTIDISPLAY
54 /* Return the GdkDisplay that corresponds to the X display DPY. */
57 xg_get_gdk_display (dpy
)
60 return gdk_x11_lookup_xdisplay (dpy
);
63 /* When the GTK widget W is to be created on a display for F that
64 is not the default display, set the display for W.
65 W can be a GtkMenu or a GtkWindow widget. */
72 if (FRAME_X_DISPLAY (f
) != GDK_DISPLAY ())
74 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
75 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
78 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
80 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
85 #else /* not HAVE_GTK_MULTIDISPLAY */
87 /* Make some defines so we can use the GTK 2.2 functions when
88 compiling with GTK 2.0. */
90 #define xg_set_screen(w, f)
91 #define gdk_xid_table_lookup_for_display(dpy, w) gdk_xid_table_lookup (w)
92 #define gdk_pixmap_foreign_new_for_display(dpy, p) gdk_pixmap_foreign_new (p)
93 #define gdk_cursor_new_for_display(dpy, c) gdk_cursor_new (c)
94 #define gdk_x11_lookup_xdisplay(dpy) 0
95 #define GdkDisplay void
97 #endif /* not HAVE_GTK_MULTIDISPLAY */
99 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
100 *DPY is set to NULL if the display can't be opened.
102 Returns non-zero if display could be opened, zero if display could not
103 be opened, and less than zero if the GTK version doesn't support
107 xg_display_open (display_name
, dpy
)
111 #ifdef HAVE_GTK_MULTIDISPLAY
114 gdpy
= gdk_display_open (display_name
);
115 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
119 #else /* not HAVE_GTK_MULTIDISPLAY */
122 #endif /* not HAVE_GTK_MULTIDISPLAY */
126 /* Close display DPY. */
129 xg_display_close (Display
*dpy
)
131 #ifdef HAVE_GTK_MULTIDISPLAY
132 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
134 /* GTK 2.2 has a bug that makes gdk_display_close crash (bug
135 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way
136 we can continue running, but there will be memory leaks. */
138 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 4
140 /* If this is the default display, we must change it before calling
141 dispose, otherwise it will crash. */
142 if (gdk_display_get_default () == gdpy
)
144 struct x_display_info
*dpyinfo
;
145 Display
*new_dpy
= 0;
146 GdkDisplay
*gdpy_new
;
148 /* Find another display. */
149 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
150 if (dpyinfo
->display
!= dpy
)
152 new_dpy
= dpyinfo
->display
;
156 if (! new_dpy
) return; /* Emacs will exit anyway. */
158 gdpy_new
= gdk_x11_lookup_xdisplay (new_dpy
);
159 gdk_display_manager_set_default_display (gdk_display_manager_get (),
163 g_object_run_dispose (G_OBJECT (gdpy
));
166 /* I hope this will be fixed in GTK 2.4. It is what bug 85715 says. */
167 gdk_display_close (gdpy
);
169 #endif /* HAVE_GTK_MULTIDISPLAY */
173 /***********************************************************************
175 ***********************************************************************/
176 /* The timer for scroll bar repetition and menu bar timeouts.
177 NULL if no timer is started. */
178 static struct atimer
*xg_timer
;
181 /* The next two variables and functions are taken from lwlib. */
182 static widget_value
*widget_value_free_list
;
183 static int malloc_cpt
;
185 /* Allocate a widget_value structure, either by taking one from the
186 widget_value_free_list or by malloc:ing a new one.
188 Return a pointer to the allocated structure. */
191 malloc_widget_value ()
194 if (widget_value_free_list
)
196 wv
= widget_value_free_list
;
197 widget_value_free_list
= wv
->free_list
;
202 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
205 memset (wv
, 0, sizeof (widget_value
));
209 /* This is analogous to free. It frees only what was allocated
210 by malloc_widget_value, and no substructures. */
213 free_widget_value (wv
)
221 /* When the number of already allocated cells is too big,
228 wv
->free_list
= widget_value_free_list
;
229 widget_value_free_list
= wv
;
234 /* Create and return the cursor to be used for popup menus and
235 scroll bars on display DPY. */
238 xg_create_default_cursor (dpy
)
241 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
242 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
245 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
248 xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
)
253 int x
, y
, width
, height
, rowstride
, mask_rowstride
;
254 GdkPixbuf
*icon_buf
, *tmp_buf
;
258 gdk_drawable_get_size (gpix
, &width
, &height
);
259 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
260 0, 0, 0, 0, width
, height
);
261 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
262 g_object_unref (G_OBJECT (tmp_buf
));
266 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
271 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
272 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
273 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
274 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
277 for (y
= 0; y
< height
; ++y
)
279 guchar
*iconptr
, *maskptr
;
282 iconptr
= pixels
+ y
* rowstride
;
283 maskptr
= mask_pixels
+ y
* mask_rowstride
;
285 for (x
= 0; x
< width
; ++x
)
287 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
288 just R is sufficient. */
290 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
292 iconptr
+= rowstride
/width
;
293 maskptr
+= mask_rowstride
/width
;
297 g_object_unref (G_OBJECT (mask_buf
));
303 /* For the image defined in IMG, make and return a GtkImage. For displays with
304 8 planes or less we must make a GdkPixbuf and apply the mask manually.
305 Otherwise the highlightning and dimming the tool bar code in GTK does
306 will look bad. For display with more than 8 planes we just use the
307 pixmap and mask directly. For monochrome displays, GTK doesn't seem
308 able to use external pixmaps, it looks bad whatever we do.
309 The image is defined on the display where frame F is.
310 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
311 If OLD_WIDGET is NULL, a new widget is constructed and returned.
312 If OLD_WIDGET is not NULL, that widget is modified. */
315 xg_get_image_for_pixmap (f
, img
, widget
, old_widget
)
319 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
= Qnil
;
331 extern Lisp_Object QCfile
;
333 for (tail
= XCDR (img
->spec
);
334 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
335 tail
= XCDR (XCDR (tail
)))
336 if (EQ (XCAR (tail
), QCfile
))
337 specified_file
= XCAR (XCDR (tail
));
339 /* We already loaded the image once before calling this
340 function, so this only fails if the image file has been removed.
341 In that case, use the pixmap already loaded. */
343 if (STRINGP (specified_file
)
344 && STRINGP (file
= x_find_image_file (specified_file
)))
347 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
349 gtk_image_set_from_file (old_widget
, SSDATA (file
));
351 return GTK_WIDGET (old_widget
);
354 /* No file, do the image handling ourselves. This will look very bad
355 on a monochrome display, and sometimes bad on all displays with
358 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
359 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
360 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
362 if (x_screen_planes (f
) > 8 || x_screen_planes (f
) == 1)
365 old_widget
= GTK_IMAGE (gtk_image_new_from_pixmap (gpix
, gmask
));
367 gtk_image_set_from_pixmap (old_widget
, gpix
, gmask
);
372 /* This is a workaround to make icons look good on pseudo color
373 displays. Apparently GTK expects the images to have an alpha
374 channel. If they don't, insensitive and activated icons will
375 look bad. This workaround does not work on monochrome displays,
376 and is not needed on true color/static color displays (i.e.
377 16 bits and higher). */
378 GdkColormap
*cmap
= gtk_widget_get_colormap (widget
);
379 GdkPixbuf
*icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
382 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
384 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
386 g_object_unref (G_OBJECT (icon_buf
));
389 g_object_unref (G_OBJECT (gpix
));
390 if (gmask
) g_object_unref (G_OBJECT (gmask
));
392 return GTK_WIDGET (old_widget
);
396 /* Set CURSOR on W and all widgets W contain. We must do like this
397 for scroll bars and menu because they create widgets internally,
398 and it is those widgets that are visible. */
401 xg_set_cursor (w
, cursor
)
405 GList
*children
= gdk_window_peek_children (w
->window
);
407 gdk_window_set_cursor (w
->window
, cursor
);
409 /* The scroll bar widget has more than one GDK window (had to look at
410 the source to figure this out), and there is no way to set cursor
411 on widgets in GTK. So we must set the cursor for all GDK windows.
414 for ( ; children
; children
= g_list_next (children
))
415 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
418 /* Timer function called when a timeout occurs for xg_timer.
419 This function processes all GTK events in a recursive event loop.
420 This is done because GTK timer events are not seen by Emacs event
421 detection, Emacs only looks for X events. When a scroll bar has the
422 pointer (detected by button press/release events below) an Emacs
423 timer is started, and this function can then check if the GTK timer
424 has expired by calling the GTK event loop.
425 Also, when a menu is active, it has a small timeout before it
426 pops down the sub menu under it. */
429 xg_process_timeouts (timer
)
430 struct atimer
*timer
;
433 /* Ideally we would like to just handle timer events, like the Xt version
434 of this does in xterm.c, but there is no such feature in GTK. */
435 while (gtk_events_pending ())
436 gtk_main_iteration ();
440 /* Start the xg_timer with an interval of 0.1 seconds, if not already started.
441 xg_process_timeouts is called when the timer expires. The timer
442 started is continuous, i.e. runs until xg_stop_timer is called. */
450 EMACS_SET_SECS_USECS (interval
, 0, 100000);
451 xg_timer
= start_atimer (ATIMER_CONTINUOUS
,
458 /* Stop the xg_timer if started. */
465 cancel_atimer (xg_timer
);
470 /* Insert NODE into linked LIST. */
473 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
475 xg_list_node
*list_start
= list
->next
;
477 if (list_start
) list_start
->prev
= node
;
478 node
->next
= list_start
;
483 /* Remove NODE from linked LIST. */
486 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
488 xg_list_node
*list_start
= list
->next
;
489 if (node
== list_start
)
491 list
->next
= node
->next
;
492 if (list
->next
) list
->next
->prev
= 0;
496 node
->prev
->next
= node
->next
;
497 if (node
->next
) node
->next
->prev
= node
->prev
;
501 /* Allocate and return a utf8 version of STR. If STR is already
502 utf8 or NULL, just return STR.
503 If not, a new string is allocated and the caller must free the result
507 get_utf8_string (str
)
510 char *utf8_str
= str
;
512 /* If not UTF-8, try current locale. */
513 if (str
&& !g_utf8_validate (str
, -1, NULL
))
514 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
521 /***********************************************************************
522 General functions for creating widgets, resizing, events, e.t.c.
523 ***********************************************************************/
525 /* Make a geometry string and pass that to GTK. It seems this is the
526 only way to get geometry position right if the user explicitly
527 asked for a position when starting Emacs.
528 F is the frame we shall set geometry for. */
534 if (f
->size_hint_flags
& USPosition
)
536 int left
= f
->left_pos
;
537 int xneg
= f
->size_hint_flags
& XNegative
;
538 int top
= f
->top_pos
;
539 int yneg
= f
->size_hint_flags
& YNegative
;
547 sprintf (geom_str
, "=%dx%d%c%d%c%d",
548 FRAME_PIXEL_WIDTH (f
),
549 FRAME_TOTAL_PIXEL_HEIGHT (f
),
550 (xneg
? '-' : '+'), left
,
551 (yneg
? '-' : '+'), top
);
553 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
555 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
556 } else if (f
->size_hint_flags
& PPosition
) {
557 gtk_window_move (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
558 f
->left_pos
, f
->top_pos
);
563 /* Resize the outer window of frame F after chainging the height.
564 This happend when the menu bar or the tool bar is added or removed.
565 COLUMNS/ROWS is the size the edit area shall have after the resize. */
568 xg_resize_outer_widget (f
, columns
, rows
)
573 /* If we are not mapped yet, set geometry once again, as window
574 height now have changed. */
575 if (! GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f
)))
578 xg_frame_set_char_size (f
, columns
, rows
);
579 gdk_window_process_all_updates ();
582 /* Function to handle resize of our widgets. Since Emacs has some layouts
583 that does not fit well with GTK standard containers, we do most layout
585 F is the frame to resize.
586 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
589 xg_resize_widgets (f
, pixelwidth
, pixelheight
)
591 int pixelwidth
, pixelheight
;
593 int mbheight
= FRAME_MENUBAR_HEIGHT (f
);
594 int tbheight
= FRAME_TOOLBAR_HEIGHT (f
);
595 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, (pixelheight
596 - mbheight
- tbheight
));
597 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
599 if (FRAME_GTK_WIDGET (f
)
600 && (columns
!= FRAME_COLS (f
)
601 || rows
!= FRAME_LINES (f
)
602 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
603 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
)))
605 struct x_output
*x
= f
->output_data
.x
;
608 all
.y
= mbheight
+ tbheight
;
611 all
.width
= pixelwidth
;
612 all
.height
= pixelheight
- mbheight
- tbheight
;
614 gtk_widget_size_allocate (x
->edit_widget
, &all
);
616 change_frame_size (f
, rows
, columns
, 0, 1, 0);
617 SET_FRAME_GARBAGED (f
);
618 cancel_mouse_face (f
);
623 /* Update our widget size to be COLS/ROWS characters for frame F. */
626 xg_frame_set_char_size (f
, cols
, rows
)
631 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
632 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
635 /* Take into account the size of the scroll bar. Always use the
636 number of columns occupied by the scroll bar here otherwise we
637 might end up with a frame width that is not a multiple of the
638 frame's character width which is bad for vertically split
640 f
->scroll_bar_actual_width
641 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
643 compute_fringe_widths (f
, 0);
645 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
646 after calculating that value. */
647 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
649 /* Must resize our top level widget. Font size may have changed,
650 but not rows/cols. */
651 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
652 pixelwidth
, pixelheight
);
653 xg_resize_widgets (f
, pixelwidth
, pixelheight
);
654 x_wm_set_size_hint (f
, 0, 0);
655 SET_FRAME_GARBAGED (f
);
656 cancel_mouse_face (f
);
659 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
660 Must be done like this, because GtkWidget:s can have "hidden"
661 X Window that aren't accessible.
663 Return 0 if no widget match WDESC. */
666 xg_win_to_widget (dpy
, wdesc
)
671 GtkWidget
*gwdesc
= 0;
675 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
680 event
.any
.window
= gdkwin
;
681 gwdesc
= gtk_get_event_widget (&event
);
688 /* Fill in the GdkColor C so that it represents PIXEL.
689 W is the widget that color will be used for. Used to find colormap. */
692 xg_pix_to_gcolor (w
, pixel
, c
)
697 GdkColormap
*map
= gtk_widget_get_colormap (w
);
698 gdk_colormap_query_color (map
, pixel
, c
);
701 /* Create and set up the GTK widgets for frame F.
702 Return 0 if creation failed, non-zero otherwise. */
705 xg_create_frame_widgets (f
)
718 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
719 xg_set_screen (wtop
, f
);
721 wvbox
= gtk_vbox_new (FALSE
, 0);
722 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
724 if (! wtop
|| ! wvbox
|| ! wfixed
)
726 if (wtop
) gtk_widget_destroy (wtop
);
727 if (wvbox
) gtk_widget_destroy (wvbox
);
728 if (wfixed
) gtk_widget_destroy (wfixed
);
734 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
735 gtk_widget_set_name (wtop
, EMACS_CLASS
);
736 gtk_widget_set_name (wvbox
, "pane");
737 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
739 /* If this frame has a title or name, set it in the title bar. */
740 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
741 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
743 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
745 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
746 FRAME_GTK_WIDGET (f
) = wfixed
;
747 f
->output_data
.x
->vbox_widget
= wvbox
;
749 gtk_fixed_set_has_window (GTK_FIXED (wfixed
), TRUE
);
751 gtk_widget_set_size_request (wfixed
, FRAME_PIXEL_WIDTH (f
),
752 FRAME_PIXEL_HEIGHT (f
));
754 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
755 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
757 if (FRAME_EXTERNAL_TOOL_BAR (f
))
758 update_frame_tool_bar (f
);
760 /* The tool bar is created but first there are no items in it.
761 This causes it to be zero height. Later items are added, but then
762 the frame is already mapped, so there is a "jumping" resize.
763 This makes geometry handling difficult, for example -0-0 will end
764 up in the wrong place as tool bar height has not been taken into account.
765 So we cheat a bit by setting a height that is what it will have
766 later on when tool bar items are added. */
767 if (FRAME_EXTERNAL_TOOL_BAR (f
) && f
->n_tool_bar_items
== 0)
768 FRAME_TOOLBAR_HEIGHT (f
) = 38;
771 /* We don't want this widget double buffered, because we draw on it
772 with regular X drawing primitives, so from a GTK/GDK point of
773 view, the widget is totally blank. When an expose comes, this
774 will make the widget blank, and then Emacs redraws it. This flickers
775 a lot, so we turn off double buffering. */
776 gtk_widget_set_double_buffered (wfixed
, FALSE
);
778 /* GTK documents says use gtk_window_set_resizable. But then a user
779 can't shrink the window from its starting size. */
780 gtk_window_set_policy (GTK_WINDOW (wtop
), TRUE
, TRUE
, TRUE
);
781 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
782 SSDATA (Vx_resource_name
),
783 SSDATA (Vx_resource_class
));
785 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
786 GTK is to destroy the widget. We want Emacs to do that instead. */
787 g_signal_connect (G_OBJECT (wtop
), "delete-event",
788 G_CALLBACK (gtk_true
), 0);
790 /* Convert our geometry parameters into a geometry string
792 GTK will itself handle calculating the real position this way. */
795 gtk_widget_add_events (wfixed
,
796 GDK_POINTER_MOTION_MASK
798 | GDK_BUTTON_PRESS_MASK
799 | GDK_BUTTON_RELEASE_MASK
801 | GDK_ENTER_NOTIFY_MASK
802 | GDK_LEAVE_NOTIFY_MASK
803 | GDK_FOCUS_CHANGE_MASK
805 | GDK_VISIBILITY_NOTIFY_MASK
);
807 /* Must realize the windows so the X window gets created. It is used
808 by callers of this function. */
809 gtk_widget_realize (wfixed
);
810 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
812 /* Since GTK clears its window by filling with the background color,
813 we must keep X and GTK background in sync. */
814 xg_pix_to_gcolor (wfixed
, FRAME_BACKGROUND_PIXEL (f
), &bg
);
815 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
817 /* Also, do not let any background pixmap to be set, this looks very
818 bad as Emacs overwrites the background pixmap with its own idea
819 of background color. */
820 style
= gtk_widget_get_modifier_style (wfixed
);
822 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
823 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
824 gtk_widget_modify_style (wfixed
, style
);
826 /* GTK does not set any border, and they look bad with GTK. */
828 f
->internal_border_width
= 0;
835 /* Set the normal size hints for the window manager, for frame F.
836 FLAGS is the flags word to use--or 0 meaning preserve the flags
837 that the window now has.
838 If USER_POSITION is nonzero, we set the User Position
839 flag (this is useful when FLAGS is 0). */
842 x_wm_set_size_hint (f
, flags
, user_position
)
847 if (FRAME_GTK_OUTER_WIDGET (f
))
849 /* Must use GTK routines here, otherwise GTK resets the size hints
850 to its own defaults. */
851 GdkGeometry size_hints
;
853 int base_width
, base_height
;
854 int min_rows
= 0, min_cols
= 0;
855 int win_gravity
= f
->win_gravity
;
859 memset (&size_hints
, 0, sizeof (size_hints
));
860 f
->output_data
.x
->size_hints
= size_hints
;
861 f
->output_data
.x
->hint_flags
= hint_flags
;
864 flags
= f
->size_hint_flags
;
866 size_hints
= f
->output_data
.x
->size_hints
;
867 hint_flags
= f
->output_data
.x
->hint_flags
;
869 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
870 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
871 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
873 hint_flags
|= GDK_HINT_BASE_SIZE
;
874 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
875 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
876 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
878 check_frame_size (f
, &min_rows
, &min_cols
);
880 size_hints
.base_width
= base_width
;
881 size_hints
.base_height
= base_height
;
882 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
883 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
886 /* These currently have a one to one mapping with the X values, but I
887 don't think we should rely on that. */
888 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
889 size_hints
.win_gravity
= 0;
890 if (win_gravity
== NorthWestGravity
)
891 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
892 else if (win_gravity
== NorthGravity
)
893 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
894 else if (win_gravity
== NorthEastGravity
)
895 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
896 else if (win_gravity
== WestGravity
)
897 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
898 else if (win_gravity
== CenterGravity
)
899 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
900 else if (win_gravity
== EastGravity
)
901 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
902 else if (win_gravity
== SouthWestGravity
)
903 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
904 else if (win_gravity
== SouthGravity
)
905 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
906 else if (win_gravity
== SouthEastGravity
)
907 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
908 else if (win_gravity
== StaticGravity
)
909 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
911 if (flags
& PPosition
) hint_flags
|= GDK_HINT_POS
;
912 if (flags
& USPosition
) hint_flags
|= GDK_HINT_USER_POS
;
913 if (flags
& USSize
) hint_flags
|= GDK_HINT_USER_SIZE
;
917 hint_flags
&= ~GDK_HINT_POS
;
918 hint_flags
|= GDK_HINT_USER_POS
;
923 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
924 FRAME_GTK_OUTER_WIDGET (f
),
928 f
->output_data
.x
->size_hints
= size_hints
;
929 f
->output_data
.x
->hint_flags
= hint_flags
;
934 /* Change background color of a frame.
935 Since GTK uses the background colour to clear the window, we must
936 keep the GTK and X colors in sync.
937 F is the frame to change,
938 BG is the pixel value to change to. */
941 xg_set_background_color (f
, bg
)
945 if (FRAME_GTK_WIDGET (f
))
950 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
951 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
957 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
958 functions so GTK does not overwrite the icon. */
961 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
)
966 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
967 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
968 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
969 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
971 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
976 /***********************************************************************
978 ***********************************************************************/
979 /* Return the dialog title to use for a dialog of type KEY.
980 This is the encoding used by lwlib. We use the same for GTK. */
983 get_dialog_title (char key
)
993 title
= "Information";
1012 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1013 the dialog, but return TRUE so the event does not propagate further
1014 in GTK. This prevents GTK from destroying the dialog widget automatically
1015 and we can always destrou the widget manually, regardles of how
1016 it was popped down (button press or WM_DELETE_WINDOW).
1017 W is the dialog widget.
1018 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1019 user_data is NULL (not used).
1021 Returns TRUE to end propagation of event. */
1024 dialog_delete_callback (w
, event
, user_data
)
1029 gtk_widget_unmap (w
);
1033 /* Create a popup dialog window. See also xg_create_widget below.
1034 WV is a widget_value describing the dialog.
1035 SELECT_CB is the callback to use when a button has been pressed.
1036 DEACTIVATE_CB is the callback to use when the dialog pops down.
1038 Returns the GTK dialog widget. */
1041 create_dialog (wv
, select_cb
, deactivate_cb
)
1043 GCallback select_cb
;
1044 GCallback deactivate_cb
;
1046 char *title
= get_dialog_title (wv
->name
[0]);
1047 int total_buttons
= wv
->name
[1] - '0';
1048 int right_buttons
= wv
->name
[4] - '0';
1051 int button_spacing
= 10;
1052 GtkWidget
*wdialog
= gtk_dialog_new ();
1056 GtkWidget
*whbox_up
;
1057 GtkWidget
*whbox_down
;
1059 /* If the number of buttons is greater than 4, make two rows of buttons
1060 instead. This looks better. */
1061 int make_two_rows
= total_buttons
> 4;
1063 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1064 left_buttons
= total_buttons
- right_buttons
;
1066 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1067 gtk_widget_set_name (wdialog
, "emacs-dialog");
1069 cur_box
= GTK_BOX (GTK_DIALOG (wdialog
)->action_area
);
1073 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1074 whbox_up
= gtk_hbox_new (FALSE
, 0);
1075 whbox_down
= gtk_hbox_new (FALSE
, 0);
1077 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1078 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1079 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1081 cur_box
= GTK_BOX (whbox_up
);
1084 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1085 G_CALLBACK (dialog_delete_callback
), 0);
1089 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1090 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1093 for (item
= wv
->contents
; item
; item
= item
->next
)
1095 char *utf8_label
= get_utf8_string (item
->value
);
1099 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1101 /* This is the text part of the dialog. */
1102 w
= gtk_label_new (utf8_label
);
1103 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1106 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
), w
,
1108 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1110 /* Try to make dialog look better. Must realize first so
1111 the widget can calculate the size it needs. */
1112 gtk_widget_realize (w
);
1113 gtk_widget_size_request (w
, &req
);
1114 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1116 if (item
->value
&& strlen (item
->value
) > 0)
1117 button_spacing
= 2*req
.width
/strlen (item
->value
);
1121 /* This is one button to add to the dialog. */
1122 w
= gtk_button_new_with_label (utf8_label
);
1123 if (! item
->enabled
)
1124 gtk_widget_set_sensitive (w
, FALSE
);
1126 g_signal_connect (G_OBJECT (w
), "clicked",
1127 select_cb
, item
->call_data
);
1129 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1130 if (++button_nr
== left_buttons
)
1133 cur_box
= GTK_BOX (whbox_down
);
1135 gtk_box_pack_start (cur_box
,
1142 if (utf8_label
&& utf8_label
!= item
->value
)
1143 g_free (utf8_label
);
1151 /***********************************************************************
1152 File dialog functions
1153 ***********************************************************************/
1154 /* Return non-zero if the old file selection dialog is being used.
1155 Return zero if not. */
1158 xg_uses_old_file_dialog ()
1160 #ifdef HAVE_GTK_FILE_BOTH
1161 extern int x_use_old_gtk_file_dialog
;
1162 return x_use_old_gtk_file_dialog
;
1163 #else /* ! HAVE_GTK_FILE_BOTH */
1165 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1171 #endif /* ! HAVE_GTK_FILE_BOTH */
1175 /* Function that is called when the file dialog pops down.
1176 W is the dialog widget, RESPONSE is the response code.
1177 USER_DATA is what we passed in to g_signal_connect (pointer to int). */
1180 xg_file_response_cb (w
,
1187 int *ptr
= (int *) user_data
;
1192 /* Destroy the dialog. This makes it pop down. */
1195 pop_down_file_dialog (arg
)
1198 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1200 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1205 typedef char * (*xg_get_file_func
) P_ ((GtkWidget
*));
1207 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1209 /* Return the selected file for file chooser dialog W.
1210 The returned string must be free:d. */
1213 xg_get_file_name_from_chooser (w
)
1216 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1219 /* Callback called when the "Show hidden files" toggle is pressed.
1220 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1223 xg_toggle_visibility_cb (widget
, data
)
1227 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1229 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1230 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1234 /* Callback called when a property changes in a file chooser.
1235 GOBJECT is the file chooser dialog, ARG1 describes the property.
1236 USER_DATA is the toggle widget in the file chooser dialog.
1237 We use this to update the "Show hidden files" toggle when the user
1238 changes that property by right clicking in the file list. */
1241 xg_toggle_notify_cb (gobject
, arg1
, user_data
)
1246 extern int x_gtk_show_hidden_files
;
1248 if (strcmp (arg1
->name
, "show-hidden") == 0)
1250 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (gobject
);
1251 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1252 gboolean visible
, toggle_on
;
1254 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1255 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1257 if (!!visible
!= !!toggle_on
)
1259 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1260 G_CALLBACK (xg_toggle_visibility_cb
),
1262 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1263 g_signal_handlers_unblock_by_func
1264 (G_OBJECT (wtoggle
),
1265 G_CALLBACK (xg_toggle_visibility_cb
),
1268 x_gtk_show_hidden_files
= visible
;
1272 /* Read a file name from the user using a file chooser dialog.
1273 F is the current frame.
1274 PROMPT is a prompt to show to the user. May not be NULL.
1275 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1276 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1277 file. *FUNC is set to a function that can be used to retrieve the
1278 selected file name from the returned widget.
1280 Returns the created widget. */
1283 xg_get_file_with_chooser (f
, prompt
, default_filename
,
1284 mustmatch_p
, only_dir_p
, func
)
1287 char *default_filename
;
1288 int mustmatch_p
, only_dir_p
;
1289 xg_get_file_func
*func
;
1293 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1294 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1295 GtkFileChooserAction action
= (mustmatch_p
?
1296 GTK_FILE_CHOOSER_ACTION_OPEN
:
1297 GTK_FILE_CHOOSER_ACTION_SAVE
);
1298 extern int x_gtk_show_hidden_files
;
1301 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1303 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1304 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1305 (mustmatch_p
|| only_dir_p
?
1306 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1309 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1311 wbox
= gtk_vbox_new (FALSE
, 0);
1312 gtk_widget_show (wbox
);
1313 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1315 if (x_gtk_show_hidden_files
)
1317 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1318 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1320 gtk_widget_show (wtoggle
);
1321 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1322 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1323 g_signal_connect (G_OBJECT (filewin
), "notify",
1324 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1327 if (action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1328 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1329 strcat (message
, "\nIf you don't like this file selector, customize "
1330 "use-file-dialog\nto turn it off, or type C-x C-f to visit files.");
1332 wmessage
= gtk_label_new (message
);
1333 gtk_widget_show (wmessage
);
1334 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1335 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1336 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1338 if (default_filename
)
1341 struct gcpro gcpro1
;
1344 file
= build_string (default_filename
);
1346 /* File chooser does not understand ~/... in the file name. It must be
1347 an absolute name starting with /. */
1348 if (default_filename
[0] != '/')
1349 file
= Fexpand_file_name (file
, Qnil
);
1351 default_filename
= SSDATA (file
);
1352 if (Ffile_directory_p (file
))
1353 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1356 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1362 *func
= xg_get_file_name_from_chooser
;
1365 #endif /* HAVE_GTK_FILE_CHOOSER_DIALOG_NEW */
1367 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1369 /* Return the selected file for file selector dialog W.
1370 The returned string must be free:d. */
1373 xg_get_file_name_from_selector (w
)
1376 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1377 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1380 /* Create a file selection dialog.
1381 F is the current frame.
1382 PROMPT is a prompt to show to the user. May not be NULL.
1383 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1384 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1385 file. *FUNC is set to a function that can be used to retrieve the
1386 selected file name from the returned widget.
1388 Returns the created widget. */
1391 xg_get_file_with_selection (f
, prompt
, default_filename
,
1392 mustmatch_p
, only_dir_p
, func
)
1395 char *default_filename
;
1396 int mustmatch_p
, only_dir_p
;
1397 xg_get_file_func
*func
;
1400 GtkFileSelection
*filesel
;
1402 filewin
= gtk_file_selection_new (prompt
);
1403 filesel
= GTK_FILE_SELECTION (filewin
);
1405 if (default_filename
)
1406 gtk_file_selection_set_filename (filesel
, default_filename
);
1410 /* The selection_entry part of filesel is not documented. */
1411 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1412 gtk_file_selection_hide_fileop_buttons (filesel
);
1415 *func
= xg_get_file_name_from_selector
;
1419 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1421 /* Read a file name from the user using a file dialog, either the old
1422 file selection dialog, or the new file chooser dialog. Which to use
1423 depends on what the GTK version used has, and what the value of
1424 gtk-use-old-file-dialog.
1425 F is the current frame.
1426 PROMPT is a prompt to show to the user. May not be NULL.
1427 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1428 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1431 Returns a file name or NULL if no file was selected.
1432 The returned string must be freed by the caller. */
1435 xg_get_file_name (f
, prompt
, default_filename
, mustmatch_p
, only_dir_p
)
1438 char *default_filename
;
1439 int mustmatch_p
, only_dir_p
;
1442 int count
= SPECPDL_INDEX ();
1444 int filesel_done
= 0;
1445 xg_get_file_func func
;
1447 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1448 /* I really don't know why this is needed, but without this the GLIBC add on
1449 library linuxthreads hangs when the Gnome file chooser backend creates
1451 sigblock (sigmask (__SIGRTMIN
));
1452 #endif /* HAVE_GTK_AND_PTHREAD */
1454 #ifdef HAVE_GTK_FILE_BOTH
1456 if (xg_uses_old_file_dialog ())
1457 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1458 mustmatch_p
, only_dir_p
, &func
);
1460 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1461 mustmatch_p
, only_dir_p
, &func
);
1463 #else /* not HAVE_GTK_FILE_BOTH */
1465 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1466 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1467 mustmatch_p
, only_dir_p
, &func
);
1469 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1470 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1471 mustmatch_p
, only_dir_p
, &func
);
1474 #endif /* HAVE_GTK_FILE_BOTH */
1476 xg_set_screen (w
, f
);
1477 gtk_widget_set_name (w
, "emacs-filedialog");
1478 gtk_window_set_transient_for (GTK_WINDOW (w
),
1479 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1480 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1481 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1483 g_signal_connect (G_OBJECT (w
),
1485 G_CALLBACK (xg_file_response_cb
),
1488 /* Don't destroy the widget if closed by the window manager close button. */
1489 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1491 gtk_widget_show (w
);
1493 record_unwind_protect (pop_down_file_dialog
, make_save_value (w
, 0));
1494 while (! filesel_done
)
1496 x_menu_wait_for_event (0);
1497 gtk_main_iteration ();
1500 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1501 sigunblock (sigmask (__SIGRTMIN
));
1504 if (filesel_done
== GTK_RESPONSE_OK
)
1507 unbind_to (count
, Qnil
);
1513 /***********************************************************************
1515 ***********************************************************************/
1517 /* The name of menu items that can be used for citomization. Since GTK
1518 RC files are very crude and primitive, we have to set this on all
1519 menu item names so a user can easily cutomize menu items. */
1521 #define MENU_ITEM_NAME "emacs-menuitem"
1524 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1525 during GC. The next member points to the items. */
1526 static xg_list_node xg_menu_cb_list
;
1528 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1529 during GC. The next member points to the items. */
1530 static xg_list_node xg_menu_item_cb_list
;
1532 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1533 F is the frame CL_DATA will be initialized for.
1534 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1536 The menu bar and all sub menus under the menu bar in a frame
1537 share the same structure, hence the reference count.
1539 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1540 allocated xg_menu_cb_data if CL_DATA is NULL. */
1542 static xg_menu_cb_data
*
1543 make_cl_data (cl_data
, f
, highlight_cb
)
1544 xg_menu_cb_data
*cl_data
;
1546 GCallback highlight_cb
;
1550 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1552 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1553 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1554 cl_data
->highlight_cb
= highlight_cb
;
1555 cl_data
->ref_count
= 0;
1557 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1560 cl_data
->ref_count
++;
1565 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1566 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1568 When the menu bar is updated, menu items may have been added and/or
1569 removed, so menu_bar_vector and menu_bar_items_used change. We must
1570 then update CL_DATA since it is used to determine which menu
1571 item that is invoked in the menu.
1572 HIGHLIGHT_CB could change, there is no check that the same
1573 function is given when modifying a menu bar as was given when
1574 creating the menu bar. */
1577 update_cl_data (cl_data
, f
, highlight_cb
)
1578 xg_menu_cb_data
*cl_data
;
1580 GCallback highlight_cb
;
1585 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1586 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1587 cl_data
->highlight_cb
= highlight_cb
;
1591 /* Decrease reference count for CL_DATA.
1592 If reference count is zero, free CL_DATA. */
1595 unref_cl_data (cl_data
)
1596 xg_menu_cb_data
*cl_data
;
1598 if (cl_data
&& cl_data
->ref_count
> 0)
1600 cl_data
->ref_count
--;
1601 if (cl_data
->ref_count
== 0)
1603 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1609 /* Function that marks all lisp data during GC. */
1616 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1617 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1619 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1621 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1623 if (! NILP (cb_data
->help
))
1624 mark_object (cb_data
->help
);
1629 /* Callback called when a menu item is destroyed. Used to free data.
1630 W is the widget that is being destroyed (not used).
1631 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1634 menuitem_destroy_callback (w
, client_data
)
1636 gpointer client_data
;
1640 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1641 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1646 /* Callback called when the pointer enters/leaves a menu item.
1648 EVENT is either an enter event or leave event.
1649 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W.
1651 Returns FALSE to tell GTK to keep processing this event. */
1654 menuitem_highlight_callback (w
, event
, client_data
)
1656 GdkEventCrossing
*event
;
1657 gpointer client_data
;
1661 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1662 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : client_data
;
1664 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1666 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1667 (*func
) (w
, call_data
);
1674 /* Callback called when a menu is destroyed. Used to free data.
1675 W is the widget that is being destroyed (not used).
1676 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1679 menu_destroy_callback (w
, client_data
)
1681 gpointer client_data
;
1683 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1686 /* Callback called when a menu does a grab or ungrab. That means the
1687 menu has been activated or deactivated.
1688 Used to start a timer so the small timeout the menus in GTK uses before
1689 popping down a menu is seen by Emacs (see xg_process_timeouts above).
1690 W is the widget that does the grab (not used).
1691 UNGRAB_P is TRUE if this is an ungrab, FALSE if it is a grab.
1692 CLIENT_DATA is NULL (not used). */
1695 menu_grab_callback (GtkWidget
*widget
,
1697 gpointer client_data
)
1699 /* Keep track of total number of grabs. */
1702 if (ungrab_p
) cnt
--;
1705 if (cnt
> 0 && ! xg_timer
) xg_start_timer ();
1706 else if (cnt
== 0 && xg_timer
) xg_stop_timer ();
1709 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1710 must be non-NULL) and can be inserted into a menu item.
1712 Returns the GtkHBox. */
1715 make_widget_for_menu_item (utf8_label
, utf8_key
)
1723 wbox
= gtk_hbox_new (FALSE
, 0);
1724 wlbl
= gtk_label_new (utf8_label
);
1725 wkey
= gtk_label_new (utf8_key
);
1727 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1728 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1730 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1731 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1733 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1734 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1735 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1740 /* Make and return a menu item widget with the key to the right.
1741 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1742 UTF8_KEY is the text representing the key binding.
1743 ITEM is the widget_value describing the menu item.
1745 GROUP is an in/out parameter. If the menu item to be created is not
1746 part of any radio menu group, *GROUP contains NULL on entry and exit.
1747 If the menu item to be created is part of a radio menu group, on entry
1748 *GROUP contains the group to use, or NULL if this is the first item
1749 in the group. On exit, *GROUP contains the radio item group.
1751 Unfortunately, keys don't line up as nicely as in Motif,
1752 but the MacOS X version doesn't either, so I guess that is OK. */
1755 make_menu_item (utf8_label
, utf8_key
, item
, group
)
1762 GtkWidget
*wtoadd
= 0;
1764 /* It has been observed that some menu items have a NULL name field.
1765 This will lead to this function being called with a NULL utf8_label.
1766 GTK crashes on that so we set a blank label. Why there is a NULL
1767 name remains to be investigated. */
1768 if (! utf8_label
) utf8_label
= " ";
1771 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1773 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1776 if (utf8_key
) w
= gtk_check_menu_item_new ();
1777 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1778 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1780 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1782 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1783 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1784 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1786 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1791 if (utf8_key
) w
= gtk_menu_item_new ();
1792 else w
= gtk_menu_item_new_with_label (utf8_label
);
1795 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1796 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1801 /* Return non-zero if LABEL specifies a separator (GTK only has one
1805 xg_separator_p (char *label
)
1807 if (! label
) return 0;
1808 else if (strlen (label
) > 3
1809 && strncmp (label
, "--", 2) == 0
1812 static char* separator_names
[] = {
1817 "single-dashed-line",
1818 "double-dashed-line",
1820 "shadow-etched-out",
1821 "shadow-etched-in-dash",
1822 "shadow-etched-out-dash",
1823 "shadow-double-etched-in",
1824 "shadow-double-etched-out",
1825 "shadow-double-etched-in-dash",
1826 "shadow-double-etched-out-dash",
1833 for (i
= 0; separator_names
[i
]; ++i
)
1834 if (strcmp (label
, separator_names
[i
]) == 0)
1839 /* Old-style separator, maybe. It's a separator if it contains
1841 while (*label
== '-')
1843 if (*label
== 0) return 1;
1849 static int xg_detached_menus
;
1851 /* Returns non-zero if there are detached menus. */
1854 xg_have_tear_offs ()
1856 return xg_detached_menus
> 0;
1859 /* Callback invoked when a detached menu window is removed. Here we
1860 decrease the xg_detached_menus count.
1861 WIDGET is the top level window that is removed (the parent of the menu).
1862 CLIENT_DATA is not used. */
1865 tearoff_remove (widget
, client_data
)
1867 gpointer client_data
;
1869 if (xg_detached_menus
> 0) --xg_detached_menus
;
1872 /* Callback invoked when a menu is detached. It increases the
1873 xg_detached_menus count.
1874 WIDGET is the GtkTearoffMenuItem.
1875 CLIENT_DATA is not used. */
1878 tearoff_activate (widget
, client_data
)
1880 gpointer client_data
;
1882 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
1883 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
1885 ++xg_detached_menus
;
1886 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
1888 G_CALLBACK (tearoff_remove
), 0);
1893 /* Create a menu item widget, and connect the callbacks.
1894 ITEM decribes the menu item.
1895 F is the frame the created menu belongs to.
1896 SELECT_CB is the callback to use when a menu item is selected.
1897 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1898 CL_DATA points to the callback data to be used for this menu.
1899 GROUP is an in/out parameter. If the menu item to be created is not
1900 part of any radio menu group, *GROUP contains NULL on entry and exit.
1901 If the menu item to be created is part of a radio menu group, on entry
1902 *GROUP contains the group to use, or NULL if this is the first item
1903 in the group. On exit, *GROUP contains the radio item group.
1905 Returns the created GtkWidget. */
1908 xg_create_one_menuitem (item
, f
, select_cb
, highlight_cb
, cl_data
, group
)
1911 GCallback select_cb
;
1912 GCallback highlight_cb
;
1913 xg_menu_cb_data
*cl_data
;
1919 xg_menu_item_cb_data
*cb_data
;
1921 utf8_label
= get_utf8_string (item
->name
);
1922 utf8_key
= get_utf8_string (item
->key
);
1924 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
1926 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
1927 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
1929 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
1931 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
1933 cb_data
->unhighlight_id
= cb_data
->highlight_id
= cb_data
->select_id
= 0;
1934 cb_data
->help
= item
->help
;
1935 cb_data
->cl_data
= cl_data
;
1936 cb_data
->call_data
= item
->call_data
;
1938 g_signal_connect (G_OBJECT (w
),
1940 G_CALLBACK (menuitem_destroy_callback
),
1943 /* Put cb_data in widget, so we can get at it when modifying menubar */
1944 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
1946 /* final item, not a submenu */
1947 if (item
->call_data
&& ! item
->contents
)
1951 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
1954 if (! NILP (item
->help
) && highlight_cb
)
1956 /* We use enter/leave notify instead of select/deselect because
1957 select/deselect doesn't go well with detached menus. */
1958 cb_data
->highlight_id
1959 = g_signal_connect (G_OBJECT (w
),
1960 "enter-notify-event",
1961 G_CALLBACK (menuitem_highlight_callback
),
1963 cb_data
->unhighlight_id
1964 = g_signal_connect (G_OBJECT (w
),
1965 "leave-notify-event",
1966 G_CALLBACK (menuitem_highlight_callback
),
1973 /* Callback called when keyboard traversal (started by menu-bar-open) ends.
1974 WMENU is the menu for which traversal has been done. DATA points to the
1975 frame for WMENU. We must release grabs, some bad interaction between GTK
1976 and Emacs makes the menus keep the grabs. */
1979 menu_nav_ended (wmenu
, data
)
1980 GtkMenuShell
*wmenu
;
1983 FRAME_PTR f
= (FRAME_PTR
) data
;
1985 if (FRAME_X_OUTPUT (f
)->menubar_widget
)
1987 GtkMenuShell
*w
= GTK_MENU_SHELL (FRAME_X_OUTPUT (f
)->menubar_widget
);
1988 Display
*dpy
= FRAME_X_DISPLAY (f
);
1991 gtk_menu_shell_deactivate (w
);
1992 gtk_menu_shell_deselect (w
);
1994 XUngrabKeyboard (dpy
, CurrentTime
);
1995 XUngrabPointer (dpy
, CurrentTime
);
2001 static GtkWidget
*create_menus
P_ ((widget_value
*, FRAME_PTR
, GCallback
,
2002 GCallback
, GCallback
, int, int, int,
2003 GtkWidget
*, xg_menu_cb_data
*, char *));
2005 /* Create a full menu tree specified by DATA.
2006 F is the frame the created menu belongs to.
2007 SELECT_CB is the callback to use when a menu item is selected.
2008 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2009 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2010 POP_UP_P is non-zero if we shall create a popup menu.
2011 MENU_BAR_P is non-zero if we shall create a menu bar.
2012 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2013 if MENU_BAR_P is non-zero.
2014 TOPMENU is the topmost GtkWidget that others shall be placed under.
2015 It may be NULL, in that case we create the appropriate widget
2016 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2017 CL_DATA is the callback data we shall use for this menu, or NULL
2018 if we haven't set the first callback yet.
2019 NAME is the name to give to the top level menu if this function
2020 creates it. May be NULL to not set any name.
2022 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2025 This function calls itself to create submenus. */
2028 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2029 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
2032 GCallback select_cb
;
2033 GCallback deactivate_cb
;
2034 GCallback highlight_cb
;
2039 xg_menu_cb_data
*cl_data
;
2043 GtkWidget
*wmenu
= topmenu
;
2044 GSList
*group
= NULL
;
2050 wmenu
= gtk_menu_new ();
2051 xg_set_screen (wmenu
, f
);
2053 else wmenu
= gtk_menu_bar_new ();
2055 /* Fix up grabs after keyboard traversal ends. */
2056 g_signal_connect (G_OBJECT (wmenu
),
2058 G_CALLBACK (menu_nav_ended
),
2061 /* Put cl_data on the top menu for easier access. */
2062 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2063 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2064 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2065 G_CALLBACK (menu_destroy_callback
), cl_data
);
2068 gtk_widget_set_name (wmenu
, name
);
2071 g_signal_connect (G_OBJECT (wmenu
),
2072 "selection-done", deactivate_cb
, 0);
2074 g_signal_connect (G_OBJECT (wmenu
),
2075 "grab-notify", G_CALLBACK (menu_grab_callback
), 0);
2078 if (! menu_bar_p
&& add_tearoff_p
)
2080 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2081 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2083 g_signal_connect (G_OBJECT (tearoff
), "activate",
2084 G_CALLBACK (tearoff_activate
), 0);
2087 for (item
= data
; item
; item
= item
->next
)
2091 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2092 && !xg_separator_p (item
->name
))
2095 /* A title for a popup. We do the same as GTK does when
2096 creating titles, but it does not look good. */
2098 utf8_label
= get_utf8_string (item
->name
);
2100 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2101 w
= gtk_menu_item_new_with_label (utf8_label
);
2102 gtk_widget_set_sensitive (w
, FALSE
);
2103 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2105 else if (xg_separator_p (item
->name
))
2108 /* GTK only have one separator type. */
2109 w
= gtk_separator_menu_item_new ();
2113 w
= xg_create_one_menuitem (item
,
2115 item
->contents
? 0 : select_cb
,
2122 GtkWidget
*submenu
= create_menus (item
->contents
,
2133 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2137 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2138 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2144 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2145 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2146 with some text and buttons.
2147 F is the frame the created item belongs to.
2148 NAME is the name to use for the top widget.
2149 VAL is a widget_value structure describing items to be created.
2150 SELECT_CB is the callback to use when a menu item is selected or
2151 a dialog button is pressed.
2152 DEACTIVATE_CB is the callback to use when an item is deactivated.
2153 For a menu, when a sub menu is not shown anymore, for a dialog it is
2154 called when the dialog is popped down.
2155 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2157 Returns the widget created. */
2160 xg_create_widget (type
, name
, f
, val
,
2161 select_cb
, deactivate_cb
, highlight_cb
)
2166 GCallback select_cb
;
2167 GCallback deactivate_cb
;
2168 GCallback highlight_cb
;
2171 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2172 int pop_up_p
= strcmp (type
, "popup") == 0;
2174 if (strcmp (type
, "dialog") == 0)
2176 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2177 xg_set_screen (w
, f
);
2178 gtk_window_set_transient_for (GTK_WINDOW (w
),
2179 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2180 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2181 gtk_widget_set_name (w
, "emacs-dialog");
2182 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2184 else if (menu_bar_p
|| pop_up_p
)
2186 w
= create_menus (val
->contents
,
2198 /* Set the cursor to an arrow for popup menus when they are mapped.
2199 This is done by default for menu bar menus. */
2202 /* Must realize so the GdkWindow inside the widget is created. */
2203 gtk_widget_realize (w
);
2204 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2209 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2216 /* Return the label for menu item WITEM. */
2219 xg_get_menu_item_label (witem
)
2222 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2223 return gtk_label_get_label (wlabel
);
2226 /* Return non-zero if the menu item WITEM has the text LABEL. */
2229 xg_item_label_same_p (witem
, label
)
2234 char *utf8_label
= get_utf8_string (label
);
2235 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2237 if (! old_label
&& ! utf8_label
)
2239 else if (old_label
&& utf8_label
)
2240 is_same
= strcmp (utf8_label
, old_label
) == 0;
2242 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2247 /* Destroy widgets in LIST. */
2250 xg_destroy_widgets (list
)
2255 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2257 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2259 /* Destroying the widget will remove it from the container it is in. */
2260 gtk_widget_destroy (w
);
2264 /* Update the top level names in MENUBAR (i.e. not submenus).
2265 F is the frame the menu bar belongs to.
2266 *LIST is a list with the current menu bar names (menu item widgets).
2267 ITER is the item within *LIST that shall be updated.
2268 POS is the numerical position, starting at 0, of ITER in *LIST.
2269 VAL describes what the menu bar shall look like after the update.
2270 SELECT_CB is the callback to use when a menu item is selected.
2271 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2272 CL_DATA points to the callback data to be used for this menu bar.
2274 This function calls itself to walk through the menu bar names. */
2277 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2278 select_cb
, highlight_cb
, cl_data
)
2285 GCallback select_cb
;
2286 GCallback highlight_cb
;
2287 xg_menu_cb_data
*cl_data
;
2289 if (! iter
&& ! val
)
2291 else if (iter
&& ! val
)
2293 /* Item(s) have been removed. Remove all remaining items. */
2294 xg_destroy_widgets (iter
);
2300 else if (! iter
&& val
)
2302 /* Item(s) added. Add all new items in one call. */
2303 create_menus (val
, f
, select_cb
, 0, highlight_cb
,
2304 0, 1, 0, menubar
, cl_data
, 0);
2310 /* Below this neither iter or val is NULL */
2311 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2313 /* This item is still the same, check next item. */
2315 iter
= g_list_next (iter
);
2318 else /* This item is changed. */
2320 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2321 GtkMenuItem
*witem2
= 0;
2322 int val_in_menubar
= 0;
2323 int iter_in_new_menubar
= 0;
2327 /* See if the changed entry (val) is present later in the menu bar */
2329 iter2
&& ! val_in_menubar
;
2330 iter2
= g_list_next (iter2
))
2332 witem2
= GTK_MENU_ITEM (iter2
->data
);
2333 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2336 /* See if the current entry (iter) is present later in the
2337 specification for the new menu bar. */
2338 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2339 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2341 if (val_in_menubar
&& ! iter_in_new_menubar
)
2345 /* This corresponds to:
2350 gtk_widget_ref (GTK_WIDGET (witem
));
2351 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2352 gtk_widget_destroy (GTK_WIDGET (witem
));
2354 /* Must get new list since the old changed. */
2355 g_list_free (*list
);
2356 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2357 while (nr
-- > 0) iter
= g_list_next (iter
);
2359 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2361 /* This corresponds to:
2364 Rename B to X. This might seem to be a strange thing to do,
2365 since if there is a menu under B it will be totally wrong for X.
2366 But consider editing a C file. Then there is a C-mode menu
2367 (corresponds to B above).
2368 If then doing C-x C-f the minibuf menu (X above) replaces the
2369 C-mode menu. When returning from the minibuffer, we get
2370 back the C-mode menu. Thus we do:
2371 Rename B to X (C-mode to minibuf menu)
2372 Rename X to B (minibuf to C-mode menu).
2373 If the X menu hasn't been invoked, the menu under B
2374 is up to date when leaving the minibuffer. */
2375 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2376 char *utf8_label
= get_utf8_string (val
->name
);
2377 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2379 gtk_label_set_text (wlabel
, utf8_label
);
2381 /* If this item has a submenu that has been detached, change
2382 the title in the WM decorations also. */
2383 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2384 /* Set the title of the detached window. */
2385 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2387 iter
= g_list_next (iter
);
2391 else if (! val_in_menubar
&& iter_in_new_menubar
)
2393 /* This corresponds to:
2400 GtkWidget
*w
= xg_create_one_menuitem (val
,
2407 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2408 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2410 g_list_free (*list
);
2411 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2412 while (nr
-- > 0) iter
= g_list_next (iter
);
2413 iter
= g_list_next (iter
);
2417 else /* if (val_in_menubar && iter_in_new_menubar) */
2420 /* This corresponds to:
2425 gtk_widget_ref (GTK_WIDGET (witem2
));
2426 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2427 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2428 GTK_WIDGET (witem2
), pos
);
2429 gtk_widget_unref (GTK_WIDGET (witem2
));
2431 g_list_free (*list
);
2432 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2433 while (nr
-- > 0) iter
= g_list_next (iter
);
2439 /* Update the rest of the menu bar. */
2440 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2441 select_cb
, highlight_cb
, cl_data
);
2444 /* Update the menu item W so it corresponds to VAL.
2445 SELECT_CB is the callback to use when a menu item is selected.
2446 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2447 CL_DATA is the data to set in the widget for menu invokation. */
2450 xg_update_menu_item (val
, w
, select_cb
, highlight_cb
, cl_data
)
2453 GCallback select_cb
;
2454 GCallback highlight_cb
;
2455 xg_menu_cb_data
*cl_data
;
2462 const char *old_label
= 0;
2463 const char *old_key
= 0;
2464 xg_menu_item_cb_data
*cb_data
;
2466 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2467 utf8_label
= get_utf8_string (val
->name
);
2468 utf8_key
= get_utf8_string (val
->key
);
2470 /* See if W is a menu item with a key. See make_menu_item above. */
2471 if (GTK_IS_HBOX (wchild
))
2473 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2475 wlbl
= GTK_LABEL (list
->data
);
2476 wkey
= GTK_LABEL (list
->next
->data
);
2481 /* Remove the key and keep just the label. */
2482 gtk_widget_ref (GTK_WIDGET (wlbl
));
2483 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2484 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2489 else /* Just a label. */
2491 wlbl
= GTK_LABEL (wchild
);
2493 /* Check if there is now a key. */
2496 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2497 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2499 wlbl
= GTK_LABEL (list
->data
);
2500 wkey
= GTK_LABEL (list
->next
->data
);
2503 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2504 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2509 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2510 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2512 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2513 gtk_label_set_text (wkey
, utf8_key
);
2515 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2516 gtk_label_set_text (wlbl
, utf8_label
);
2518 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2519 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2521 if (! val
->enabled
&& GTK_WIDGET_SENSITIVE (w
))
2522 gtk_widget_set_sensitive (w
, FALSE
);
2523 else if (val
->enabled
&& ! GTK_WIDGET_SENSITIVE (w
))
2524 gtk_widget_set_sensitive (w
, TRUE
);
2526 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2530 cb_data
->call_data
= val
->call_data
;
2531 cb_data
->help
= val
->help
;
2532 cb_data
->cl_data
= cl_data
;
2534 /* We assume the callback functions don't change. */
2535 if (val
->call_data
&& ! val
->contents
)
2537 /* This item shall have a select callback. */
2538 if (! cb_data
->select_id
)
2540 = g_signal_connect (G_OBJECT (w
), "activate",
2541 select_cb
, cb_data
);
2543 else if (cb_data
->select_id
)
2545 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2546 cb_data
->select_id
= 0;
2549 if (NILP (cb_data
->help
))
2551 /* Shall not have help. Remove if any existed previously. */
2552 if (cb_data
->highlight_id
)
2554 g_signal_handler_disconnect (G_OBJECT (w
),
2555 cb_data
->highlight_id
);
2556 cb_data
->highlight_id
= 0;
2558 if (cb_data
->unhighlight_id
)
2560 g_signal_handler_disconnect (G_OBJECT (w
),
2561 cb_data
->unhighlight_id
);
2562 cb_data
->unhighlight_id
= 0;
2565 else if (! cb_data
->highlight_id
&& highlight_cb
)
2567 /* Have help now, but didn't previously. Add callback. */
2568 cb_data
->highlight_id
2569 = g_signal_connect (G_OBJECT (w
),
2570 "enter-notify-event",
2571 G_CALLBACK (menuitem_highlight_callback
),
2573 cb_data
->unhighlight_id
2574 = g_signal_connect (G_OBJECT (w
),
2575 "leave-notify-event",
2576 G_CALLBACK (menuitem_highlight_callback
),
2582 /* Update the toggle menu item W so it corresponds to VAL. */
2585 xg_update_toggle_item (val
, w
)
2589 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2592 /* Update the radio menu item W so it corresponds to VAL. */
2595 xg_update_radio_item (val
, w
)
2599 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2602 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2603 SUBMENU may be NULL, in that case a new menu is created.
2604 F is the frame the menu bar belongs to.
2605 VAL describes the contents of the menu bar.
2606 SELECT_CB is the callback to use when a menu item is selected.
2607 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2608 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2609 CL_DATA is the call back data to use for any newly created items.
2611 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2615 xg_update_submenu (submenu
, f
, val
,
2616 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2620 GCallback select_cb
;
2621 GCallback deactivate_cb
;
2622 GCallback highlight_cb
;
2623 xg_menu_cb_data
*cl_data
;
2625 GtkWidget
*newsub
= submenu
;
2629 int has_tearoff_p
= 0;
2630 GList
*first_radio
= 0;
2633 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2635 for (cur
= val
, iter
= list
;
2637 iter
= g_list_next (iter
), cur
= cur
->next
)
2639 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2641 /* Skip tearoff items, they have no counterpart in val. */
2642 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2645 iter
= g_list_next (iter
);
2646 if (iter
) w
= GTK_WIDGET (iter
->data
);
2650 /* Remember first radio button in a group. If we get a mismatch in
2651 a radio group we must rebuild the whole group so that the connections
2652 in GTK becomes correct. */
2653 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2655 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2656 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2659 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2661 if (! xg_separator_p (cur
->name
))
2664 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2666 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2668 xg_update_toggle_item (cur
, w
);
2669 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2671 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2673 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2675 xg_update_radio_item (cur
, w
);
2676 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2678 else if (GTK_IS_MENU_ITEM (w
))
2680 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2683 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2684 xg_separator_p (cur
->name
))
2687 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2689 sub
= gtk_menu_item_get_submenu (witem
);
2690 if (sub
&& ! cur
->contents
)
2692 /* Not a submenu anymore. */
2693 gtk_widget_ref (sub
);
2694 gtk_menu_item_remove_submenu (witem
);
2695 gtk_widget_destroy (sub
);
2697 else if (cur
->contents
)
2701 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2702 select_cb
, deactivate_cb
,
2703 highlight_cb
, cl_data
);
2705 /* If this item just became a submenu, we must set it. */
2707 gtk_menu_item_set_submenu (witem
, nsub
);
2712 /* Structural difference. Remove everything from here and down
2718 /* Remove widgets from first structual change. */
2721 /* If we are adding new menu items below, we must remove from
2722 first radio button so that radio groups become correct. */
2723 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2724 else xg_destroy_widgets (iter
);
2729 /* More items added. Create them. */
2730 newsub
= create_menus (cur
,
2743 if (list
) g_list_free (list
);
2748 /* Update the MENUBAR.
2749 F is the frame the menu bar belongs to.
2750 VAL describes the contents of the menu bar.
2751 If DEEP_P is non-zero, rebuild all but the top level menu names in
2752 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2753 SELECT_CB is the callback to use when a menu item is selected.
2754 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2755 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2758 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2759 select_cb
, deactivate_cb
, highlight_cb
)
2764 GCallback select_cb
;
2765 GCallback deactivate_cb
;
2766 GCallback highlight_cb
;
2768 xg_menu_cb_data
*cl_data
;
2769 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2773 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2776 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2777 select_cb
, highlight_cb
, cl_data
);
2783 /* Update all sub menus.
2784 We must keep the submenus (GTK menu item widgets) since the
2785 X Window in the XEvent that activates the menu are those widgets. */
2787 /* Update cl_data, menu_item things in F may have changed. */
2788 update_cl_data (cl_data
, f
, highlight_cb
);
2790 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2797 /* Find sub menu that corresponds to val and update it. */
2798 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2800 witem
= GTK_MENU_ITEM (iter
->data
);
2801 if (xg_item_label_same_p (witem
, cur
->name
))
2803 sub
= gtk_menu_item_get_submenu (witem
);
2808 newsub
= xg_update_submenu (sub
,
2815 /* sub may still be NULL. If we just updated non deep and added
2816 a new menu bar item, it has no sub menu yet. So we set the
2817 newly created sub menu under witem. */
2820 xg_set_screen (newsub
, f
);
2821 gtk_menu_item_set_submenu (witem
, newsub
);
2827 gtk_widget_show_all (menubar
);
2830 /* Recompute all the widgets of frame F, when the menu bar has been
2831 changed. Value is non-zero if widgets were updated. */
2834 xg_update_frame_menubar (f
)
2837 struct x_output
*x
= f
->output_data
.x
;
2840 if (!x
->menubar_widget
|| GTK_WIDGET_MAPPED (x
->menubar_widget
))
2845 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2847 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2849 gtk_widget_show_all (x
->menubar_widget
);
2850 gtk_widget_size_request (x
->menubar_widget
, &req
);
2852 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2854 /* The height has changed, resize outer widget and set columns
2855 rows to what we had before adding the menu bar. */
2856 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2858 SET_FRAME_GARBAGED (f
);
2864 /* Get rid of the menu bar of frame F, and free its storage.
2865 This is used when deleting a frame, and when turning off the menu bar. */
2868 free_frame_menubar (f
)
2871 struct x_output
*x
= f
->output_data
.x
;
2873 if (x
->menubar_widget
)
2877 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2878 /* The menubar and its children shall be deleted when removed from
2880 x
->menubar_widget
= 0;
2881 FRAME_MENUBAR_HEIGHT (f
) = 0;
2883 /* The height has changed, resize outer widget and set columns
2884 rows to what we had before removing the menu bar. */
2885 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2887 SET_FRAME_GARBAGED (f
);
2894 /***********************************************************************
2895 Scroll bar functions
2896 ***********************************************************************/
2899 /* Setting scroll bar values invokes the callback. Use this variable
2900 to indicate that callback should do nothing. */
2902 int xg_ignore_gtk_scrollbar
;
2904 /* SET_SCROLL_BAR_X_WINDOW assumes the second argument fits in
2905 32 bits. But we want to store pointers, and they may be larger
2906 than 32 bits. Keep a mapping from integer index to widget pointers
2907 to get around the 32 bit limitation. */
2911 GtkWidget
**widgets
;
2916 /* Grow this much every time we need to allocate more */
2918 #define ID_TO_WIDGET_INCR 32
2920 /* Store the widget pointer W in id_to_widget and return the integer index. */
2923 xg_store_widget_in_map (w
)
2928 if (id_to_widget
.max_size
== id_to_widget
.used
)
2930 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
2932 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
2933 sizeof (GtkWidget
*)*new_size
);
2935 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
2936 id_to_widget
.widgets
[i
] = 0;
2937 id_to_widget
.max_size
= new_size
;
2940 /* Just loop over the array and find a free place. After all,
2941 how many scroll bars are we creating? Should be a small number.
2942 The check above guarantees we will find a free place. */
2943 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
2945 if (! id_to_widget
.widgets
[i
])
2947 id_to_widget
.widgets
[i
] = w
;
2948 ++id_to_widget
.used
;
2954 /* Should never end up here */
2958 /* Remove pointer at IDX from id_to_widget.
2959 Called when scroll bar is destroyed. */
2962 xg_remove_widget_from_map (idx
)
2965 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2967 id_to_widget
.widgets
[idx
] = 0;
2968 --id_to_widget
.used
;
2972 /* Get the widget pointer at IDX from id_to_widget. */
2975 xg_get_widget_from_map (idx
)
2978 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2979 return id_to_widget
.widgets
[idx
];
2984 /* Return the scrollbar id for X Window WID on display DPY.
2985 Return -1 if WID not in id_to_widget. */
2988 xg_get_scroll_id_for_window (dpy
, wid
)
2995 w
= xg_win_to_widget (dpy
, wid
);
2999 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3000 if (id_to_widget
.widgets
[idx
] == w
)
3007 /* Callback invoked when scroll bar WIDGET is destroyed.
3008 DATA is the index into id_to_widget for WIDGET.
3009 We free pointer to last scroll bar values here and remove the index. */
3012 xg_gtk_scroll_destroy (widget
, data
)
3017 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
3019 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
3021 xg_remove_widget_from_map (id
);
3024 /* Callback for button press/release events. Used to start timer so that
3025 the scroll bar repetition timer in GTK gets handeled.
3026 Also, sets bar->dragging to Qnil when dragging (button release) is done.
3027 WIDGET is the scroll bar widget the event is for (not used).
3028 EVENT contains the event.
3029 USER_DATA points to the struct scrollbar structure.
3031 Returns FALSE to tell GTK that it shall continue propagate the event
3035 scroll_bar_button_cb (widget
, event
, user_data
)
3037 GdkEventButton
*event
;
3040 if (event
->type
== GDK_BUTTON_PRESS
&& ! xg_timer
)
3042 else if (event
->type
== GDK_BUTTON_RELEASE
)
3044 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
3045 if (xg_timer
) xg_stop_timer ();
3046 bar
->dragging
= Qnil
;
3052 /* Create a scroll bar widget for frame F. Store the scroll bar
3054 SCROLL_CALLBACK is the callback to invoke when the value of the
3056 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3057 to set resources for the widget. */
3060 xg_create_scroll_bar (f
, bar
, scroll_callback
, scroll_bar_name
)
3062 struct scroll_bar
*bar
;
3063 GCallback scroll_callback
;
3064 char *scroll_bar_name
;
3071 /* Page, step increment values are not so important here, they
3072 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3073 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3076 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3077 webox
= gtk_event_box_new ();
3078 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3079 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3081 scroll_id
= xg_store_widget_in_map (wscroll
);
3083 g_signal_connect (G_OBJECT (wscroll
),
3087 /* The EMACS_INT cast avoids a warning. */
3088 g_signal_connect (G_OBJECT (wscroll
),
3090 G_CALLBACK (xg_gtk_scroll_destroy
),
3091 (gpointer
) (EMACS_INT
) scroll_id
);
3093 /* Connect to button press and button release to detect if any scroll bar
3095 g_signal_connect (G_OBJECT (wscroll
),
3096 "button-press-event",
3097 G_CALLBACK (scroll_bar_button_cb
),
3099 g_signal_connect (G_OBJECT (wscroll
),
3100 "button-release-event",
3101 G_CALLBACK (scroll_bar_button_cb
),
3104 /* The scroll bar widget does not draw on a window of its own. Instead
3105 it draws on the parent window, in this case the edit widget. So
3106 whenever the edit widget is cleared, the scroll bar needs to redraw
3107 also, which causes flicker. Put an event box between the edit widget
3108 and the scroll bar, so the scroll bar instead draws itself on the
3109 event box window. */
3110 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3111 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3114 /* Set the cursor to an arrow. */
3115 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3117 SET_SCROLL_BAR_X_WINDOW (bar
, scroll_id
);
3120 /* Make the scroll bar represented by SCROLLBAR_ID visible. */
3123 xg_show_scroll_bar (scrollbar_id
)
3126 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3128 gtk_widget_show_all (gtk_widget_get_parent (w
));
3131 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3134 xg_remove_scroll_bar (f
, scrollbar_id
)
3138 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3141 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3142 gtk_widget_destroy (w
);
3143 gtk_widget_destroy (wparent
);
3144 SET_FRAME_GARBAGED (f
);
3148 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3150 TOP/LEFT are the new pixel positions where the bar shall appear.
3151 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3154 xg_update_scrollbar_pos (f
, scrollbar_id
, top
, left
, width
, height
)
3163 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3167 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3168 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3170 /* Move and resize to new values. */
3171 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3172 gtk_widget_set_size_request (wscroll
, width
, height
);
3173 gtk_widget_queue_draw (wparent
);
3174 gdk_window_process_all_updates ();
3175 /* GTK does not redraw until the main loop is entered again, but
3176 if there are no X events pending we will not enter it. So we sync
3177 here to get some events. */
3179 SET_FRAME_GARBAGED (f
);
3180 cancel_mouse_face (f
);
3184 /* Set the thumb size and position of scroll bar BAR. We are currently
3185 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3188 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
3189 struct scroll_bar
*bar
;
3190 int portion
, position
, whole
;
3192 GtkWidget
*wscroll
= xg_get_widget_from_map (SCROLL_BAR_X_WINDOW (bar
));
3194 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3196 if (wscroll
&& NILP (bar
->dragging
))
3205 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3207 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3208 rather than the real portion value. This makes the thumb less likely
3209 to resize and that looks better. */
3210 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3211 /* When the thumb is at the bottom, position == whole.
3212 So we need to increase `whole' to make space for the thumb. */
3219 top
= (gdouble
) position
/ whole
;
3220 shown
= (gdouble
) portion
/ whole
;
3223 size
= shown
* XG_SB_RANGE
;
3224 size
= min (size
, XG_SB_RANGE
);
3225 size
= max (size
, 1);
3227 value
= top
* XG_SB_RANGE
;
3228 value
= min (value
, XG_SB_MAX
- size
);
3229 value
= max (value
, XG_SB_MIN
);
3231 /* Assume all lines are of equal size. */
3232 new_step
= size
/ max (1, FRAME_LINES (f
));
3234 if ((int) adj
->page_size
!= size
3235 || (int) adj
->step_increment
!= new_step
)
3237 adj
->page_size
= size
;
3238 adj
->step_increment
= new_step
;
3239 /* Assume a page increment is about 95% of the page size */
3240 adj
->page_increment
= (int) (0.95*adj
->page_size
);
3244 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3246 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3250 /* gtk_range_set_value invokes the callback. Set
3251 ignore_gtk_scrollbar to make the callback do nothing */
3252 xg_ignore_gtk_scrollbar
= 1;
3254 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3255 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3257 gtk_adjustment_changed (adj
);
3259 xg_ignore_gtk_scrollbar
= 0;
3267 /***********************************************************************
3269 ***********************************************************************/
3270 /* The key for the data we put in the GtkImage widgets. The data is
3271 the image used by Emacs. We use this to see if we need to update
3272 the GtkImage with a new image. */
3273 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3275 /* The key for storing the latest modifiers so the activate callback can
3277 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3280 /* Callback function invoked when a tool bar item is pressed.
3281 W is the button widget in the tool bar that got pressed,
3282 CLIENT_DATA is an integer that is the index of the button in the
3283 tool bar. 0 is the first button. */
3286 xg_tool_bar_button_cb (widget
, event
, user_data
)
3288 GdkEventButton
*event
;
3291 g_object_set_data (G_OBJECT (user_data
), XG_TOOL_BAR_LAST_MODIFIER
,
3292 (gpointer
) event
->state
);
3298 xg_tool_bar_callback (w
, client_data
)
3300 gpointer client_data
;
3302 /* The EMACS_INT cast avoids a warning. */
3303 int idx
= (int) (EMACS_INT
) client_data
;
3304 int mod
= (int) g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3306 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3307 Lisp_Object key
, frame
;
3308 struct input_event event
;
3311 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3314 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3316 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3317 XSETFRAME (frame
, f
);
3318 event
.kind
= TOOL_BAR_EVENT
;
3319 event
.frame_or_window
= frame
;
3321 kbd_buffer_store_event (&event
);
3323 event
.kind
= TOOL_BAR_EVENT
;
3324 event
.frame_or_window
= frame
;
3326 /* Convert between the modifier bits GDK uses and the modifier bits
3327 Emacs uses. This assumes GDK an X masks are the same, which they are when
3329 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3330 kbd_buffer_store_event (&event
);
3333 /* This callback is called when a tool bar is detached. We must set
3334 the height of the tool bar to zero when this happens so frame sizes
3335 are correctly calculated.
3336 WBOX is the handle box widget that enables detach/attach of the tool bar.
3337 W is the tool bar widget.
3338 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3341 xg_tool_bar_detach_callback (wbox
, w
, client_data
)
3344 gpointer client_data
;
3346 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3347 extern int x_gtk_whole_detached_tool_bar
;
3349 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3354 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3356 /* When detaching a tool bar, not everything dissapear. There are
3357 a few pixels left that are used to drop the tool bar back into
3359 FRAME_TOOLBAR_HEIGHT (f
) = 2;
3361 /* The height has changed, resize outer widget and set columns
3362 rows to what we had before detaching the tool bar. */
3363 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3367 /* This callback is called when a tool bar is reattached. We must set
3368 the height of the tool bar when this happens so frame sizes
3369 are correctly calculated.
3370 WBOX is the handle box widget that enables detach/attach of the tool bar.
3371 W is the tool bar widget.
3372 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3375 xg_tool_bar_attach_callback (wbox
, w
, client_data
)
3378 gpointer client_data
;
3380 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3381 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3387 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3389 gtk_widget_size_request (w
, &req
);
3390 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3392 /* The height has changed, resize outer widget and set columns
3393 rows to what we had before attaching the tool bar. */
3394 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3398 /* This callback is called when the mouse enters or leaves a tool bar item.
3399 It is used for displaying and hiding the help text.
3400 W is the tool bar item, a button.
3401 EVENT is either an enter event or leave event.
3402 CLIENT_DATA is an integer that is the index of the button in the
3403 tool bar. 0 is the first button.
3405 Returns FALSE to tell GTK to keep processing this event. */
3408 xg_tool_bar_help_callback (w
, event
, client_data
)
3410 GdkEventCrossing
*event
;
3411 gpointer client_data
;
3413 /* The EMACS_INT cast avoids a warning. */
3414 int idx
= (int) (EMACS_INT
) client_data
;
3415 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3416 Lisp_Object help
, frame
;
3418 if (! GTK_IS_BUTTON (w
))
3421 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3424 if (event
->type
== GDK_ENTER_NOTIFY
)
3426 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3427 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3430 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3435 XSETFRAME (frame
, f
);
3436 kbd_buffer_store_help_event (frame
, help
);
3442 /* This callback is called when a tool bar item shall be redrawn.
3443 It modifies the expose event so that the GtkImage widget redraws the
3444 whole image. This to overcome a bug that makes GtkImage draw the image
3445 in the wrong place when it tries to redraw just a part of the image.
3446 W is the GtkImage to be redrawn.
3447 EVENT is the expose event for W.
3448 CLIENT_DATA is unused.
3450 Returns FALSE to tell GTK to keep processing this event. */
3453 xg_tool_bar_item_expose_callback (w
, event
, client_data
)
3455 GdkEventExpose
*event
;
3456 gpointer client_data
;
3460 gdk_drawable_get_size (event
->window
, &width
, &height
);
3462 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3463 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3465 event
->area
.x
= max (0, event
->area
.x
);
3466 event
->area
.y
= max (0, event
->area
.y
);
3468 event
->area
.width
= max (width
, event
->area
.width
);
3469 event
->area
.height
= max (height
, event
->area
.height
);
3474 /* This callback is called when a tool bar shall be redrawn.
3475 We need to update the tool bar from here in case the image cache
3476 has deleted the pixmaps used in the tool bar.
3477 W is the GtkToolbar to be redrawn.
3478 EVENT is the expose event for W.
3479 CLIENT_DATA is pointing to the frame for this tool bar.
3481 Returns FALSE to tell GTK to keep processing this event. */
3484 xg_tool_bar_expose_callback (w
, event
, client_data
)
3486 GdkEventExpose
*event
;
3487 gpointer client_data
;
3489 update_frame_tool_bar ((FRAME_PTR
) client_data
);
3493 /* Create a tool bar for frame F. */
3496 xg_create_tool_bar (f
)
3499 struct x_output
*x
= f
->output_data
.x
;
3501 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3503 x
->toolbar_widget
= gtk_toolbar_new ();
3504 x
->handlebox_widget
= gtk_handle_box_new ();
3505 x
->toolbar_detached
= 0;
3507 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3510 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3513 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3516 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3518 /* We only have icons, so override any user setting. We could
3519 use the caption property of the toolbar item (see update_frame_tool_bar
3520 below), but some of those strings are long, making the toolbar so
3521 long it does not fit on the screen. The GtkToolbar widget makes every
3522 item equal size, so the longest caption determine the size of every
3523 tool bar item. I think the creators of the GtkToolbar widget
3524 counted on 4 or 5 character long strings. */
3525 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3526 gtk_toolbar_set_orientation (GTK_TOOLBAR (x
->toolbar_widget
),
3527 GTK_ORIENTATION_HORIZONTAL
);
3529 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3530 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3531 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3532 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3533 g_signal_connect (G_OBJECT (x
->toolbar_widget
),
3535 G_CALLBACK (xg_tool_bar_expose_callback
),
3538 gtk_widget_show_all (x
->handlebox_widget
);
3540 gtk_widget_size_request (x
->toolbar_widget
, &req
);
3541 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3543 /* The height has changed, resize outer widget and set columns
3544 rows to what we had before adding the tool bar. */
3545 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3547 SET_FRAME_GARBAGED (f
);
3550 /* Update the tool bar for frame F. Add new buttons and remove old. */
3553 update_frame_tool_bar (f
)
3557 GtkRequisition old_req
, new_req
;
3560 struct x_output
*x
= f
->output_data
.x
;
3561 int hmargin
, vmargin
;
3563 if (! FRAME_GTK_WIDGET (f
))
3568 if (INTEGERP (Vtool_bar_button_margin
)
3569 && XINT (Vtool_bar_button_margin
) > 0)
3571 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3572 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3574 else if (CONSP (Vtool_bar_button_margin
))
3576 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3577 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3578 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3580 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3581 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3582 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3585 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3586 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3587 i.e. zero. This means that margins less than
3588 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3589 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3590 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3592 if (! x
->toolbar_widget
)
3593 xg_create_tool_bar (f
);
3595 gtk_widget_size_request (x
->toolbar_widget
, &old_req
);
3597 icon_list
= gtk_container_get_children (GTK_CONTAINER (x
->toolbar_widget
));
3600 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3602 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3604 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3605 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3610 GtkWidget
*wicon
= iter
? GTK_WIDGET (iter
->data
) : 0;
3612 if (iter
) iter
= g_list_next (iter
);
3614 /* If image is a vector, choose the image according to the
3616 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3617 if (VECTORP (image
))
3621 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3622 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3625 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3626 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3628 xassert (ASIZE (image
) >= idx
);
3629 image
= AREF (image
, idx
);
3634 /* Ignore invalid image specifications. */
3635 if (!valid_image_p (image
))
3637 if (wicon
) gtk_widget_hide (wicon
);
3641 img_id
= lookup_image (f
, image
);
3642 img
= IMAGE_FROM_ID (f
, img_id
);
3643 prepare_image_for_display (f
, img
);
3645 if (img
->load_failed_p
|| img
->pixmap
== None
)
3647 if (wicon
) gtk_widget_hide (wicon
);
3653 GtkWidget
*w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
3654 GtkToolItem
*ti
= gtk_tool_button_new (w
, "");
3656 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
3658 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
),
3661 /* The EMACS_INT cast avoids a warning. */
3662 g_signal_connect (GTK_WIDGET (ti
), "clicked",
3663 GTK_SIGNAL_FUNC (xg_tool_bar_callback
),
3664 (gpointer
) (EMACS_INT
) i
);
3666 gtk_widget_show (GTK_WIDGET (ti
));
3667 gtk_widget_show (GTK_WIDGET (w
));
3669 /* Save the image so we can see if an update is needed when
3670 this function is called again. */
3671 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
3672 (gpointer
)img
->pixmap
);
3674 g_object_set_data (G_OBJECT (ti
), XG_FRAME_DATA
, (gpointer
)f
);
3676 /* Catch expose events to overcome an annoying redraw bug, see
3677 comment for xg_tool_bar_item_expose_callback. */
3678 g_signal_connect (G_OBJECT (ti
),
3680 G_CALLBACK (xg_tool_bar_item_expose_callback
),
3683 gtk_widget_set_sensitive (GTK_WIDGET (ti
), enabled_p
);
3684 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (ti
), FALSE
);
3686 while (! GTK_IS_BUTTON (w
))
3687 w
= gtk_widget_get_parent (w
);
3689 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
3690 no distinction based on modifiers in the activate callback,
3691 so we have to do it ourselves. */
3692 g_signal_connect (w
, "button-release-event",
3693 GTK_SIGNAL_FUNC (xg_tool_bar_button_cb
),
3696 g_object_set_data (G_OBJECT (w
), XG_FRAME_DATA
, (gpointer
)f
);
3698 /* Use enter/leave notify to show help. We use the events
3699 rather than the GtkButton specific signals "enter" and
3700 "leave", so we can have only one callback. The event
3701 will tell us what kind of event it is. */
3702 /* The EMACS_INT cast avoids a warning. */
3703 g_signal_connect (G_OBJECT (w
),
3704 "enter-notify-event",
3705 G_CALLBACK (xg_tool_bar_help_callback
),
3706 (gpointer
) (EMACS_INT
) i
);
3707 g_signal_connect (G_OBJECT (w
),
3708 "leave-notify-event",
3709 G_CALLBACK (xg_tool_bar_help_callback
),
3710 (gpointer
) (EMACS_INT
) i
);
3714 /* The child of the tool bar is a button. Inside that button
3715 is a vbox. Inside that vbox is the GtkImage. */
3716 GtkWidget
*wvbox
= gtk_bin_get_child (GTK_BIN (wicon
));
3717 GList
*chlist
= gtk_container_get_children (GTK_CONTAINER (wvbox
));
3718 GtkImage
*wimage
= GTK_IMAGE (chlist
->data
);
3719 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
3720 XG_TOOL_BAR_IMAGE_DATA
);
3721 g_list_free (chlist
);
3723 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
3725 if (old_img
!= img
->pixmap
)
3726 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
3728 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
3729 (gpointer
)img
->pixmap
);
3731 gtk_widget_set_sensitive (wicon
, enabled_p
);
3732 gtk_widget_show (wicon
);
3738 /* Remove buttons not longer needed. We just hide them so they
3739 can be reused later on. */
3742 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3743 gtk_widget_hide (w
);
3744 iter
= g_list_next (iter
);
3747 gtk_widget_size_request (x
->toolbar_widget
, &new_req
);
3748 if (old_req
.height
!= new_req
.height
3749 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
3751 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
3752 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3755 if (icon_list
) g_list_free (icon_list
);
3760 /* Deallocate all resources for the tool bar on frame F.
3761 Remove the tool bar. */
3764 free_frame_tool_bar (f
)
3767 struct x_output
*x
= f
->output_data
.x
;
3769 if (x
->toolbar_widget
)
3772 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
3773 x
->handlebox_widget
);
3774 x
->toolbar_widget
= 0;
3775 x
->handlebox_widget
= 0;
3776 FRAME_TOOLBAR_HEIGHT (f
) = 0;
3778 /* The height has changed, resize outer widget and set columns
3779 rows to what we had before removing the tool bar. */
3780 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3782 SET_FRAME_GARBAGED (f
);
3789 /***********************************************************************
3791 ***********************************************************************/
3795 GtkBindingSet
*binding_set
;
3797 xg_ignore_gtk_scrollbar
= 0;
3798 xg_detached_menus
= 0;
3799 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
3800 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
3802 id_to_widget
.max_size
= id_to_widget
.used
= 0;
3803 id_to_widget
.widgets
= 0;
3805 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
3806 bindings. It doesn't seem to be any way to remove properties,
3807 so we set it to VoidSymbol which in X means "no key". */
3808 gtk_settings_set_string_property (gtk_settings_get_default (),
3809 "gtk-menu-bar-accel",
3813 /* Make GTK text input widgets use Emacs style keybindings. This is
3815 gtk_settings_set_string_property (gtk_settings_get_default (),
3816 "gtk-key-theme-name",
3820 /* Make dialogs close on C-g. Since file dialog inherits from
3821 dialog, this works for them also. */
3822 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_DIALOG
));
3823 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3826 /* Make menus close on C-g. */
3827 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_MENU_SHELL
));
3828 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3832 #endif /* USE_GTK */
3834 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
3835 (do not change this comment) */