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 /* If this is the default display, we must change it before calling
135 dispose, otherwise it will crash on some Gtk+ versions. */
136 if (gdk_display_get_default () == gdpy
)
138 struct x_display_info
*dpyinfo
;
139 Display
*new_dpy
= 0;
140 GdkDisplay
*gdpy_new
;
142 /* Find another display. */
143 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
144 if (dpyinfo
->display
!= dpy
)
146 new_dpy
= dpyinfo
->display
;
150 if (! new_dpy
) return; /* Emacs will exit anyway. */
152 gdpy_new
= gdk_x11_lookup_xdisplay (new_dpy
);
153 gdk_display_manager_set_default_display (gdk_display_manager_get (),
157 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
158 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way
159 we can continue running, but there will be memory leaks. */
161 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
162 g_object_run_dispose (G_OBJECT (gdpy
));
164 /* This seems to be fixed in GTK 2.10. */
165 gdk_display_close (gdpy
);
167 #endif /* HAVE_GTK_MULTIDISPLAY */
171 /***********************************************************************
173 ***********************************************************************/
174 /* The timer for scroll bar repetition and menu bar timeouts.
175 NULL if no timer is started. */
176 static struct atimer
*xg_timer
;
179 /* The next two variables and functions are taken from lwlib. */
180 static widget_value
*widget_value_free_list
;
181 static int malloc_cpt
;
183 /* Allocate a widget_value structure, either by taking one from the
184 widget_value_free_list or by malloc:ing a new one.
186 Return a pointer to the allocated structure. */
189 malloc_widget_value ()
192 if (widget_value_free_list
)
194 wv
= widget_value_free_list
;
195 widget_value_free_list
= wv
->free_list
;
200 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
203 memset (wv
, 0, sizeof (widget_value
));
207 /* This is analogous to free. It frees only what was allocated
208 by malloc_widget_value, and no substructures. */
211 free_widget_value (wv
)
219 /* When the number of already allocated cells is too big,
226 wv
->free_list
= widget_value_free_list
;
227 widget_value_free_list
= wv
;
232 /* Create and return the cursor to be used for popup menus and
233 scroll bars on display DPY. */
236 xg_create_default_cursor (dpy
)
239 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
240 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
243 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
246 xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
)
251 int x
, y
, width
, height
, rowstride
, mask_rowstride
;
252 GdkPixbuf
*icon_buf
, *tmp_buf
;
256 gdk_drawable_get_size (gpix
, &width
, &height
);
257 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
258 0, 0, 0, 0, width
, height
);
259 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
260 g_object_unref (G_OBJECT (tmp_buf
));
264 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
269 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
270 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
271 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
272 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
275 for (y
= 0; y
< height
; ++y
)
277 guchar
*iconptr
, *maskptr
;
280 iconptr
= pixels
+ y
* rowstride
;
281 maskptr
= mask_pixels
+ y
* mask_rowstride
;
283 for (x
= 0; x
< width
; ++x
)
285 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
286 just R is sufficient. */
288 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
290 iconptr
+= rowstride
/width
;
291 maskptr
+= mask_rowstride
/width
;
295 g_object_unref (G_OBJECT (mask_buf
));
301 /* For the image defined in IMG, make and return a GtkImage. For displays with
302 8 planes or less we must make a GdkPixbuf and apply the mask manually.
303 Otherwise the highlightning and dimming the tool bar code in GTK does
304 will look bad. For display with more than 8 planes we just use the
305 pixmap and mask directly. For monochrome displays, GTK doesn't seem
306 able to use external pixmaps, it looks bad whatever we do.
307 The image is defined on the display where frame F is.
308 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
309 If OLD_WIDGET is NULL, a new widget is constructed and returned.
310 If OLD_WIDGET is not NULL, that widget is modified. */
313 xg_get_image_for_pixmap (f
, img
, widget
, old_widget
)
317 GtkImage
*old_widget
;
323 /* If we have a file, let GTK do all the image handling.
324 This seems to be the only way to make insensitive and activated icons
325 look good in all cases. */
326 Lisp_Object specified_file
= Qnil
;
329 extern Lisp_Object QCfile
;
331 for (tail
= XCDR (img
->spec
);
332 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
333 tail
= XCDR (XCDR (tail
)))
334 if (EQ (XCAR (tail
), QCfile
))
335 specified_file
= XCAR (XCDR (tail
));
337 /* We already loaded the image once before calling this
338 function, so this only fails if the image file has been removed.
339 In that case, use the pixmap already loaded. */
341 if (STRINGP (specified_file
)
342 && STRINGP (file
= x_find_image_file (specified_file
)))
345 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
347 gtk_image_set_from_file (old_widget
, SSDATA (file
));
349 return GTK_WIDGET (old_widget
);
352 /* No file, do the image handling ourselves. This will look very bad
353 on a monochrome display, and sometimes bad on all displays with
356 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
357 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
358 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
360 if (x_screen_planes (f
) > 8 || x_screen_planes (f
) == 1)
363 old_widget
= GTK_IMAGE (gtk_image_new_from_pixmap (gpix
, gmask
));
365 gtk_image_set_from_pixmap (old_widget
, gpix
, gmask
);
370 /* This is a workaround to make icons look good on pseudo color
371 displays. Apparently GTK expects the images to have an alpha
372 channel. If they don't, insensitive and activated icons will
373 look bad. This workaround does not work on monochrome displays,
374 and is not needed on true color/static color displays (i.e.
375 16 bits and higher). */
376 GdkColormap
*cmap
= gtk_widget_get_colormap (widget
);
377 GdkPixbuf
*icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
380 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
382 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
384 g_object_unref (G_OBJECT (icon_buf
));
387 g_object_unref (G_OBJECT (gpix
));
388 if (gmask
) g_object_unref (G_OBJECT (gmask
));
390 return GTK_WIDGET (old_widget
);
394 /* Set CURSOR on W and all widgets W contain. We must do like this
395 for scroll bars and menu because they create widgets internally,
396 and it is those widgets that are visible. */
399 xg_set_cursor (w
, cursor
)
403 GList
*children
= gdk_window_peek_children (w
->window
);
405 gdk_window_set_cursor (w
->window
, cursor
);
407 /* The scroll bar widget has more than one GDK window (had to look at
408 the source to figure this out), and there is no way to set cursor
409 on widgets in GTK. So we must set the cursor for all GDK windows.
412 for ( ; children
; children
= g_list_next (children
))
413 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
416 /* Timer function called when a timeout occurs for xg_timer.
417 This function processes all GTK events in a recursive event loop.
418 This is done because GTK timer events are not seen by Emacs event
419 detection, Emacs only looks for X events. When a scroll bar has the
420 pointer (detected by button press/release events below) an Emacs
421 timer is started, and this function can then check if the GTK timer
422 has expired by calling the GTK event loop.
423 Also, when a menu is active, it has a small timeout before it
424 pops down the sub menu under it. */
427 xg_process_timeouts (timer
)
428 struct atimer
*timer
;
431 /* Ideally we would like to just handle timer events, like the Xt version
432 of this does in xterm.c, but there is no such feature in GTK. */
433 while (gtk_events_pending ())
434 gtk_main_iteration ();
438 /* Start the xg_timer with an interval of 0.1 seconds, if not already started.
439 xg_process_timeouts is called when the timer expires. The timer
440 started is continuous, i.e. runs until xg_stop_timer is called. */
448 EMACS_SET_SECS_USECS (interval
, 0, 100000);
449 xg_timer
= start_atimer (ATIMER_CONTINUOUS
,
456 /* Stop the xg_timer if started. */
463 cancel_atimer (xg_timer
);
468 /* Insert NODE into linked LIST. */
471 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
473 xg_list_node
*list_start
= list
->next
;
475 if (list_start
) list_start
->prev
= node
;
476 node
->next
= list_start
;
481 /* Remove NODE from linked LIST. */
484 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
486 xg_list_node
*list_start
= list
->next
;
487 if (node
== list_start
)
489 list
->next
= node
->next
;
490 if (list
->next
) list
->next
->prev
= 0;
494 node
->prev
->next
= node
->next
;
495 if (node
->next
) node
->next
->prev
= node
->prev
;
499 /* Allocate and return a utf8 version of STR. If STR is already
500 utf8 or NULL, just return STR.
501 If not, a new string is allocated and the caller must free the result
505 get_utf8_string (str
)
508 char *utf8_str
= str
;
510 if (!str
) return NULL
;
512 /* If not UTF-8, try current locale. */
513 if (!g_utf8_validate (str
, -1, NULL
))
514 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
518 /* Probably some control characters in str. Escape them. */
522 unsigned char *p
= (unsigned char *)str
;
524 GError
*error
= NULL
;
526 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
527 &bytes_written
, &error
))
528 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
531 p
+= bytes_written
+1;
532 g_error_free (error
);
538 g_error_free (error
);
543 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
544 p
= (unsigned char *)str
;
546 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
547 &bytes_written
, &error
))
548 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
550 strncpy (up
, (char *)p
, bytes_written
);
551 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
552 up
[bytes_written
+4] = '\0';
553 up
+= bytes_written
+4;
554 p
+= bytes_written
+1;
555 g_error_free (error
);
561 strcat (utf8_str
, cp
);
566 g_error_free (error
);
575 /***********************************************************************
576 General functions for creating widgets, resizing, events, e.t.c.
577 ***********************************************************************/
579 /* Make a geometry string and pass that to GTK. It seems this is the
580 only way to get geometry position right if the user explicitly
581 asked for a position when starting Emacs.
582 F is the frame we shall set geometry for. */
588 if (f
->size_hint_flags
& USPosition
)
590 int left
= f
->left_pos
;
591 int xneg
= f
->size_hint_flags
& XNegative
;
592 int top
= f
->top_pos
;
593 int yneg
= f
->size_hint_flags
& YNegative
;
601 sprintf (geom_str
, "=%dx%d%c%d%c%d",
602 FRAME_PIXEL_WIDTH (f
),
603 FRAME_TOTAL_PIXEL_HEIGHT (f
),
604 (xneg
? '-' : '+'), left
,
605 (yneg
? '-' : '+'), top
);
607 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
609 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
610 } else if (f
->size_hint_flags
& PPosition
) {
611 gtk_window_move (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
612 f
->left_pos
, f
->top_pos
);
617 /* Resize the outer window of frame F after chainging the height.
618 This happend when the menu bar or the tool bar is added or removed.
619 COLUMNS/ROWS is the size the edit area shall have after the resize. */
622 xg_resize_outer_widget (f
, columns
, rows
)
627 /* If we are not mapped yet, set geometry once again, as window
628 height now have changed. */
629 if (! GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f
)))
632 xg_frame_set_char_size (f
, columns
, rows
);
633 gdk_window_process_all_updates ();
636 /* Function to handle resize of our widgets. Since Emacs has some layouts
637 that does not fit well with GTK standard containers, we do most layout
639 F is the frame to resize.
640 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
643 xg_resize_widgets (f
, pixelwidth
, pixelheight
)
645 int pixelwidth
, pixelheight
;
647 int mbheight
= FRAME_MENUBAR_HEIGHT (f
);
648 int tbheight
= FRAME_TOOLBAR_HEIGHT (f
);
649 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, (pixelheight
650 - mbheight
- tbheight
));
651 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
653 if (FRAME_GTK_WIDGET (f
)
654 && (columns
!= FRAME_COLS (f
)
655 || rows
!= FRAME_LINES (f
)
656 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
657 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
)))
659 struct x_output
*x
= f
->output_data
.x
;
662 all
.y
= mbheight
+ tbheight
;
665 all
.width
= pixelwidth
;
666 all
.height
= pixelheight
- mbheight
- tbheight
;
668 gtk_widget_size_allocate (x
->edit_widget
, &all
);
670 change_frame_size (f
, rows
, columns
, 0, 1, 0);
671 SET_FRAME_GARBAGED (f
);
672 cancel_mouse_face (f
);
677 /* Update our widget size to be COLS/ROWS characters for frame F. */
680 xg_frame_set_char_size (f
, cols
, rows
)
685 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
686 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
689 /* Take into account the size of the scroll bar. Always use the
690 number of columns occupied by the scroll bar here otherwise we
691 might end up with a frame width that is not a multiple of the
692 frame's character width which is bad for vertically split
694 f
->scroll_bar_actual_width
695 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
697 compute_fringe_widths (f
, 0);
699 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
700 after calculating that value. */
701 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
703 /* Must resize our top level widget. Font size may have changed,
704 but not rows/cols. */
705 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
706 pixelwidth
, pixelheight
);
707 xg_resize_widgets (f
, pixelwidth
, pixelheight
);
708 x_wm_set_size_hint (f
, 0, 0);
709 SET_FRAME_GARBAGED (f
);
710 cancel_mouse_face (f
);
713 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
714 Must be done like this, because GtkWidget:s can have "hidden"
715 X Window that aren't accessible.
717 Return 0 if no widget match WDESC. */
720 xg_win_to_widget (dpy
, wdesc
)
725 GtkWidget
*gwdesc
= 0;
729 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
734 event
.any
.window
= gdkwin
;
735 gwdesc
= gtk_get_event_widget (&event
);
742 /* Fill in the GdkColor C so that it represents PIXEL.
743 W is the widget that color will be used for. Used to find colormap. */
746 xg_pix_to_gcolor (w
, pixel
, c
)
751 GdkColormap
*map
= gtk_widget_get_colormap (w
);
752 gdk_colormap_query_color (map
, pixel
, c
);
755 /* Create and set up the GTK widgets for frame F.
756 Return 0 if creation failed, non-zero otherwise. */
759 xg_create_frame_widgets (f
)
772 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
773 xg_set_screen (wtop
, f
);
775 wvbox
= gtk_vbox_new (FALSE
, 0);
776 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
778 if (! wtop
|| ! wvbox
|| ! wfixed
)
780 if (wtop
) gtk_widget_destroy (wtop
);
781 if (wvbox
) gtk_widget_destroy (wvbox
);
782 if (wfixed
) gtk_widget_destroy (wfixed
);
788 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
789 gtk_widget_set_name (wtop
, EMACS_CLASS
);
790 gtk_widget_set_name (wvbox
, "pane");
791 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
793 /* If this frame has a title or name, set it in the title bar. */
794 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
795 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
797 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
799 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
800 FRAME_GTK_WIDGET (f
) = wfixed
;
801 f
->output_data
.x
->vbox_widget
= wvbox
;
803 gtk_fixed_set_has_window (GTK_FIXED (wfixed
), TRUE
);
805 gtk_widget_set_size_request (wfixed
, FRAME_PIXEL_WIDTH (f
),
806 FRAME_PIXEL_HEIGHT (f
));
808 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
809 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
811 if (FRAME_EXTERNAL_TOOL_BAR (f
))
812 update_frame_tool_bar (f
);
814 /* The tool bar is created but first there are no items in it.
815 This causes it to be zero height. Later items are added, but then
816 the frame is already mapped, so there is a "jumping" resize.
817 This makes geometry handling difficult, for example -0-0 will end
818 up in the wrong place as tool bar height has not been taken into account.
819 So we cheat a bit by setting a height that is what it will have
820 later on when tool bar items are added. */
821 if (FRAME_EXTERNAL_TOOL_BAR (f
) && f
->n_tool_bar_items
== 0)
822 FRAME_TOOLBAR_HEIGHT (f
) = 38;
825 /* We don't want this widget double buffered, because we draw on it
826 with regular X drawing primitives, so from a GTK/GDK point of
827 view, the widget is totally blank. When an expose comes, this
828 will make the widget blank, and then Emacs redraws it. This flickers
829 a lot, so we turn off double buffering. */
830 gtk_widget_set_double_buffered (wfixed
, FALSE
);
832 /* GTK documents says use gtk_window_set_resizable. But then a user
833 can't shrink the window from its starting size. */
834 gtk_window_set_policy (GTK_WINDOW (wtop
), TRUE
, TRUE
, TRUE
);
835 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
836 SSDATA (Vx_resource_name
),
837 SSDATA (Vx_resource_class
));
839 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
840 GTK is to destroy the widget. We want Emacs to do that instead. */
841 g_signal_connect (G_OBJECT (wtop
), "delete-event",
842 G_CALLBACK (gtk_true
), 0);
844 /* Convert our geometry parameters into a geometry string
846 GTK will itself handle calculating the real position this way. */
849 gtk_widget_add_events (wfixed
,
850 GDK_POINTER_MOTION_MASK
852 | GDK_BUTTON_PRESS_MASK
853 | GDK_BUTTON_RELEASE_MASK
855 | GDK_ENTER_NOTIFY_MASK
856 | GDK_LEAVE_NOTIFY_MASK
857 | GDK_FOCUS_CHANGE_MASK
859 | GDK_VISIBILITY_NOTIFY_MASK
);
861 /* Must realize the windows so the X window gets created. It is used
862 by callers of this function. */
863 gtk_widget_realize (wfixed
);
864 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
866 /* Since GTK clears its window by filling with the background color,
867 we must keep X and GTK background in sync. */
868 xg_pix_to_gcolor (wfixed
, f
->output_data
.x
->background_pixel
, &bg
);
869 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
871 /* Also, do not let any background pixmap to be set, this looks very
872 bad as Emacs overwrites the background pixmap with its own idea
873 of background color. */
874 style
= gtk_widget_get_modifier_style (wfixed
);
876 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
877 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
878 gtk_widget_modify_style (wfixed
, style
);
880 /* GTK does not set any border, and they look bad with GTK. */
882 f
->internal_border_width
= 0;
889 /* Set the normal size hints for the window manager, for frame F.
890 FLAGS is the flags word to use--or 0 meaning preserve the flags
891 that the window now has.
892 If USER_POSITION is nonzero, we set the User Position
893 flag (this is useful when FLAGS is 0). */
896 x_wm_set_size_hint (f
, flags
, user_position
)
901 if (FRAME_GTK_OUTER_WIDGET (f
))
903 /* Must use GTK routines here, otherwise GTK resets the size hints
904 to its own defaults. */
905 GdkGeometry size_hints
;
907 int base_width
, base_height
;
908 int min_rows
= 0, min_cols
= 0;
909 int win_gravity
= f
->win_gravity
;
913 memset (&size_hints
, 0, sizeof (size_hints
));
914 f
->output_data
.x
->size_hints
= size_hints
;
915 f
->output_data
.x
->hint_flags
= hint_flags
;
918 flags
= f
->size_hint_flags
;
920 size_hints
= f
->output_data
.x
->size_hints
;
921 hint_flags
= f
->output_data
.x
->hint_flags
;
923 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
924 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
925 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
927 hint_flags
|= GDK_HINT_BASE_SIZE
;
928 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
929 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
930 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
932 check_frame_size (f
, &min_rows
, &min_cols
);
934 size_hints
.base_width
= base_width
;
935 size_hints
.base_height
= base_height
;
936 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
937 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
940 /* These currently have a one to one mapping with the X values, but I
941 don't think we should rely on that. */
942 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
943 size_hints
.win_gravity
= 0;
944 if (win_gravity
== NorthWestGravity
)
945 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
946 else if (win_gravity
== NorthGravity
)
947 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
948 else if (win_gravity
== NorthEastGravity
)
949 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
950 else if (win_gravity
== WestGravity
)
951 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
952 else if (win_gravity
== CenterGravity
)
953 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
954 else if (win_gravity
== EastGravity
)
955 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
956 else if (win_gravity
== SouthWestGravity
)
957 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
958 else if (win_gravity
== SouthGravity
)
959 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
960 else if (win_gravity
== SouthEastGravity
)
961 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
962 else if (win_gravity
== StaticGravity
)
963 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
965 if (flags
& PPosition
) hint_flags
|= GDK_HINT_POS
;
966 if (flags
& USPosition
) hint_flags
|= GDK_HINT_USER_POS
;
967 if (flags
& USSize
) hint_flags
|= GDK_HINT_USER_SIZE
;
971 hint_flags
&= ~GDK_HINT_POS
;
972 hint_flags
|= GDK_HINT_USER_POS
;
977 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
978 FRAME_GTK_OUTER_WIDGET (f
),
982 f
->output_data
.x
->size_hints
= size_hints
;
983 f
->output_data
.x
->hint_flags
= hint_flags
;
988 /* Change background color of a frame.
989 Since GTK uses the background colour to clear the window, we must
990 keep the GTK and X colors in sync.
991 F is the frame to change,
992 BG is the pixel value to change to. */
995 xg_set_background_color (f
, bg
)
999 if (FRAME_GTK_WIDGET (f
))
1004 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
1005 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
1011 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1012 functions so GTK does not overwrite the icon. */
1015 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
)
1020 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1021 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
1022 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
1023 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
1025 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1030 /***********************************************************************
1032 ***********************************************************************/
1033 /* Return the dialog title to use for a dialog of type KEY.
1034 This is the encoding used by lwlib. We use the same for GTK. */
1037 get_dialog_title (char key
)
1047 title
= "Information";
1066 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1067 the dialog, but return TRUE so the event does not propagate further
1068 in GTK. This prevents GTK from destroying the dialog widget automatically
1069 and we can always destrou the widget manually, regardles of how
1070 it was popped down (button press or WM_DELETE_WINDOW).
1071 W is the dialog widget.
1072 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1073 user_data is NULL (not used).
1075 Returns TRUE to end propagation of event. */
1078 dialog_delete_callback (w
, event
, user_data
)
1083 gtk_widget_unmap (w
);
1087 /* Create a popup dialog window. See also xg_create_widget below.
1088 WV is a widget_value describing the dialog.
1089 SELECT_CB is the callback to use when a button has been pressed.
1090 DEACTIVATE_CB is the callback to use when the dialog pops down.
1092 Returns the GTK dialog widget. */
1095 create_dialog (wv
, select_cb
, deactivate_cb
)
1097 GCallback select_cb
;
1098 GCallback deactivate_cb
;
1100 char *title
= get_dialog_title (wv
->name
[0]);
1101 int total_buttons
= wv
->name
[1] - '0';
1102 int right_buttons
= wv
->name
[4] - '0';
1105 int button_spacing
= 10;
1106 GtkWidget
*wdialog
= gtk_dialog_new ();
1110 GtkWidget
*whbox_up
;
1111 GtkWidget
*whbox_down
;
1113 /* If the number of buttons is greater than 4, make two rows of buttons
1114 instead. This looks better. */
1115 int make_two_rows
= total_buttons
> 4;
1117 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1118 left_buttons
= total_buttons
- right_buttons
;
1120 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1121 gtk_widget_set_name (wdialog
, "emacs-dialog");
1123 cur_box
= GTK_BOX (GTK_DIALOG (wdialog
)->action_area
);
1127 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1128 whbox_up
= gtk_hbox_new (FALSE
, 0);
1129 whbox_down
= gtk_hbox_new (FALSE
, 0);
1131 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1132 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1133 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1135 cur_box
= GTK_BOX (whbox_up
);
1138 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1139 G_CALLBACK (dialog_delete_callback
), 0);
1143 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1144 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1147 for (item
= wv
->contents
; item
; item
= item
->next
)
1149 char *utf8_label
= get_utf8_string (item
->value
);
1153 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1155 /* This is the text part of the dialog. */
1156 w
= gtk_label_new (utf8_label
);
1157 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1160 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
), w
,
1162 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1164 /* Try to make dialog look better. Must realize first so
1165 the widget can calculate the size it needs. */
1166 gtk_widget_realize (w
);
1167 gtk_widget_size_request (w
, &req
);
1168 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1170 if (item
->value
&& strlen (item
->value
) > 0)
1171 button_spacing
= 2*req
.width
/strlen (item
->value
);
1175 /* This is one button to add to the dialog. */
1176 w
= gtk_button_new_with_label (utf8_label
);
1177 if (! item
->enabled
)
1178 gtk_widget_set_sensitive (w
, FALSE
);
1180 g_signal_connect (G_OBJECT (w
), "clicked",
1181 select_cb
, item
->call_data
);
1183 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1184 if (++button_nr
== left_buttons
)
1187 cur_box
= GTK_BOX (whbox_down
);
1189 gtk_box_pack_start (cur_box
,
1196 if (utf8_label
&& utf8_label
!= item
->value
)
1197 g_free (utf8_label
);
1205 /***********************************************************************
1206 File dialog functions
1207 ***********************************************************************/
1208 /* Return non-zero if the old file selection dialog is being used.
1209 Return zero if not. */
1212 xg_uses_old_file_dialog ()
1214 #ifdef HAVE_GTK_FILE_BOTH
1215 extern int x_gtk_use_old_file_dialog
;
1216 return x_gtk_use_old_file_dialog
;
1217 #else /* ! HAVE_GTK_FILE_BOTH */
1219 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1225 #endif /* ! HAVE_GTK_FILE_BOTH */
1229 /* Function that is called when the file dialog pops down.
1230 W is the dialog widget, RESPONSE is the response code.
1231 USER_DATA is what we passed in to g_signal_connect (pointer to int). */
1234 xg_file_response_cb (w
,
1241 int *ptr
= (int *) user_data
;
1246 /* Destroy the dialog. This makes it pop down. */
1249 pop_down_file_dialog (arg
)
1252 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1254 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1259 typedef char * (*xg_get_file_func
) P_ ((GtkWidget
*));
1261 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1263 /* Return the selected file for file chooser dialog W.
1264 The returned string must be free:d. */
1267 xg_get_file_name_from_chooser (w
)
1270 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1273 /* Callback called when the "Show hidden files" toggle is pressed.
1274 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1277 xg_toggle_visibility_cb (widget
, data
)
1281 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1283 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1284 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1288 /* Callback called when a property changes in a file chooser.
1289 GOBJECT is the file chooser dialog, ARG1 describes the property.
1290 USER_DATA is the toggle widget in the file chooser dialog.
1291 We use this to update the "Show hidden files" toggle when the user
1292 changes that property by right clicking in the file list. */
1295 xg_toggle_notify_cb (gobject
, arg1
, user_data
)
1300 extern int x_gtk_show_hidden_files
;
1302 if (strcmp (arg1
->name
, "show-hidden") == 0)
1304 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (gobject
);
1305 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1306 gboolean visible
, toggle_on
;
1308 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1309 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1311 if (!!visible
!= !!toggle_on
)
1313 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1314 G_CALLBACK (xg_toggle_visibility_cb
),
1316 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1317 g_signal_handlers_unblock_by_func
1318 (G_OBJECT (wtoggle
),
1319 G_CALLBACK (xg_toggle_visibility_cb
),
1322 x_gtk_show_hidden_files
= visible
;
1326 /* Read a file name from the user using a file chooser dialog.
1327 F is the current frame.
1328 PROMPT is a prompt to show to the user. May not be NULL.
1329 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1330 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1331 file. *FUNC is set to a function that can be used to retrieve the
1332 selected file name from the returned widget.
1334 Returns the created widget. */
1337 xg_get_file_with_chooser (f
, prompt
, default_filename
,
1338 mustmatch_p
, only_dir_p
, func
)
1341 char *default_filename
;
1342 int mustmatch_p
, only_dir_p
;
1343 xg_get_file_func
*func
;
1347 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1348 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1349 GtkFileChooserAction action
= (mustmatch_p
?
1350 GTK_FILE_CHOOSER_ACTION_OPEN
:
1351 GTK_FILE_CHOOSER_ACTION_SAVE
);
1352 extern int x_gtk_show_hidden_files
;
1353 extern int x_gtk_file_dialog_help_text
;
1357 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1359 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1360 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1361 (mustmatch_p
|| only_dir_p
?
1362 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1365 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1367 wbox
= gtk_vbox_new (FALSE
, 0);
1368 gtk_widget_show (wbox
);
1369 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1371 if (x_gtk_show_hidden_files
)
1373 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1374 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1376 gtk_widget_show (wtoggle
);
1377 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1378 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1379 g_signal_connect (G_OBJECT (filewin
), "notify",
1380 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1382 if (x_gtk_file_dialog_help_text
)
1385 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1386 Show the C-l help text only for versions < 2.10. */
1387 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1388 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1389 strcat (message
, "\nIf you don't like this file selector, use the "
1390 "corresponding\nkey binding or customize "
1391 "use-file-dialog to turn it off.");
1393 wmessage
= gtk_label_new (message
);
1394 gtk_widget_show (wmessage
);
1397 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1398 if (x_gtk_file_dialog_help_text
)
1399 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1400 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1402 if (default_filename
)
1405 struct gcpro gcpro1
;
1407 char *utf8_filename
;
1409 file
= build_string (default_filename
);
1411 /* File chooser does not understand ~/... in the file name. It must be
1412 an absolute name starting with /. */
1413 if (default_filename
[0] != '/')
1414 file
= Fexpand_file_name (file
, Qnil
);
1416 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1417 if (! NILP (Ffile_directory_p (file
)))
1418 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1422 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1424 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1426 char *cp
= strrchr (utf8_filename
, '/');
1428 else cp
= utf8_filename
;
1429 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1436 *func
= xg_get_file_name_from_chooser
;
1439 #endif /* HAVE_GTK_FILE_CHOOSER_DIALOG_NEW */
1441 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1443 /* Return the selected file for file selector dialog W.
1444 The returned string must be free:d. */
1447 xg_get_file_name_from_selector (w
)
1450 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1451 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1454 /* Create a file selection dialog.
1455 F is the current frame.
1456 PROMPT is a prompt to show to the user. May not be NULL.
1457 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1458 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1459 file. *FUNC is set to a function that can be used to retrieve the
1460 selected file name from the returned widget.
1462 Returns the created widget. */
1465 xg_get_file_with_selection (f
, prompt
, default_filename
,
1466 mustmatch_p
, only_dir_p
, func
)
1469 char *default_filename
;
1470 int mustmatch_p
, only_dir_p
;
1471 xg_get_file_func
*func
;
1474 GtkFileSelection
*filesel
;
1476 filewin
= gtk_file_selection_new (prompt
);
1477 filesel
= GTK_FILE_SELECTION (filewin
);
1479 if (default_filename
)
1480 gtk_file_selection_set_filename (filesel
, default_filename
);
1484 /* The selection_entry part of filesel is not documented. */
1485 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1486 gtk_file_selection_hide_fileop_buttons (filesel
);
1489 *func
= xg_get_file_name_from_selector
;
1493 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1495 /* Read a file name from the user using a file dialog, either the old
1496 file selection dialog, or the new file chooser dialog. Which to use
1497 depends on what the GTK version used has, and what the value of
1498 gtk-use-old-file-dialog.
1499 F is the current frame.
1500 PROMPT is a prompt to show to the user. May not be NULL.
1501 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1502 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1505 Returns a file name or NULL if no file was selected.
1506 The returned string must be freed by the caller. */
1509 xg_get_file_name (f
, prompt
, default_filename
, mustmatch_p
, only_dir_p
)
1512 char *default_filename
;
1513 int mustmatch_p
, only_dir_p
;
1516 int count
= SPECPDL_INDEX ();
1518 int filesel_done
= 0;
1519 xg_get_file_func func
;
1521 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1522 /* I really don't know why this is needed, but without this the GLIBC add on
1523 library linuxthreads hangs when the Gnome file chooser backend creates
1525 sigblock (sigmask (__SIGRTMIN
));
1526 #endif /* HAVE_GTK_AND_PTHREAD */
1528 #ifdef HAVE_GTK_FILE_BOTH
1530 if (xg_uses_old_file_dialog ())
1531 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1532 mustmatch_p
, only_dir_p
, &func
);
1534 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1535 mustmatch_p
, only_dir_p
, &func
);
1537 #else /* not HAVE_GTK_FILE_BOTH */
1539 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1540 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1541 mustmatch_p
, only_dir_p
, &func
);
1543 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1544 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1545 mustmatch_p
, only_dir_p
, &func
);
1548 #endif /* HAVE_GTK_FILE_BOTH */
1550 xg_set_screen (w
, f
);
1551 gtk_widget_set_name (w
, "emacs-filedialog");
1552 gtk_window_set_transient_for (GTK_WINDOW (w
),
1553 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1554 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1555 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1557 g_signal_connect (G_OBJECT (w
),
1559 G_CALLBACK (xg_file_response_cb
),
1562 /* Don't destroy the widget if closed by the window manager close button. */
1563 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1565 gtk_widget_show (w
);
1567 record_unwind_protect (pop_down_file_dialog
, make_save_value (w
, 0));
1568 while (! filesel_done
)
1570 x_menu_wait_for_event (0);
1571 gtk_main_iteration ();
1574 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1575 sigunblock (sigmask (__SIGRTMIN
));
1578 if (filesel_done
== GTK_RESPONSE_OK
)
1581 unbind_to (count
, Qnil
);
1587 /***********************************************************************
1589 ***********************************************************************/
1591 /* The name of menu items that can be used for citomization. Since GTK
1592 RC files are very crude and primitive, we have to set this on all
1593 menu item names so a user can easily cutomize menu items. */
1595 #define MENU_ITEM_NAME "emacs-menuitem"
1598 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1599 during GC. The next member points to the items. */
1600 static xg_list_node xg_menu_cb_list
;
1602 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1603 during GC. The next member points to the items. */
1604 static xg_list_node xg_menu_item_cb_list
;
1606 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1607 F is the frame CL_DATA will be initialized for.
1608 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1610 The menu bar and all sub menus under the menu bar in a frame
1611 share the same structure, hence the reference count.
1613 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1614 allocated xg_menu_cb_data if CL_DATA is NULL. */
1616 static xg_menu_cb_data
*
1617 make_cl_data (cl_data
, f
, highlight_cb
)
1618 xg_menu_cb_data
*cl_data
;
1620 GCallback highlight_cb
;
1624 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1626 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1627 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1628 cl_data
->highlight_cb
= highlight_cb
;
1629 cl_data
->ref_count
= 0;
1631 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1634 cl_data
->ref_count
++;
1639 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1640 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1642 When the menu bar is updated, menu items may have been added and/or
1643 removed, so menu_bar_vector and menu_bar_items_used change. We must
1644 then update CL_DATA since it is used to determine which menu
1645 item that is invoked in the menu.
1646 HIGHLIGHT_CB could change, there is no check that the same
1647 function is given when modifying a menu bar as was given when
1648 creating the menu bar. */
1651 update_cl_data (cl_data
, f
, highlight_cb
)
1652 xg_menu_cb_data
*cl_data
;
1654 GCallback highlight_cb
;
1659 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1660 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1661 cl_data
->highlight_cb
= highlight_cb
;
1665 /* Decrease reference count for CL_DATA.
1666 If reference count is zero, free CL_DATA. */
1669 unref_cl_data (cl_data
)
1670 xg_menu_cb_data
*cl_data
;
1672 if (cl_data
&& cl_data
->ref_count
> 0)
1674 cl_data
->ref_count
--;
1675 if (cl_data
->ref_count
== 0)
1677 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1683 /* Function that marks all lisp data during GC. */
1690 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1691 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1693 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1695 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1697 if (! NILP (cb_data
->help
))
1698 mark_object (cb_data
->help
);
1703 /* Callback called when a menu item is destroyed. Used to free data.
1704 W is the widget that is being destroyed (not used).
1705 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1708 menuitem_destroy_callback (w
, client_data
)
1710 gpointer client_data
;
1714 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1715 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1720 /* Callback called when the pointer enters/leaves a menu item.
1722 EVENT is either an enter event or leave event.
1723 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W.
1725 Returns FALSE to tell GTK to keep processing this event. */
1728 menuitem_highlight_callback (w
, event
, client_data
)
1730 GdkEventCrossing
*event
;
1731 gpointer client_data
;
1735 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1736 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : client_data
;
1738 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1740 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1741 (*func
) (w
, call_data
);
1748 /* Callback called when a menu is destroyed. Used to free data.
1749 W is the widget that is being destroyed (not used).
1750 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1753 menu_destroy_callback (w
, client_data
)
1755 gpointer client_data
;
1757 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1760 /* Callback called when a menu does a grab or ungrab. That means the
1761 menu has been activated or deactivated.
1762 Used to start a timer so the small timeout the menus in GTK uses before
1763 popping down a menu is seen by Emacs (see xg_process_timeouts above).
1764 W is the widget that does the grab (not used).
1765 UNGRAB_P is TRUE if this is an ungrab, FALSE if it is a grab.
1766 CLIENT_DATA is NULL (not used). */
1769 menu_grab_callback (GtkWidget
*widget
,
1771 gpointer client_data
)
1773 /* Keep track of total number of grabs. */
1776 if (ungrab_p
) cnt
--;
1779 if (cnt
> 0 && ! xg_timer
) xg_start_timer ();
1780 else if (cnt
== 0 && xg_timer
) xg_stop_timer ();
1783 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1784 must be non-NULL) and can be inserted into a menu item.
1786 Returns the GtkHBox. */
1789 make_widget_for_menu_item (utf8_label
, utf8_key
)
1797 wbox
= gtk_hbox_new (FALSE
, 0);
1798 wlbl
= gtk_label_new (utf8_label
);
1799 wkey
= gtk_label_new (utf8_key
);
1801 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1802 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1804 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1805 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1807 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1808 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1809 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1814 /* Make and return a menu item widget with the key to the right.
1815 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1816 UTF8_KEY is the text representing the key binding.
1817 ITEM is the widget_value describing the menu item.
1819 GROUP is an in/out parameter. If the menu item to be created is not
1820 part of any radio menu group, *GROUP contains NULL on entry and exit.
1821 If the menu item to be created is part of a radio menu group, on entry
1822 *GROUP contains the group to use, or NULL if this is the first item
1823 in the group. On exit, *GROUP contains the radio item group.
1825 Unfortunately, keys don't line up as nicely as in Motif,
1826 but the MacOS X version doesn't either, so I guess that is OK. */
1829 make_menu_item (utf8_label
, utf8_key
, item
, group
)
1836 GtkWidget
*wtoadd
= 0;
1838 /* It has been observed that some menu items have a NULL name field.
1839 This will lead to this function being called with a NULL utf8_label.
1840 GTK crashes on that so we set a blank label. Why there is a NULL
1841 name remains to be investigated. */
1842 if (! utf8_label
) utf8_label
= " ";
1845 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1847 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1850 if (utf8_key
) w
= gtk_check_menu_item_new ();
1851 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1852 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1854 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1856 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1857 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1858 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1860 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1865 if (utf8_key
) w
= gtk_menu_item_new ();
1866 else w
= gtk_menu_item_new_with_label (utf8_label
);
1869 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1870 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1875 /* Return non-zero if LABEL specifies a separator (GTK only has one
1879 xg_separator_p (char *label
)
1881 if (! label
) return 0;
1882 else if (strlen (label
) > 3
1883 && strncmp (label
, "--", 2) == 0
1886 static char* separator_names
[] = {
1891 "single-dashed-line",
1892 "double-dashed-line",
1894 "shadow-etched-out",
1895 "shadow-etched-in-dash",
1896 "shadow-etched-out-dash",
1897 "shadow-double-etched-in",
1898 "shadow-double-etched-out",
1899 "shadow-double-etched-in-dash",
1900 "shadow-double-etched-out-dash",
1907 for (i
= 0; separator_names
[i
]; ++i
)
1908 if (strcmp (label
, separator_names
[i
]) == 0)
1913 /* Old-style separator, maybe. It's a separator if it contains
1915 while (*label
== '-')
1917 if (*label
== 0) return 1;
1923 static int xg_detached_menus
;
1925 /* Returns non-zero if there are detached menus. */
1928 xg_have_tear_offs ()
1930 return xg_detached_menus
> 0;
1933 /* Callback invoked when a detached menu window is removed. Here we
1934 decrease the xg_detached_menus count.
1935 WIDGET is the top level window that is removed (the parent of the menu).
1936 CLIENT_DATA is not used. */
1939 tearoff_remove (widget
, client_data
)
1941 gpointer client_data
;
1943 if (xg_detached_menus
> 0) --xg_detached_menus
;
1946 /* Callback invoked when a menu is detached. It increases the
1947 xg_detached_menus count.
1948 WIDGET is the GtkTearoffMenuItem.
1949 CLIENT_DATA is not used. */
1952 tearoff_activate (widget
, client_data
)
1954 gpointer client_data
;
1956 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
1957 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
1959 ++xg_detached_menus
;
1960 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
1962 G_CALLBACK (tearoff_remove
), 0);
1967 /* Create a menu item widget, and connect the callbacks.
1968 ITEM decribes the menu item.
1969 F is the frame the created menu belongs to.
1970 SELECT_CB is the callback to use when a menu item is selected.
1971 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1972 CL_DATA points to the callback data to be used for this menu.
1973 GROUP is an in/out parameter. If the menu item to be created is not
1974 part of any radio menu group, *GROUP contains NULL on entry and exit.
1975 If the menu item to be created is part of a radio menu group, on entry
1976 *GROUP contains the group to use, or NULL if this is the first item
1977 in the group. On exit, *GROUP contains the radio item group.
1979 Returns the created GtkWidget. */
1982 xg_create_one_menuitem (item
, f
, select_cb
, highlight_cb
, cl_data
, group
)
1985 GCallback select_cb
;
1986 GCallback highlight_cb
;
1987 xg_menu_cb_data
*cl_data
;
1993 xg_menu_item_cb_data
*cb_data
;
1995 utf8_label
= get_utf8_string (item
->name
);
1996 utf8_key
= get_utf8_string (item
->key
);
1998 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2000 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2001 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
2003 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2005 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2007 cb_data
->unhighlight_id
= cb_data
->highlight_id
= cb_data
->select_id
= 0;
2008 cb_data
->help
= item
->help
;
2009 cb_data
->cl_data
= cl_data
;
2010 cb_data
->call_data
= item
->call_data
;
2012 g_signal_connect (G_OBJECT (w
),
2014 G_CALLBACK (menuitem_destroy_callback
),
2017 /* Put cb_data in widget, so we can get at it when modifying menubar */
2018 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2020 /* final item, not a submenu */
2021 if (item
->call_data
&& ! item
->contents
)
2025 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2028 if (! NILP (item
->help
) && highlight_cb
)
2030 /* We use enter/leave notify instead of select/deselect because
2031 select/deselect doesn't go well with detached menus. */
2032 cb_data
->highlight_id
2033 = g_signal_connect (G_OBJECT (w
),
2034 "enter-notify-event",
2035 G_CALLBACK (menuitem_highlight_callback
),
2037 cb_data
->unhighlight_id
2038 = g_signal_connect (G_OBJECT (w
),
2039 "leave-notify-event",
2040 G_CALLBACK (menuitem_highlight_callback
),
2047 /* Callback called when keyboard traversal (started by menu-bar-open) ends.
2048 WMENU is the menu for which traversal has been done. DATA points to the
2049 frame for WMENU. We must release grabs, some bad interaction between GTK
2050 and Emacs makes the menus keep the grabs. */
2053 menu_nav_ended (wmenu
, data
)
2054 GtkMenuShell
*wmenu
;
2057 FRAME_PTR f
= (FRAME_PTR
) data
;
2059 if (FRAME_X_OUTPUT (f
)->menubar_widget
)
2061 GtkMenuShell
*w
= GTK_MENU_SHELL (FRAME_X_OUTPUT (f
)->menubar_widget
);
2062 Display
*dpy
= FRAME_X_DISPLAY (f
);
2065 gtk_menu_shell_deactivate (w
);
2066 gtk_menu_shell_deselect (w
);
2068 XUngrabKeyboard (dpy
, CurrentTime
);
2069 XUngrabPointer (dpy
, CurrentTime
);
2075 static GtkWidget
*create_menus
P_ ((widget_value
*, FRAME_PTR
, GCallback
,
2076 GCallback
, GCallback
, int, int, int,
2077 GtkWidget
*, xg_menu_cb_data
*, char *));
2079 /* Create a full menu tree specified by DATA.
2080 F is the frame the created menu belongs to.
2081 SELECT_CB is the callback to use when a menu item is selected.
2082 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2083 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2084 POP_UP_P is non-zero if we shall create a popup menu.
2085 MENU_BAR_P is non-zero if we shall create a menu bar.
2086 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2087 if MENU_BAR_P is non-zero.
2088 TOPMENU is the topmost GtkWidget that others shall be placed under.
2089 It may be NULL, in that case we create the appropriate widget
2090 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2091 CL_DATA is the callback data we shall use for this menu, or NULL
2092 if we haven't set the first callback yet.
2093 NAME is the name to give to the top level menu if this function
2094 creates it. May be NULL to not set any name.
2096 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2099 This function calls itself to create submenus. */
2102 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2103 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
2106 GCallback select_cb
;
2107 GCallback deactivate_cb
;
2108 GCallback highlight_cb
;
2113 xg_menu_cb_data
*cl_data
;
2117 GtkWidget
*wmenu
= topmenu
;
2118 GSList
*group
= NULL
;
2124 wmenu
= gtk_menu_new ();
2125 xg_set_screen (wmenu
, f
);
2127 else wmenu
= gtk_menu_bar_new ();
2129 /* Fix up grabs after keyboard traversal ends. */
2130 g_signal_connect (G_OBJECT (wmenu
),
2132 G_CALLBACK (menu_nav_ended
),
2135 /* Put cl_data on the top menu for easier access. */
2136 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2137 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2138 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2139 G_CALLBACK (menu_destroy_callback
), cl_data
);
2142 gtk_widget_set_name (wmenu
, name
);
2145 g_signal_connect (G_OBJECT (wmenu
),
2146 "selection-done", deactivate_cb
, 0);
2148 g_signal_connect (G_OBJECT (wmenu
),
2149 "grab-notify", G_CALLBACK (menu_grab_callback
), 0);
2152 if (! menu_bar_p
&& add_tearoff_p
)
2154 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2155 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2157 g_signal_connect (G_OBJECT (tearoff
), "activate",
2158 G_CALLBACK (tearoff_activate
), 0);
2161 for (item
= data
; item
; item
= item
->next
)
2165 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2166 && !xg_separator_p (item
->name
))
2169 /* A title for a popup. We do the same as GTK does when
2170 creating titles, but it does not look good. */
2172 utf8_label
= get_utf8_string (item
->name
);
2174 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2175 w
= gtk_menu_item_new_with_label (utf8_label
);
2176 gtk_widget_set_sensitive (w
, FALSE
);
2177 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2179 else if (xg_separator_p (item
->name
))
2182 /* GTK only have one separator type. */
2183 w
= gtk_separator_menu_item_new ();
2187 w
= xg_create_one_menuitem (item
,
2189 item
->contents
? 0 : select_cb
,
2196 GtkWidget
*submenu
= create_menus (item
->contents
,
2207 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2211 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2212 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2218 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2219 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2220 with some text and buttons.
2221 F is the frame the created item belongs to.
2222 NAME is the name to use for the top widget.
2223 VAL is a widget_value structure describing items to be created.
2224 SELECT_CB is the callback to use when a menu item is selected or
2225 a dialog button is pressed.
2226 DEACTIVATE_CB is the callback to use when an item is deactivated.
2227 For a menu, when a sub menu is not shown anymore, for a dialog it is
2228 called when the dialog is popped down.
2229 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2231 Returns the widget created. */
2234 xg_create_widget (type
, name
, f
, val
,
2235 select_cb
, deactivate_cb
, highlight_cb
)
2240 GCallback select_cb
;
2241 GCallback deactivate_cb
;
2242 GCallback highlight_cb
;
2245 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2246 int pop_up_p
= strcmp (type
, "popup") == 0;
2248 if (strcmp (type
, "dialog") == 0)
2250 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2251 xg_set_screen (w
, f
);
2252 gtk_window_set_transient_for (GTK_WINDOW (w
),
2253 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2254 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2255 gtk_widget_set_name (w
, "emacs-dialog");
2256 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2258 else if (menu_bar_p
|| pop_up_p
)
2260 w
= create_menus (val
->contents
,
2272 /* Set the cursor to an arrow for popup menus when they are mapped.
2273 This is done by default for menu bar menus. */
2276 /* Must realize so the GdkWindow inside the widget is created. */
2277 gtk_widget_realize (w
);
2278 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2283 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2290 /* Return the label for menu item WITEM. */
2293 xg_get_menu_item_label (witem
)
2296 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2297 return gtk_label_get_label (wlabel
);
2300 /* Return non-zero if the menu item WITEM has the text LABEL. */
2303 xg_item_label_same_p (witem
, label
)
2308 char *utf8_label
= get_utf8_string (label
);
2309 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2311 if (! old_label
&& ! utf8_label
)
2313 else if (old_label
&& utf8_label
)
2314 is_same
= strcmp (utf8_label
, old_label
) == 0;
2316 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2321 /* Destroy widgets in LIST. */
2324 xg_destroy_widgets (list
)
2329 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2331 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2333 /* Destroying the widget will remove it from the container it is in. */
2334 gtk_widget_destroy (w
);
2338 /* Update the top level names in MENUBAR (i.e. not submenus).
2339 F is the frame the menu bar belongs to.
2340 *LIST is a list with the current menu bar names (menu item widgets).
2341 ITER is the item within *LIST that shall be updated.
2342 POS is the numerical position, starting at 0, of ITER in *LIST.
2343 VAL describes what the menu bar shall look like after the update.
2344 SELECT_CB is the callback to use when a menu item is selected.
2345 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2346 CL_DATA points to the callback data to be used for this menu bar.
2348 This function calls itself to walk through the menu bar names. */
2351 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2352 select_cb
, highlight_cb
, cl_data
)
2359 GCallback select_cb
;
2360 GCallback highlight_cb
;
2361 xg_menu_cb_data
*cl_data
;
2363 if (! iter
&& ! val
)
2365 else if (iter
&& ! val
)
2367 /* Item(s) have been removed. Remove all remaining items. */
2368 xg_destroy_widgets (iter
);
2374 else if (! iter
&& val
)
2376 /* Item(s) added. Add all new items in one call. */
2377 create_menus (val
, f
, select_cb
, 0, highlight_cb
,
2378 0, 1, 0, menubar
, cl_data
, 0);
2384 /* Below this neither iter or val is NULL */
2385 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2387 /* This item is still the same, check next item. */
2389 iter
= g_list_next (iter
);
2392 else /* This item is changed. */
2394 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2395 GtkMenuItem
*witem2
= 0;
2396 int val_in_menubar
= 0;
2397 int iter_in_new_menubar
= 0;
2401 /* See if the changed entry (val) is present later in the menu bar */
2403 iter2
&& ! val_in_menubar
;
2404 iter2
= g_list_next (iter2
))
2406 witem2
= GTK_MENU_ITEM (iter2
->data
);
2407 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2410 /* See if the current entry (iter) is present later in the
2411 specification for the new menu bar. */
2412 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2413 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2415 if (val_in_menubar
&& ! iter_in_new_menubar
)
2419 /* This corresponds to:
2424 gtk_widget_ref (GTK_WIDGET (witem
));
2425 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2426 gtk_widget_destroy (GTK_WIDGET (witem
));
2428 /* Must get new list since the old changed. */
2429 g_list_free (*list
);
2430 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2431 while (nr
-- > 0) iter
= g_list_next (iter
);
2433 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2435 /* This corresponds to:
2438 Rename B to X. This might seem to be a strange thing to do,
2439 since if there is a menu under B it will be totally wrong for X.
2440 But consider editing a C file. Then there is a C-mode menu
2441 (corresponds to B above).
2442 If then doing C-x C-f the minibuf menu (X above) replaces the
2443 C-mode menu. When returning from the minibuffer, we get
2444 back the C-mode menu. Thus we do:
2445 Rename B to X (C-mode to minibuf menu)
2446 Rename X to B (minibuf to C-mode menu).
2447 If the X menu hasn't been invoked, the menu under B
2448 is up to date when leaving the minibuffer. */
2449 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2450 char *utf8_label
= get_utf8_string (val
->name
);
2451 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2453 gtk_label_set_text (wlabel
, utf8_label
);
2455 /* If this item has a submenu that has been detached, change
2456 the title in the WM decorations also. */
2457 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2458 /* Set the title of the detached window. */
2459 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2461 iter
= g_list_next (iter
);
2465 else if (! val_in_menubar
&& iter_in_new_menubar
)
2467 /* This corresponds to:
2474 GtkWidget
*w
= xg_create_one_menuitem (val
,
2481 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2482 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2484 g_list_free (*list
);
2485 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2486 while (nr
-- > 0) iter
= g_list_next (iter
);
2487 iter
= g_list_next (iter
);
2491 else /* if (val_in_menubar && iter_in_new_menubar) */
2494 /* This corresponds to:
2499 gtk_widget_ref (GTK_WIDGET (witem2
));
2500 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2501 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2502 GTK_WIDGET (witem2
), pos
);
2503 gtk_widget_unref (GTK_WIDGET (witem2
));
2505 g_list_free (*list
);
2506 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2507 while (nr
-- > 0) iter
= g_list_next (iter
);
2513 /* Update the rest of the menu bar. */
2514 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2515 select_cb
, highlight_cb
, cl_data
);
2518 /* Update the menu item W so it corresponds to VAL.
2519 SELECT_CB is the callback to use when a menu item is selected.
2520 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2521 CL_DATA is the data to set in the widget for menu invokation. */
2524 xg_update_menu_item (val
, w
, select_cb
, highlight_cb
, cl_data
)
2527 GCallback select_cb
;
2528 GCallback highlight_cb
;
2529 xg_menu_cb_data
*cl_data
;
2536 const char *old_label
= 0;
2537 const char *old_key
= 0;
2538 xg_menu_item_cb_data
*cb_data
;
2540 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2541 utf8_label
= get_utf8_string (val
->name
);
2542 utf8_key
= get_utf8_string (val
->key
);
2544 /* See if W is a menu item with a key. See make_menu_item above. */
2545 if (GTK_IS_HBOX (wchild
))
2547 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2549 wlbl
= GTK_LABEL (list
->data
);
2550 wkey
= GTK_LABEL (list
->next
->data
);
2555 /* Remove the key and keep just the label. */
2556 gtk_widget_ref (GTK_WIDGET (wlbl
));
2557 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2558 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2563 else /* Just a label. */
2565 wlbl
= GTK_LABEL (wchild
);
2567 /* Check if there is now a key. */
2570 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2571 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2573 wlbl
= GTK_LABEL (list
->data
);
2574 wkey
= GTK_LABEL (list
->next
->data
);
2577 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2578 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2583 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2584 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2586 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2587 gtk_label_set_text (wkey
, utf8_key
);
2589 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2590 gtk_label_set_text (wlbl
, utf8_label
);
2592 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2593 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2595 if (! val
->enabled
&& GTK_WIDGET_SENSITIVE (w
))
2596 gtk_widget_set_sensitive (w
, FALSE
);
2597 else if (val
->enabled
&& ! GTK_WIDGET_SENSITIVE (w
))
2598 gtk_widget_set_sensitive (w
, TRUE
);
2600 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2604 cb_data
->call_data
= val
->call_data
;
2605 cb_data
->help
= val
->help
;
2606 cb_data
->cl_data
= cl_data
;
2608 /* We assume the callback functions don't change. */
2609 if (val
->call_data
&& ! val
->contents
)
2611 /* This item shall have a select callback. */
2612 if (! cb_data
->select_id
)
2614 = g_signal_connect (G_OBJECT (w
), "activate",
2615 select_cb
, cb_data
);
2617 else if (cb_data
->select_id
)
2619 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2620 cb_data
->select_id
= 0;
2623 if (NILP (cb_data
->help
))
2625 /* Shall not have help. Remove if any existed previously. */
2626 if (cb_data
->highlight_id
)
2628 g_signal_handler_disconnect (G_OBJECT (w
),
2629 cb_data
->highlight_id
);
2630 cb_data
->highlight_id
= 0;
2632 if (cb_data
->unhighlight_id
)
2634 g_signal_handler_disconnect (G_OBJECT (w
),
2635 cb_data
->unhighlight_id
);
2636 cb_data
->unhighlight_id
= 0;
2639 else if (! cb_data
->highlight_id
&& highlight_cb
)
2641 /* Have help now, but didn't previously. Add callback. */
2642 cb_data
->highlight_id
2643 = g_signal_connect (G_OBJECT (w
),
2644 "enter-notify-event",
2645 G_CALLBACK (menuitem_highlight_callback
),
2647 cb_data
->unhighlight_id
2648 = g_signal_connect (G_OBJECT (w
),
2649 "leave-notify-event",
2650 G_CALLBACK (menuitem_highlight_callback
),
2656 /* Update the toggle menu item W so it corresponds to VAL. */
2659 xg_update_toggle_item (val
, w
)
2663 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2666 /* Update the radio menu item W so it corresponds to VAL. */
2669 xg_update_radio_item (val
, w
)
2673 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2676 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2677 SUBMENU may be NULL, in that case a new menu is created.
2678 F is the frame the menu bar belongs to.
2679 VAL describes the contents of the menu bar.
2680 SELECT_CB is the callback to use when a menu item is selected.
2681 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2682 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2683 CL_DATA is the call back data to use for any newly created items.
2685 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2689 xg_update_submenu (submenu
, f
, val
,
2690 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2694 GCallback select_cb
;
2695 GCallback deactivate_cb
;
2696 GCallback highlight_cb
;
2697 xg_menu_cb_data
*cl_data
;
2699 GtkWidget
*newsub
= submenu
;
2703 int has_tearoff_p
= 0;
2704 GList
*first_radio
= 0;
2707 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2709 for (cur
= val
, iter
= list
;
2711 iter
= g_list_next (iter
), cur
= cur
->next
)
2713 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2715 /* Skip tearoff items, they have no counterpart in val. */
2716 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2719 iter
= g_list_next (iter
);
2720 if (iter
) w
= GTK_WIDGET (iter
->data
);
2724 /* Remember first radio button in a group. If we get a mismatch in
2725 a radio group we must rebuild the whole group so that the connections
2726 in GTK becomes correct. */
2727 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2729 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2730 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2733 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2735 if (! xg_separator_p (cur
->name
))
2738 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2740 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2742 xg_update_toggle_item (cur
, w
);
2743 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2745 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2747 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2749 xg_update_radio_item (cur
, w
);
2750 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2752 else if (GTK_IS_MENU_ITEM (w
))
2754 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2757 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2758 xg_separator_p (cur
->name
))
2761 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2763 sub
= gtk_menu_item_get_submenu (witem
);
2764 if (sub
&& ! cur
->contents
)
2766 /* Not a submenu anymore. */
2767 gtk_widget_ref (sub
);
2768 gtk_menu_item_remove_submenu (witem
);
2769 gtk_widget_destroy (sub
);
2771 else if (cur
->contents
)
2775 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2776 select_cb
, deactivate_cb
,
2777 highlight_cb
, cl_data
);
2779 /* If this item just became a submenu, we must set it. */
2781 gtk_menu_item_set_submenu (witem
, nsub
);
2786 /* Structural difference. Remove everything from here and down
2792 /* Remove widgets from first structual change. */
2795 /* If we are adding new menu items below, we must remove from
2796 first radio button so that radio groups become correct. */
2797 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2798 else xg_destroy_widgets (iter
);
2803 /* More items added. Create them. */
2804 newsub
= create_menus (cur
,
2817 if (list
) g_list_free (list
);
2822 /* Update the MENUBAR.
2823 F is the frame the menu bar belongs to.
2824 VAL describes the contents of the menu bar.
2825 If DEEP_P is non-zero, rebuild all but the top level menu names in
2826 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2827 SELECT_CB is the callback to use when a menu item is selected.
2828 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2829 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2832 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2833 select_cb
, deactivate_cb
, highlight_cb
)
2838 GCallback select_cb
;
2839 GCallback deactivate_cb
;
2840 GCallback highlight_cb
;
2842 xg_menu_cb_data
*cl_data
;
2843 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2847 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2850 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2851 select_cb
, highlight_cb
, cl_data
);
2857 /* Update all sub menus.
2858 We must keep the submenus (GTK menu item widgets) since the
2859 X Window in the XEvent that activates the menu are those widgets. */
2861 /* Update cl_data, menu_item things in F may have changed. */
2862 update_cl_data (cl_data
, f
, highlight_cb
);
2864 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2871 /* Find sub menu that corresponds to val and update it. */
2872 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2874 witem
= GTK_MENU_ITEM (iter
->data
);
2875 if (xg_item_label_same_p (witem
, cur
->name
))
2877 sub
= gtk_menu_item_get_submenu (witem
);
2882 newsub
= xg_update_submenu (sub
,
2889 /* sub may still be NULL. If we just updated non deep and added
2890 a new menu bar item, it has no sub menu yet. So we set the
2891 newly created sub menu under witem. */
2894 xg_set_screen (newsub
, f
);
2895 gtk_menu_item_set_submenu (witem
, newsub
);
2901 gtk_widget_show_all (menubar
);
2904 /* Recompute all the widgets of frame F, when the menu bar has been
2905 changed. Value is non-zero if widgets were updated. */
2908 xg_update_frame_menubar (f
)
2911 struct x_output
*x
= f
->output_data
.x
;
2914 if (!x
->menubar_widget
|| GTK_WIDGET_MAPPED (x
->menubar_widget
))
2919 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2921 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2923 gtk_widget_show_all (x
->menubar_widget
);
2924 gtk_widget_size_request (x
->menubar_widget
, &req
);
2926 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2928 /* The height has changed, resize outer widget and set columns
2929 rows to what we had before adding the menu bar. */
2930 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2932 SET_FRAME_GARBAGED (f
);
2938 /* Get rid of the menu bar of frame F, and free its storage.
2939 This is used when deleting a frame, and when turning off the menu bar. */
2942 free_frame_menubar (f
)
2945 struct x_output
*x
= f
->output_data
.x
;
2947 if (x
->menubar_widget
)
2951 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2952 /* The menubar and its children shall be deleted when removed from
2954 x
->menubar_widget
= 0;
2955 FRAME_MENUBAR_HEIGHT (f
) = 0;
2957 /* The height has changed, resize outer widget and set columns
2958 rows to what we had before removing the menu bar. */
2959 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2961 SET_FRAME_GARBAGED (f
);
2968 /***********************************************************************
2969 Scroll bar functions
2970 ***********************************************************************/
2973 /* Setting scroll bar values invokes the callback. Use this variable
2974 to indicate that callback should do nothing. */
2976 int xg_ignore_gtk_scrollbar
;
2978 /* SET_SCROLL_BAR_X_WINDOW assumes the second argument fits in
2979 32 bits. But we want to store pointers, and they may be larger
2980 than 32 bits. Keep a mapping from integer index to widget pointers
2981 to get around the 32 bit limitation. */
2985 GtkWidget
**widgets
;
2990 /* Grow this much every time we need to allocate more */
2992 #define ID_TO_WIDGET_INCR 32
2994 /* Store the widget pointer W in id_to_widget and return the integer index. */
2997 xg_store_widget_in_map (w
)
3002 if (id_to_widget
.max_size
== id_to_widget
.used
)
3004 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3006 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
3007 sizeof (GtkWidget
*)*new_size
);
3009 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3010 id_to_widget
.widgets
[i
] = 0;
3011 id_to_widget
.max_size
= new_size
;
3014 /* Just loop over the array and find a free place. After all,
3015 how many scroll bars are we creating? Should be a small number.
3016 The check above guarantees we will find a free place. */
3017 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3019 if (! id_to_widget
.widgets
[i
])
3021 id_to_widget
.widgets
[i
] = w
;
3022 ++id_to_widget
.used
;
3028 /* Should never end up here */
3032 /* Remove pointer at IDX from id_to_widget.
3033 Called when scroll bar is destroyed. */
3036 xg_remove_widget_from_map (idx
)
3039 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3041 id_to_widget
.widgets
[idx
] = 0;
3042 --id_to_widget
.used
;
3046 /* Get the widget pointer at IDX from id_to_widget. */
3049 xg_get_widget_from_map (idx
)
3052 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3053 return id_to_widget
.widgets
[idx
];
3058 /* Return the scrollbar id for X Window WID on display DPY.
3059 Return -1 if WID not in id_to_widget. */
3062 xg_get_scroll_id_for_window (dpy
, wid
)
3069 w
= xg_win_to_widget (dpy
, wid
);
3073 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3074 if (id_to_widget
.widgets
[idx
] == w
)
3081 /* Callback invoked when scroll bar WIDGET is destroyed.
3082 DATA is the index into id_to_widget for WIDGET.
3083 We free pointer to last scroll bar values here and remove the index. */
3086 xg_gtk_scroll_destroy (widget
, data
)
3091 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
3093 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
3095 xg_remove_widget_from_map (id
);
3098 /* Callback for button press/release events. Used to start timer so that
3099 the scroll bar repetition timer in GTK gets handeled.
3100 Also, sets bar->dragging to Qnil when dragging (button release) is done.
3101 WIDGET is the scroll bar widget the event is for (not used).
3102 EVENT contains the event.
3103 USER_DATA points to the struct scrollbar structure.
3105 Returns FALSE to tell GTK that it shall continue propagate the event
3109 scroll_bar_button_cb (widget
, event
, user_data
)
3111 GdkEventButton
*event
;
3114 if (event
->type
== GDK_BUTTON_PRESS
&& ! xg_timer
)
3116 else if (event
->type
== GDK_BUTTON_RELEASE
)
3118 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
3119 if (xg_timer
) xg_stop_timer ();
3120 bar
->dragging
= Qnil
;
3126 /* Create a scroll bar widget for frame F. Store the scroll bar
3128 SCROLL_CALLBACK is the callback to invoke when the value of the
3130 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3131 to set resources for the widget. */
3134 xg_create_scroll_bar (f
, bar
, scroll_callback
, scroll_bar_name
)
3136 struct scroll_bar
*bar
;
3137 GCallback scroll_callback
;
3138 char *scroll_bar_name
;
3145 /* Page, step increment values are not so important here, they
3146 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3147 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3150 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3151 webox
= gtk_event_box_new ();
3152 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3153 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3155 scroll_id
= xg_store_widget_in_map (wscroll
);
3157 g_signal_connect (G_OBJECT (wscroll
),
3161 /* The EMACS_INT cast avoids a warning. */
3162 g_signal_connect (G_OBJECT (wscroll
),
3164 G_CALLBACK (xg_gtk_scroll_destroy
),
3165 (gpointer
) (EMACS_INT
) scroll_id
);
3167 /* Connect to button press and button release to detect if any scroll bar
3169 g_signal_connect (G_OBJECT (wscroll
),
3170 "button-press-event",
3171 G_CALLBACK (scroll_bar_button_cb
),
3173 g_signal_connect (G_OBJECT (wscroll
),
3174 "button-release-event",
3175 G_CALLBACK (scroll_bar_button_cb
),
3178 /* The scroll bar widget does not draw on a window of its own. Instead
3179 it draws on the parent window, in this case the edit widget. So
3180 whenever the edit widget is cleared, the scroll bar needs to redraw
3181 also, which causes flicker. Put an event box between the edit widget
3182 and the scroll bar, so the scroll bar instead draws itself on the
3183 event box window. */
3184 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3185 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3188 /* Set the cursor to an arrow. */
3189 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3191 SET_SCROLL_BAR_X_WINDOW (bar
, scroll_id
);
3194 /* Make the scroll bar represented by SCROLLBAR_ID visible. */
3197 xg_show_scroll_bar (scrollbar_id
)
3200 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3202 gtk_widget_show_all (gtk_widget_get_parent (w
));
3205 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3208 xg_remove_scroll_bar (f
, scrollbar_id
)
3212 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3215 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3216 gtk_widget_destroy (w
);
3217 gtk_widget_destroy (wparent
);
3218 SET_FRAME_GARBAGED (f
);
3222 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3224 TOP/LEFT are the new pixel positions where the bar shall appear.
3225 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3228 xg_update_scrollbar_pos (f
, scrollbar_id
, top
, left
, width
, height
)
3237 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3241 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3242 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3244 /* Move and resize to new values. */
3245 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3246 gtk_widget_set_size_request (wscroll
, width
, height
);
3247 gtk_widget_queue_draw (wparent
);
3248 gdk_window_process_all_updates ();
3249 /* GTK does not redraw until the main loop is entered again, but
3250 if there are no X events pending we will not enter it. So we sync
3251 here to get some events. */
3253 SET_FRAME_GARBAGED (f
);
3254 cancel_mouse_face (f
);
3258 /* Set the thumb size and position of scroll bar BAR. We are currently
3259 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3262 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
3263 struct scroll_bar
*bar
;
3264 int portion
, position
, whole
;
3266 GtkWidget
*wscroll
= xg_get_widget_from_map (SCROLL_BAR_X_WINDOW (bar
));
3268 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3270 if (wscroll
&& NILP (bar
->dragging
))
3279 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3281 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3282 rather than the real portion value. This makes the thumb less likely
3283 to resize and that looks better. */
3284 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3285 /* When the thumb is at the bottom, position == whole.
3286 So we need to increase `whole' to make space for the thumb. */
3293 top
= (gdouble
) position
/ whole
;
3294 shown
= (gdouble
) portion
/ whole
;
3297 size
= shown
* XG_SB_RANGE
;
3298 size
= min (size
, XG_SB_RANGE
);
3299 size
= max (size
, 1);
3301 value
= top
* XG_SB_RANGE
;
3302 value
= min (value
, XG_SB_MAX
- size
);
3303 value
= max (value
, XG_SB_MIN
);
3305 /* Assume all lines are of equal size. */
3306 new_step
= size
/ max (1, FRAME_LINES (f
));
3308 if ((int) adj
->page_size
!= size
3309 || (int) adj
->step_increment
!= new_step
)
3311 adj
->page_size
= size
;
3312 adj
->step_increment
= new_step
;
3313 /* Assume a page increment is about 95% of the page size */
3314 adj
->page_increment
= (int) (0.95*adj
->page_size
);
3318 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3320 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3324 /* gtk_range_set_value invokes the callback. Set
3325 ignore_gtk_scrollbar to make the callback do nothing */
3326 xg_ignore_gtk_scrollbar
= 1;
3328 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3329 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3331 gtk_adjustment_changed (adj
);
3333 xg_ignore_gtk_scrollbar
= 0;
3341 /***********************************************************************
3343 ***********************************************************************/
3344 /* The key for the data we put in the GtkImage widgets. The data is
3345 the image used by Emacs. We use this to see if we need to update
3346 the GtkImage with a new image. */
3347 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3349 /* The key for storing the latest modifiers so the activate callback can
3351 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3355 xg_tool_bar_button_cb (widget
, event
, user_data
)
3357 GdkEventButton
*event
;
3360 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3361 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3362 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3367 /* Callback function invoked when a tool bar item is pressed.
3368 W is the button widget in the tool bar that got pressed,
3369 CLIENT_DATA is an integer that is the index of the button in the
3370 tool bar. 0 is the first button. */
3373 xg_tool_bar_callback (w
, client_data
)
3375 gpointer client_data
;
3377 /* The EMACS_INT cast avoids a warning. */
3378 int idx
= (int) (EMACS_INT
) client_data
;
3379 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3380 XG_TOOL_BAR_LAST_MODIFIER
);
3382 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3383 Lisp_Object key
, frame
;
3384 struct input_event event
;
3387 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3390 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3392 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3393 XSETFRAME (frame
, f
);
3394 event
.kind
= TOOL_BAR_EVENT
;
3395 event
.frame_or_window
= frame
;
3397 kbd_buffer_store_event (&event
);
3399 event
.kind
= TOOL_BAR_EVENT
;
3400 event
.frame_or_window
= frame
;
3402 /* Convert between the modifier bits GDK uses and the modifier bits
3403 Emacs uses. This assumes GDK an X masks are the same, which they are when
3405 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3406 kbd_buffer_store_event (&event
);
3409 /* This callback is called when a tool bar is detached. We must set
3410 the height of the tool bar to zero when this happens so frame sizes
3411 are correctly calculated.
3412 WBOX is the handle box widget that enables detach/attach of the tool bar.
3413 W is the tool bar widget.
3414 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3417 xg_tool_bar_detach_callback (wbox
, w
, client_data
)
3420 gpointer client_data
;
3422 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3423 extern int x_gtk_whole_detached_tool_bar
;
3425 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3430 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3432 /* When detaching a tool bar, not everything dissapear. There are
3433 a few pixels left that are used to drop the tool bar back into
3435 FRAME_TOOLBAR_HEIGHT (f
) = 2;
3437 /* The height has changed, resize outer widget and set columns
3438 rows to what we had before detaching the tool bar. */
3439 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3443 /* This callback is called when a tool bar is reattached. We must set
3444 the height of the tool bar when this happens so frame sizes
3445 are correctly calculated.
3446 WBOX is the handle box widget that enables detach/attach of the tool bar.
3447 W is the tool bar widget.
3448 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3451 xg_tool_bar_attach_callback (wbox
, w
, client_data
)
3454 gpointer client_data
;
3456 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3457 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3463 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3465 gtk_widget_size_request (w
, &req
);
3466 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3468 /* The height has changed, resize outer widget and set columns
3469 rows to what we had before attaching the tool bar. */
3470 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3474 /* This callback is called when the mouse enters or leaves a tool bar item.
3475 It is used for displaying and hiding the help text.
3476 W is the tool bar item, a button.
3477 EVENT is either an enter event or leave event.
3478 CLIENT_DATA is an integer that is the index of the button in the
3479 tool bar. 0 is the first button.
3481 Returns FALSE to tell GTK to keep processing this event. */
3484 xg_tool_bar_help_callback (w
, event
, client_data
)
3486 GdkEventCrossing
*event
;
3487 gpointer client_data
;
3489 /* The EMACS_INT cast avoids a warning. */
3490 int idx
= (int) (EMACS_INT
) client_data
;
3491 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3492 Lisp_Object help
, frame
;
3494 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3497 if (event
->type
== GDK_ENTER_NOTIFY
)
3499 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3500 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3503 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3508 XSETFRAME (frame
, f
);
3509 kbd_buffer_store_help_event (frame
, help
);
3515 /* This callback is called when a tool bar item shall be redrawn.
3516 It modifies the expose event so that the GtkImage widget redraws the
3517 whole image. This to overcome a bug that makes GtkImage draw the image
3518 in the wrong place when it tries to redraw just a part of the image.
3519 W is the GtkImage to be redrawn.
3520 EVENT is the expose event for W.
3521 CLIENT_DATA is unused.
3523 Returns FALSE to tell GTK to keep processing this event. */
3526 xg_tool_bar_item_expose_callback (w
, event
, client_data
)
3528 GdkEventExpose
*event
;
3529 gpointer client_data
;
3533 gdk_drawable_get_size (event
->window
, &width
, &height
);
3535 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3536 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3538 event
->area
.x
= max (0, event
->area
.x
);
3539 event
->area
.y
= max (0, event
->area
.y
);
3541 event
->area
.width
= max (width
, event
->area
.width
);
3542 event
->area
.height
= max (height
, event
->area
.height
);
3547 /* This callback is called when a tool bar shall be redrawn.
3548 We need to update the tool bar from here in case the image cache
3549 has deleted the pixmaps used in the tool bar.
3550 W is the GtkToolbar to be redrawn.
3551 EVENT is the expose event for W.
3552 CLIENT_DATA is pointing to the frame for this tool bar.
3554 Returns FALSE to tell GTK to keep processing this event. */
3557 xg_tool_bar_expose_callback (w
, event
, client_data
)
3559 GdkEventExpose
*event
;
3560 gpointer client_data
;
3562 update_frame_tool_bar ((FRAME_PTR
) client_data
);
3566 /* Create a tool bar for frame F. */
3569 xg_create_tool_bar (f
)
3572 struct x_output
*x
= f
->output_data
.x
;
3574 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3576 x
->toolbar_widget
= gtk_toolbar_new ();
3577 x
->handlebox_widget
= gtk_handle_box_new ();
3578 x
->toolbar_detached
= 0;
3580 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3583 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3586 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3589 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3591 /* We only have icons, so override any user setting. We could
3592 use the caption property of the toolbar item (see update_frame_tool_bar
3593 below), but some of those strings are long, making the toolbar so
3594 long it does not fit on the screen. The GtkToolbar widget makes every
3595 item equal size, so the longest caption determine the size of every
3596 tool bar item. I think the creators of the GtkToolbar widget
3597 counted on 4 or 5 character long strings. */
3598 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3599 gtk_toolbar_set_orientation (GTK_TOOLBAR (x
->toolbar_widget
),
3600 GTK_ORIENTATION_HORIZONTAL
);
3602 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3603 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3604 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3605 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3606 g_signal_connect (G_OBJECT (x
->toolbar_widget
),
3608 G_CALLBACK (xg_tool_bar_expose_callback
),
3611 gtk_widget_show_all (x
->handlebox_widget
);
3613 gtk_widget_size_request (x
->toolbar_widget
, &req
);
3614 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3616 /* The height has changed, resize outer widget and set columns
3617 rows to what we had before adding the tool bar. */
3618 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3620 SET_FRAME_GARBAGED (f
);
3623 /* Update the tool bar for frame F. Add new buttons and remove old. */
3626 update_frame_tool_bar (f
)
3630 GtkRequisition old_req
, new_req
;
3631 struct x_output
*x
= f
->output_data
.x
;
3632 int hmargin
, vmargin
;
3635 if (! FRAME_GTK_WIDGET (f
))
3640 if (INTEGERP (Vtool_bar_button_margin
)
3641 && XINT (Vtool_bar_button_margin
) > 0)
3643 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3644 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3646 else if (CONSP (Vtool_bar_button_margin
))
3648 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3649 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3650 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3652 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3653 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3654 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3657 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3658 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3659 i.e. zero. This means that margins less than
3660 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3661 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3662 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3664 if (! x
->toolbar_widget
)
3665 xg_create_tool_bar (f
);
3667 gtk_widget_size_request (x
->toolbar_widget
, &old_req
);
3669 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3671 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3673 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3674 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3680 GtkWidget
*weventbox
;
3682 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (x
->toolbar_widget
), i
);
3686 weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3687 wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3690 /* If image is a vector, choose the image according to the
3692 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3693 if (VECTORP (image
))
3697 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3698 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3701 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3702 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3704 xassert (ASIZE (image
) >= idx
);
3705 image
= AREF (image
, idx
);
3710 /* Ignore invalid image specifications. */
3711 if (!valid_image_p (image
))
3713 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
3717 img_id
= lookup_image (f
, image
);
3718 img
= IMAGE_FROM_ID (f
, img_id
);
3719 prepare_image_for_display (f
, img
);
3721 if (img
->load_failed_p
|| img
->pixmap
== None
)
3724 gtk_widget_hide_all (GTK_WIDGET (ti
));
3727 /* Insert an empty (non-image) button */
3728 weventbox
= gtk_event_box_new ();
3729 wbutton
= gtk_button_new ();
3730 gtk_button_set_relief (GTK_BUTTON (wbutton
), GTK_RELIEF_NONE
);
3731 gtk_container_add (GTK_CONTAINER (weventbox
), wbutton
);
3732 ti
= gtk_tool_item_new ();
3733 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
3734 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
), ti
, i
);
3741 GtkWidget
*w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
3742 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
3743 wbutton
= gtk_button_new ();
3744 gtk_button_set_relief (GTK_BUTTON (wbutton
), GTK_RELIEF_NONE
);
3745 gtk_container_add (GTK_CONTAINER (wbutton
), w
);
3746 weventbox
= gtk_event_box_new ();
3747 gtk_container_add (GTK_CONTAINER (weventbox
), wbutton
);
3748 ti
= gtk_tool_item_new ();
3749 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
3750 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
), ti
, i
);
3753 /* The EMACS_INT cast avoids a warning. */
3754 g_signal_connect (wbutton
, "clicked",
3755 GTK_SIGNAL_FUNC (xg_tool_bar_callback
),
3756 (gpointer
) (EMACS_INT
) i
);
3758 gtk_widget_show_all (GTK_WIDGET (ti
));
3760 /* Save the image so we can see if an update is needed when
3761 this function is called again. */
3762 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
3763 (gpointer
)img
->pixmap
);
3765 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
3767 /* Catch expose events to overcome an annoying redraw bug, see
3768 comment for xg_tool_bar_item_expose_callback. */
3769 g_signal_connect (G_OBJECT (ti
),
3771 G_CALLBACK (xg_tool_bar_item_expose_callback
),
3774 gtk_widget_set_sensitive (wbutton
, enabled_p
);
3775 gtk_tool_item_set_homogeneous (ti
, FALSE
);
3777 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
3778 no distinction based on modifiers in the activate callback,
3779 so we have to do it ourselves. */
3780 g_signal_connect (wbutton
, "button-release-event",
3781 GTK_SIGNAL_FUNC (xg_tool_bar_button_cb
),
3784 g_object_set_data (G_OBJECT (wbutton
), XG_FRAME_DATA
, (gpointer
)f
);
3786 /* Use enter/leave notify to show help. We use the events
3787 rather than the GtkButton specific signals "enter" and
3788 "leave", so we can have only one callback. The event
3789 will tell us what kind of event it is. */
3790 /* The EMACS_INT cast avoids a warning. */
3791 g_signal_connect (G_OBJECT (weventbox
),
3792 "enter-notify-event",
3793 G_CALLBACK (xg_tool_bar_help_callback
),
3794 (gpointer
) (EMACS_INT
) i
);
3795 g_signal_connect (G_OBJECT (weventbox
),
3796 "leave-notify-event",
3797 G_CALLBACK (xg_tool_bar_help_callback
),
3798 (gpointer
) (EMACS_INT
) i
);
3802 GtkWidget
*wimage
= gtk_bin_get_child (GTK_BIN (wbutton
));
3803 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
3804 XG_TOOL_BAR_IMAGE_DATA
);
3805 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
3807 if (old_img
!= img
->pixmap
)
3808 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
3810 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
3811 (gpointer
)img
->pixmap
);
3813 gtk_widget_set_sensitive (wbutton
, enabled_p
);
3814 gtk_widget_show_all (GTK_WIDGET (ti
));
3820 /* Remove buttons not longer needed. We just hide them so they
3821 can be reused later on. */
3824 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (x
->toolbar_widget
), i
++);
3825 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
3826 } while (ti
!= NULL
);
3828 gtk_widget_size_request (x
->toolbar_widget
, &new_req
);
3829 if (old_req
.height
!= new_req
.height
3830 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
3832 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
3833 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3839 /* Deallocate all resources for the tool bar on frame F.
3840 Remove the tool bar. */
3843 free_frame_tool_bar (f
)
3846 struct x_output
*x
= f
->output_data
.x
;
3848 if (x
->toolbar_widget
)
3851 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
3852 x
->handlebox_widget
);
3853 x
->toolbar_widget
= 0;
3854 x
->handlebox_widget
= 0;
3855 FRAME_TOOLBAR_HEIGHT (f
) = 0;
3857 /* The height has changed, resize outer widget and set columns
3858 rows to what we had before removing the tool bar. */
3859 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3861 SET_FRAME_GARBAGED (f
);
3868 /***********************************************************************
3870 ***********************************************************************/
3874 GtkBindingSet
*binding_set
;
3876 xg_ignore_gtk_scrollbar
= 0;
3877 xg_detached_menus
= 0;
3878 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
3879 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
3881 id_to_widget
.max_size
= id_to_widget
.used
= 0;
3882 id_to_widget
.widgets
= 0;
3884 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
3885 bindings. It doesn't seem to be any way to remove properties,
3886 so we set it to VoidSymbol which in X means "no key". */
3887 gtk_settings_set_string_property (gtk_settings_get_default (),
3888 "gtk-menu-bar-accel",
3892 /* Make GTK text input widgets use Emacs style keybindings. This is
3894 gtk_settings_set_string_property (gtk_settings_get_default (),
3895 "gtk-key-theme-name",
3899 /* Make dialogs close on C-g. Since file dialog inherits from
3900 dialog, this works for them also. */
3901 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_DIALOG
));
3902 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3905 /* Make menus close on C-g. */
3906 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_MENU_SHELL
));
3907 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3911 #endif /* USE_GTK */
3913 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
3914 (do not change this comment) */