1 /* Functions for creating and updating GTK widgets.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007 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.
1721 W is the parent of the menu item.
1722 EVENT is either an enter event or leave event.
1723 CLIENT_DATA is not used.
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
;
1734 GtkWidget
*subwidget
;
1735 xg_menu_item_cb_data
*data
;
1737 ev
.crossing
= *event
;
1738 subwidget
= gtk_get_event_widget (&ev
);
1739 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
1743 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1745 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
1746 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1747 (*func
) (subwidget
, call_data
);
1754 /* Callback called when a menu is destroyed. Used to free data.
1755 W is the widget that is being destroyed (not used).
1756 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1759 menu_destroy_callback (w
, client_data
)
1761 gpointer client_data
;
1763 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1766 /* Callback called when a menu does a grab or ungrab. That means the
1767 menu has been activated or deactivated.
1768 Used to start a timer so the small timeout the menus in GTK uses before
1769 popping down a menu is seen by Emacs (see xg_process_timeouts above).
1770 W is the widget that does the grab (not used).
1771 UNGRAB_P is TRUE if this is an ungrab, FALSE if it is a grab.
1772 CLIENT_DATA is NULL (not used). */
1775 menu_grab_callback (GtkWidget
*widget
,
1777 gpointer client_data
)
1779 /* Keep track of total number of grabs. */
1782 if (ungrab_p
) cnt
--;
1785 if (cnt
> 0 && ! xg_timer
) xg_start_timer ();
1786 else if (cnt
== 0 && xg_timer
) xg_stop_timer ();
1789 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1790 must be non-NULL) and can be inserted into a menu item.
1792 Returns the GtkHBox. */
1795 make_widget_for_menu_item (utf8_label
, utf8_key
)
1803 wbox
= gtk_hbox_new (FALSE
, 0);
1804 wlbl
= gtk_label_new (utf8_label
);
1805 wkey
= gtk_label_new (utf8_key
);
1807 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1808 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1810 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1811 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1813 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1814 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1815 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1820 /* Make and return a menu item widget with the key to the right.
1821 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1822 UTF8_KEY is the text representing the key binding.
1823 ITEM is the widget_value describing the menu item.
1825 GROUP is an in/out parameter. If the menu item to be created is not
1826 part of any radio menu group, *GROUP contains NULL on entry and exit.
1827 If the menu item to be created is part of a radio menu group, on entry
1828 *GROUP contains the group to use, or NULL if this is the first item
1829 in the group. On exit, *GROUP contains the radio item group.
1831 Unfortunately, keys don't line up as nicely as in Motif,
1832 but the MacOS X version doesn't either, so I guess that is OK. */
1835 make_menu_item (utf8_label
, utf8_key
, item
, group
)
1842 GtkWidget
*wtoadd
= 0;
1844 /* It has been observed that some menu items have a NULL name field.
1845 This will lead to this function being called with a NULL utf8_label.
1846 GTK crashes on that so we set a blank label. Why there is a NULL
1847 name remains to be investigated. */
1848 if (! utf8_label
) utf8_label
= " ";
1851 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1853 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1856 if (utf8_key
) w
= gtk_check_menu_item_new ();
1857 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1858 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1860 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1862 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1863 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1864 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1866 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1871 if (utf8_key
) w
= gtk_menu_item_new ();
1872 else w
= gtk_menu_item_new_with_label (utf8_label
);
1875 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1876 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1881 /* Return non-zero if LABEL specifies a separator (GTK only has one
1885 xg_separator_p (char *label
)
1887 if (! label
) return 0;
1888 else if (strlen (label
) > 3
1889 && strncmp (label
, "--", 2) == 0
1892 static char* separator_names
[] = {
1897 "single-dashed-line",
1898 "double-dashed-line",
1900 "shadow-etched-out",
1901 "shadow-etched-in-dash",
1902 "shadow-etched-out-dash",
1903 "shadow-double-etched-in",
1904 "shadow-double-etched-out",
1905 "shadow-double-etched-in-dash",
1906 "shadow-double-etched-out-dash",
1913 for (i
= 0; separator_names
[i
]; ++i
)
1914 if (strcmp (label
, separator_names
[i
]) == 0)
1919 /* Old-style separator, maybe. It's a separator if it contains
1921 while (*label
== '-')
1923 if (*label
== 0) return 1;
1929 static int xg_detached_menus
;
1931 /* Returns non-zero if there are detached menus. */
1934 xg_have_tear_offs ()
1936 return xg_detached_menus
> 0;
1939 /* Callback invoked when a detached menu window is removed. Here we
1940 decrease the xg_detached_menus count.
1941 WIDGET is the top level window that is removed (the parent of the menu).
1942 CLIENT_DATA is not used. */
1945 tearoff_remove (widget
, client_data
)
1947 gpointer client_data
;
1949 if (xg_detached_menus
> 0) --xg_detached_menus
;
1952 /* Callback invoked when a menu is detached. It increases the
1953 xg_detached_menus count.
1954 WIDGET is the GtkTearoffMenuItem.
1955 CLIENT_DATA is not used. */
1958 tearoff_activate (widget
, client_data
)
1960 gpointer client_data
;
1962 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
1963 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
1965 ++xg_detached_menus
;
1966 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
1968 G_CALLBACK (tearoff_remove
), 0);
1973 /* Create a menu item widget, and connect the callbacks.
1974 ITEM decribes the menu item.
1975 F is the frame the created menu belongs to.
1976 SELECT_CB is the callback to use when a menu item is selected.
1977 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1978 CL_DATA points to the callback data to be used for this menu.
1979 GROUP is an in/out parameter. If the menu item to be created is not
1980 part of any radio menu group, *GROUP contains NULL on entry and exit.
1981 If the menu item to be created is part of a radio menu group, on entry
1982 *GROUP contains the group to use, or NULL if this is the first item
1983 in the group. On exit, *GROUP contains the radio item group.
1985 Returns the created GtkWidget. */
1988 xg_create_one_menuitem (item
, f
, select_cb
, highlight_cb
, cl_data
, group
)
1991 GCallback select_cb
;
1992 GCallback highlight_cb
;
1993 xg_menu_cb_data
*cl_data
;
1999 xg_menu_item_cb_data
*cb_data
;
2001 utf8_label
= get_utf8_string (item
->name
);
2002 utf8_key
= get_utf8_string (item
->key
);
2004 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2006 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2007 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
2009 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2011 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2013 cb_data
->select_id
= 0;
2014 cb_data
->help
= item
->help
;
2015 cb_data
->cl_data
= cl_data
;
2016 cb_data
->call_data
= item
->call_data
;
2018 g_signal_connect (G_OBJECT (w
),
2020 G_CALLBACK (menuitem_destroy_callback
),
2023 /* Put cb_data in widget, so we can get at it when modifying menubar */
2024 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2026 /* final item, not a submenu */
2027 if (item
->call_data
&& ! item
->contents
)
2031 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2037 /* Callback called when keyboard traversal (started by menu-bar-open) ends.
2038 WMENU is the menu for which traversal has been done. DATA points to the
2039 frame for WMENU. We must release grabs, some bad interaction between GTK
2040 and Emacs makes the menus keep the grabs. */
2043 menu_nav_ended (wmenu
, data
)
2044 GtkMenuShell
*wmenu
;
2047 FRAME_PTR f
= (FRAME_PTR
) data
;
2049 if (FRAME_X_OUTPUT (f
)->menubar_widget
)
2051 GtkMenuShell
*w
= GTK_MENU_SHELL (FRAME_X_OUTPUT (f
)->menubar_widget
);
2052 Display
*dpy
= FRAME_X_DISPLAY (f
);
2055 gtk_menu_shell_deactivate (w
);
2056 gtk_menu_shell_deselect (w
);
2058 XUngrabKeyboard (dpy
, CurrentTime
);
2059 XUngrabPointer (dpy
, CurrentTime
);
2065 static GtkWidget
*create_menus
P_ ((widget_value
*, FRAME_PTR
, GCallback
,
2066 GCallback
, GCallback
, int, int, int,
2067 GtkWidget
*, xg_menu_cb_data
*, char *));
2069 /* Create a full menu tree specified by DATA.
2070 F is the frame the created menu belongs to.
2071 SELECT_CB is the callback to use when a menu item is selected.
2072 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2073 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2074 POP_UP_P is non-zero if we shall create a popup menu.
2075 MENU_BAR_P is non-zero if we shall create a menu bar.
2076 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2077 if MENU_BAR_P is non-zero.
2078 TOPMENU is the topmost GtkWidget that others shall be placed under.
2079 It may be NULL, in that case we create the appropriate widget
2080 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2081 CL_DATA is the callback data we shall use for this menu, or NULL
2082 if we haven't set the first callback yet.
2083 NAME is the name to give to the top level menu if this function
2084 creates it. May be NULL to not set any name.
2086 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2089 This function calls itself to create submenus. */
2092 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2093 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
2096 GCallback select_cb
;
2097 GCallback deactivate_cb
;
2098 GCallback highlight_cb
;
2103 xg_menu_cb_data
*cl_data
;
2107 GtkWidget
*wmenu
= topmenu
;
2108 GSList
*group
= NULL
;
2114 wmenu
= gtk_menu_new ();
2115 xg_set_screen (wmenu
, f
);
2116 /* Connect this to the menu instead of items so we get enter/leave for
2117 disabled items also. TODO: Still does not get enter/leave for
2118 disabled items in detached menus. */
2119 g_signal_connect (G_OBJECT (wmenu
),
2120 "enter-notify-event",
2121 G_CALLBACK (menuitem_highlight_callback
),
2123 g_signal_connect (G_OBJECT (wmenu
),
2124 "leave-notify-event",
2125 G_CALLBACK (menuitem_highlight_callback
),
2128 else wmenu
= gtk_menu_bar_new ();
2130 /* Fix up grabs after keyboard traversal ends. */
2131 g_signal_connect (G_OBJECT (wmenu
),
2133 G_CALLBACK (menu_nav_ended
),
2136 /* Put cl_data on the top menu for easier access. */
2137 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2138 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2139 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2140 G_CALLBACK (menu_destroy_callback
), cl_data
);
2143 gtk_widget_set_name (wmenu
, name
);
2146 g_signal_connect (G_OBJECT (wmenu
),
2147 "selection-done", deactivate_cb
, 0);
2149 g_signal_connect (G_OBJECT (wmenu
),
2150 "grab-notify", G_CALLBACK (menu_grab_callback
), 0);
2153 if (! menu_bar_p
&& add_tearoff_p
)
2155 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2156 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2158 g_signal_connect (G_OBJECT (tearoff
), "activate",
2159 G_CALLBACK (tearoff_activate
), 0);
2162 for (item
= data
; item
; item
= item
->next
)
2166 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2167 && !xg_separator_p (item
->name
))
2170 /* A title for a popup. We do the same as GTK does when
2171 creating titles, but it does not look good. */
2173 utf8_label
= get_utf8_string (item
->name
);
2175 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2176 w
= gtk_menu_item_new_with_label (utf8_label
);
2177 gtk_widget_set_sensitive (w
, FALSE
);
2178 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2180 else if (xg_separator_p (item
->name
))
2183 /* GTK only have one separator type. */
2184 w
= gtk_separator_menu_item_new ();
2188 w
= xg_create_one_menuitem (item
,
2190 item
->contents
? 0 : select_cb
,
2197 GtkWidget
*submenu
= create_menus (item
->contents
,
2208 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2212 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2213 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2219 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2220 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2221 with some text and buttons.
2222 F is the frame the created item belongs to.
2223 NAME is the name to use for the top widget.
2224 VAL is a widget_value structure describing items to be created.
2225 SELECT_CB is the callback to use when a menu item is selected or
2226 a dialog button is pressed.
2227 DEACTIVATE_CB is the callback to use when an item is deactivated.
2228 For a menu, when a sub menu is not shown anymore, for a dialog it is
2229 called when the dialog is popped down.
2230 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2232 Returns the widget created. */
2235 xg_create_widget (type
, name
, f
, val
,
2236 select_cb
, deactivate_cb
, highlight_cb
)
2241 GCallback select_cb
;
2242 GCallback deactivate_cb
;
2243 GCallback highlight_cb
;
2246 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2247 int pop_up_p
= strcmp (type
, "popup") == 0;
2249 if (strcmp (type
, "dialog") == 0)
2251 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2252 xg_set_screen (w
, f
);
2253 gtk_window_set_transient_for (GTK_WINDOW (w
),
2254 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2255 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2256 gtk_widget_set_name (w
, "emacs-dialog");
2257 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2259 else if (menu_bar_p
|| pop_up_p
)
2261 w
= create_menus (val
->contents
,
2273 /* Set the cursor to an arrow for popup menus when they are mapped.
2274 This is done by default for menu bar menus. */
2277 /* Must realize so the GdkWindow inside the widget is created. */
2278 gtk_widget_realize (w
);
2279 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2284 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2291 /* Return the label for menu item WITEM. */
2294 xg_get_menu_item_label (witem
)
2297 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2298 return gtk_label_get_label (wlabel
);
2301 /* Return non-zero if the menu item WITEM has the text LABEL. */
2304 xg_item_label_same_p (witem
, label
)
2309 char *utf8_label
= get_utf8_string (label
);
2310 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2312 if (! old_label
&& ! utf8_label
)
2314 else if (old_label
&& utf8_label
)
2315 is_same
= strcmp (utf8_label
, old_label
) == 0;
2317 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2322 /* Destroy widgets in LIST. */
2325 xg_destroy_widgets (list
)
2330 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2332 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2334 /* Destroying the widget will remove it from the container it is in. */
2335 gtk_widget_destroy (w
);
2339 /* Update the top level names in MENUBAR (i.e. not submenus).
2340 F is the frame the menu bar belongs to.
2341 *LIST is a list with the current menu bar names (menu item widgets).
2342 ITER is the item within *LIST that shall be updated.
2343 POS is the numerical position, starting at 0, of ITER in *LIST.
2344 VAL describes what the menu bar shall look like after the update.
2345 SELECT_CB is the callback to use when a menu item is selected.
2346 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2347 CL_DATA points to the callback data to be used for this menu bar.
2349 This function calls itself to walk through the menu bar names. */
2352 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2353 select_cb
, highlight_cb
, cl_data
)
2360 GCallback select_cb
;
2361 GCallback highlight_cb
;
2362 xg_menu_cb_data
*cl_data
;
2364 if (! iter
&& ! val
)
2366 else if (iter
&& ! val
)
2368 /* Item(s) have been removed. Remove all remaining items. */
2369 xg_destroy_widgets (iter
);
2375 else if (! iter
&& val
)
2377 /* Item(s) added. Add all new items in one call. */
2378 create_menus (val
, f
, select_cb
, 0, highlight_cb
,
2379 0, 1, 0, menubar
, cl_data
, 0);
2385 /* Below this neither iter or val is NULL */
2386 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2388 /* This item is still the same, check next item. */
2390 iter
= g_list_next (iter
);
2393 else /* This item is changed. */
2395 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2396 GtkMenuItem
*witem2
= 0;
2397 int val_in_menubar
= 0;
2398 int iter_in_new_menubar
= 0;
2402 /* See if the changed entry (val) is present later in the menu bar */
2404 iter2
&& ! val_in_menubar
;
2405 iter2
= g_list_next (iter2
))
2407 witem2
= GTK_MENU_ITEM (iter2
->data
);
2408 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2411 /* See if the current entry (iter) is present later in the
2412 specification for the new menu bar. */
2413 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2414 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2416 if (val_in_menubar
&& ! iter_in_new_menubar
)
2420 /* This corresponds to:
2425 gtk_widget_ref (GTK_WIDGET (witem
));
2426 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2427 gtk_widget_destroy (GTK_WIDGET (witem
));
2429 /* Must get new list since the old changed. */
2430 g_list_free (*list
);
2431 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2432 while (nr
-- > 0) iter
= g_list_next (iter
);
2434 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2436 /* This corresponds to:
2439 Rename B to X. This might seem to be a strange thing to do,
2440 since if there is a menu under B it will be totally wrong for X.
2441 But consider editing a C file. Then there is a C-mode menu
2442 (corresponds to B above).
2443 If then doing C-x C-f the minibuf menu (X above) replaces the
2444 C-mode menu. When returning from the minibuffer, we get
2445 back the C-mode menu. Thus we do:
2446 Rename B to X (C-mode to minibuf menu)
2447 Rename X to B (minibuf to C-mode menu).
2448 If the X menu hasn't been invoked, the menu under B
2449 is up to date when leaving the minibuffer. */
2450 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2451 char *utf8_label
= get_utf8_string (val
->name
);
2452 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2454 gtk_label_set_text (wlabel
, utf8_label
);
2456 /* If this item has a submenu that has been detached, change
2457 the title in the WM decorations also. */
2458 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2459 /* Set the title of the detached window. */
2460 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2462 iter
= g_list_next (iter
);
2466 else if (! val_in_menubar
&& iter_in_new_menubar
)
2468 /* This corresponds to:
2475 GtkWidget
*w
= xg_create_one_menuitem (val
,
2482 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2483 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2485 g_list_free (*list
);
2486 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2487 while (nr
-- > 0) iter
= g_list_next (iter
);
2488 iter
= g_list_next (iter
);
2492 else /* if (val_in_menubar && iter_in_new_menubar) */
2495 /* This corresponds to:
2500 gtk_widget_ref (GTK_WIDGET (witem2
));
2501 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2502 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2503 GTK_WIDGET (witem2
), pos
);
2504 gtk_widget_unref (GTK_WIDGET (witem2
));
2506 g_list_free (*list
);
2507 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2508 while (nr
-- > 0) iter
= g_list_next (iter
);
2514 /* Update the rest of the menu bar. */
2515 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2516 select_cb
, highlight_cb
, cl_data
);
2519 /* Update the menu item W so it corresponds to VAL.
2520 SELECT_CB is the callback to use when a menu item is selected.
2521 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2522 CL_DATA is the data to set in the widget for menu invokation. */
2525 xg_update_menu_item (val
, w
, select_cb
, highlight_cb
, cl_data
)
2528 GCallback select_cb
;
2529 GCallback highlight_cb
;
2530 xg_menu_cb_data
*cl_data
;
2537 const char *old_label
= 0;
2538 const char *old_key
= 0;
2539 xg_menu_item_cb_data
*cb_data
;
2541 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2542 utf8_label
= get_utf8_string (val
->name
);
2543 utf8_key
= get_utf8_string (val
->key
);
2545 /* See if W is a menu item with a key. See make_menu_item above. */
2546 if (GTK_IS_HBOX (wchild
))
2548 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2550 wlbl
= GTK_LABEL (list
->data
);
2551 wkey
= GTK_LABEL (list
->next
->data
);
2556 /* Remove the key and keep just the label. */
2557 gtk_widget_ref (GTK_WIDGET (wlbl
));
2558 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2559 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2564 else /* Just a label. */
2566 wlbl
= GTK_LABEL (wchild
);
2568 /* Check if there is now a key. */
2571 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2572 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2574 wlbl
= GTK_LABEL (list
->data
);
2575 wkey
= GTK_LABEL (list
->next
->data
);
2578 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2579 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2584 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2585 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2587 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2588 gtk_label_set_text (wkey
, utf8_key
);
2590 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2591 gtk_label_set_text (wlbl
, utf8_label
);
2593 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2594 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2596 if (! val
->enabled
&& GTK_WIDGET_SENSITIVE (w
))
2597 gtk_widget_set_sensitive (w
, FALSE
);
2598 else if (val
->enabled
&& ! GTK_WIDGET_SENSITIVE (w
))
2599 gtk_widget_set_sensitive (w
, TRUE
);
2601 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2605 cb_data
->call_data
= val
->call_data
;
2606 cb_data
->help
= val
->help
;
2607 cb_data
->cl_data
= cl_data
;
2609 /* We assume the callback functions don't change. */
2610 if (val
->call_data
&& ! val
->contents
)
2612 /* This item shall have a select callback. */
2613 if (! cb_data
->select_id
)
2615 = g_signal_connect (G_OBJECT (w
), "activate",
2616 select_cb
, cb_data
);
2618 else if (cb_data
->select_id
)
2620 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2621 cb_data
->select_id
= 0;
2626 /* Update the toggle menu item W so it corresponds to VAL. */
2629 xg_update_toggle_item (val
, w
)
2633 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2636 /* Update the radio menu item W so it corresponds to VAL. */
2639 xg_update_radio_item (val
, w
)
2643 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2646 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2647 SUBMENU may be NULL, in that case a new menu is created.
2648 F is the frame the menu bar belongs to.
2649 VAL describes the contents of the menu bar.
2650 SELECT_CB is the callback to use when a menu item is selected.
2651 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2652 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2653 CL_DATA is the call back data to use for any newly created items.
2655 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2659 xg_update_submenu (submenu
, f
, val
,
2660 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2664 GCallback select_cb
;
2665 GCallback deactivate_cb
;
2666 GCallback highlight_cb
;
2667 xg_menu_cb_data
*cl_data
;
2669 GtkWidget
*newsub
= submenu
;
2673 int has_tearoff_p
= 0;
2674 GList
*first_radio
= 0;
2677 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2679 for (cur
= val
, iter
= list
;
2681 iter
= g_list_next (iter
), cur
= cur
->next
)
2683 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2685 /* Skip tearoff items, they have no counterpart in val. */
2686 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2689 iter
= g_list_next (iter
);
2690 if (iter
) w
= GTK_WIDGET (iter
->data
);
2694 /* Remember first radio button in a group. If we get a mismatch in
2695 a radio group we must rebuild the whole group so that the connections
2696 in GTK becomes correct. */
2697 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2699 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2700 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2703 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2705 if (! xg_separator_p (cur
->name
))
2708 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2710 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2712 xg_update_toggle_item (cur
, w
);
2713 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2715 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2717 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2719 xg_update_radio_item (cur
, w
);
2720 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2722 else if (GTK_IS_MENU_ITEM (w
))
2724 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2727 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2728 xg_separator_p (cur
->name
))
2731 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2733 sub
= gtk_menu_item_get_submenu (witem
);
2734 if (sub
&& ! cur
->contents
)
2736 /* Not a submenu anymore. */
2737 gtk_widget_ref (sub
);
2738 gtk_menu_item_remove_submenu (witem
);
2739 gtk_widget_destroy (sub
);
2741 else if (cur
->contents
)
2745 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2746 select_cb
, deactivate_cb
,
2747 highlight_cb
, cl_data
);
2749 /* If this item just became a submenu, we must set it. */
2751 gtk_menu_item_set_submenu (witem
, nsub
);
2756 /* Structural difference. Remove everything from here and down
2762 /* Remove widgets from first structual change. */
2765 /* If we are adding new menu items below, we must remove from
2766 first radio button so that radio groups become correct. */
2767 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2768 else xg_destroy_widgets (iter
);
2773 /* More items added. Create them. */
2774 newsub
= create_menus (cur
,
2787 if (list
) g_list_free (list
);
2792 /* Update the MENUBAR.
2793 F is the frame the menu bar belongs to.
2794 VAL describes the contents of the menu bar.
2795 If DEEP_P is non-zero, rebuild all but the top level menu names in
2796 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2797 SELECT_CB is the callback to use when a menu item is selected.
2798 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2799 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2802 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2803 select_cb
, deactivate_cb
, highlight_cb
)
2808 GCallback select_cb
;
2809 GCallback deactivate_cb
;
2810 GCallback highlight_cb
;
2812 xg_menu_cb_data
*cl_data
;
2813 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2817 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2820 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2821 select_cb
, highlight_cb
, cl_data
);
2827 /* Update all sub menus.
2828 We must keep the submenus (GTK menu item widgets) since the
2829 X Window in the XEvent that activates the menu are those widgets. */
2831 /* Update cl_data, menu_item things in F may have changed. */
2832 update_cl_data (cl_data
, f
, highlight_cb
);
2834 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2841 /* Find sub menu that corresponds to val and update it. */
2842 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2844 witem
= GTK_MENU_ITEM (iter
->data
);
2845 if (xg_item_label_same_p (witem
, cur
->name
))
2847 sub
= gtk_menu_item_get_submenu (witem
);
2852 newsub
= xg_update_submenu (sub
,
2859 /* sub may still be NULL. If we just updated non deep and added
2860 a new menu bar item, it has no sub menu yet. So we set the
2861 newly created sub menu under witem. */
2864 xg_set_screen (newsub
, f
);
2865 gtk_menu_item_set_submenu (witem
, newsub
);
2871 gtk_widget_show_all (menubar
);
2874 /* Recompute all the widgets of frame F, when the menu bar has been
2875 changed. Value is non-zero if widgets were updated. */
2878 xg_update_frame_menubar (f
)
2881 struct x_output
*x
= f
->output_data
.x
;
2884 if (!x
->menubar_widget
|| GTK_WIDGET_MAPPED (x
->menubar_widget
))
2889 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2891 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2893 gtk_widget_show_all (x
->menubar_widget
);
2894 gtk_widget_size_request (x
->menubar_widget
, &req
);
2896 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2898 /* The height has changed, resize outer widget and set columns
2899 rows to what we had before adding the menu bar. */
2900 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2902 SET_FRAME_GARBAGED (f
);
2908 /* Get rid of the menu bar of frame F, and free its storage.
2909 This is used when deleting a frame, and when turning off the menu bar. */
2912 free_frame_menubar (f
)
2915 struct x_output
*x
= f
->output_data
.x
;
2917 if (x
->menubar_widget
)
2921 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2922 /* The menubar and its children shall be deleted when removed from
2924 x
->menubar_widget
= 0;
2925 FRAME_MENUBAR_HEIGHT (f
) = 0;
2927 /* The height has changed, resize outer widget and set columns
2928 rows to what we had before removing the menu bar. */
2929 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2931 SET_FRAME_GARBAGED (f
);
2938 /***********************************************************************
2939 Scroll bar functions
2940 ***********************************************************************/
2943 /* Setting scroll bar values invokes the callback. Use this variable
2944 to indicate that callback should do nothing. */
2946 int xg_ignore_gtk_scrollbar
;
2948 /* SET_SCROLL_BAR_X_WINDOW assumes the second argument fits in
2949 32 bits. But we want to store pointers, and they may be larger
2950 than 32 bits. Keep a mapping from integer index to widget pointers
2951 to get around the 32 bit limitation. */
2955 GtkWidget
**widgets
;
2960 /* Grow this much every time we need to allocate more */
2962 #define ID_TO_WIDGET_INCR 32
2964 /* Store the widget pointer W in id_to_widget and return the integer index. */
2967 xg_store_widget_in_map (w
)
2972 if (id_to_widget
.max_size
== id_to_widget
.used
)
2974 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
2976 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
2977 sizeof (GtkWidget
*)*new_size
);
2979 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
2980 id_to_widget
.widgets
[i
] = 0;
2981 id_to_widget
.max_size
= new_size
;
2984 /* Just loop over the array and find a free place. After all,
2985 how many scroll bars are we creating? Should be a small number.
2986 The check above guarantees we will find a free place. */
2987 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
2989 if (! id_to_widget
.widgets
[i
])
2991 id_to_widget
.widgets
[i
] = w
;
2992 ++id_to_widget
.used
;
2998 /* Should never end up here */
3002 /* Remove pointer at IDX from id_to_widget.
3003 Called when scroll bar is destroyed. */
3006 xg_remove_widget_from_map (idx
)
3009 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3011 id_to_widget
.widgets
[idx
] = 0;
3012 --id_to_widget
.used
;
3016 /* Get the widget pointer at IDX from id_to_widget. */
3019 xg_get_widget_from_map (idx
)
3022 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3023 return id_to_widget
.widgets
[idx
];
3028 /* Return the scrollbar id for X Window WID on display DPY.
3029 Return -1 if WID not in id_to_widget. */
3032 xg_get_scroll_id_for_window (dpy
, wid
)
3039 w
= xg_win_to_widget (dpy
, wid
);
3043 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3044 if (id_to_widget
.widgets
[idx
] == w
)
3051 /* Callback invoked when scroll bar WIDGET is destroyed.
3052 DATA is the index into id_to_widget for WIDGET.
3053 We free pointer to last scroll bar values here and remove the index. */
3056 xg_gtk_scroll_destroy (widget
, data
)
3061 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
3063 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
3065 xg_remove_widget_from_map (id
);
3068 /* Callback for button press/release events. Used to start timer so that
3069 the scroll bar repetition timer in GTK gets handeled.
3070 Also, sets bar->dragging to Qnil when dragging (button release) is done.
3071 WIDGET is the scroll bar widget the event is for (not used).
3072 EVENT contains the event.
3073 USER_DATA points to the struct scrollbar structure.
3075 Returns FALSE to tell GTK that it shall continue propagate the event
3079 scroll_bar_button_cb (widget
, event
, user_data
)
3081 GdkEventButton
*event
;
3084 if (event
->type
== GDK_BUTTON_PRESS
&& ! xg_timer
)
3086 else if (event
->type
== GDK_BUTTON_RELEASE
)
3088 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
3089 if (xg_timer
) xg_stop_timer ();
3090 bar
->dragging
= Qnil
;
3096 /* Create a scroll bar widget for frame F. Store the scroll bar
3098 SCROLL_CALLBACK is the callback to invoke when the value of the
3100 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3101 to set resources for the widget. */
3104 xg_create_scroll_bar (f
, bar
, scroll_callback
, scroll_bar_name
)
3106 struct scroll_bar
*bar
;
3107 GCallback scroll_callback
;
3108 char *scroll_bar_name
;
3115 /* Page, step increment values are not so important here, they
3116 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3117 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3120 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3121 webox
= gtk_event_box_new ();
3122 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3123 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3125 scroll_id
= xg_store_widget_in_map (wscroll
);
3127 g_signal_connect (G_OBJECT (wscroll
),
3131 /* The EMACS_INT cast avoids a warning. */
3132 g_signal_connect (G_OBJECT (wscroll
),
3134 G_CALLBACK (xg_gtk_scroll_destroy
),
3135 (gpointer
) (EMACS_INT
) scroll_id
);
3137 /* Connect to button press and button release to detect if any scroll bar
3139 g_signal_connect (G_OBJECT (wscroll
),
3140 "button-press-event",
3141 G_CALLBACK (scroll_bar_button_cb
),
3143 g_signal_connect (G_OBJECT (wscroll
),
3144 "button-release-event",
3145 G_CALLBACK (scroll_bar_button_cb
),
3148 /* The scroll bar widget does not draw on a window of its own. Instead
3149 it draws on the parent window, in this case the edit widget. So
3150 whenever the edit widget is cleared, the scroll bar needs to redraw
3151 also, which causes flicker. Put an event box between the edit widget
3152 and the scroll bar, so the scroll bar instead draws itself on the
3153 event box window. */
3154 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3155 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3158 /* Set the cursor to an arrow. */
3159 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3161 SET_SCROLL_BAR_X_WINDOW (bar
, scroll_id
);
3164 /* Make the scroll bar represented by SCROLLBAR_ID visible. */
3167 xg_show_scroll_bar (scrollbar_id
)
3170 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3172 gtk_widget_show_all (gtk_widget_get_parent (w
));
3175 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3178 xg_remove_scroll_bar (f
, scrollbar_id
)
3182 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3185 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3186 gtk_widget_destroy (w
);
3187 gtk_widget_destroy (wparent
);
3188 SET_FRAME_GARBAGED (f
);
3192 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3194 TOP/LEFT are the new pixel positions where the bar shall appear.
3195 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3198 xg_update_scrollbar_pos (f
, scrollbar_id
, top
, left
, width
, height
)
3207 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3211 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3212 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3214 /* Move and resize to new values. */
3215 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3216 gtk_widget_set_size_request (wscroll
, width
, height
);
3217 gtk_widget_queue_draw (wparent
);
3218 gdk_window_process_all_updates ();
3219 /* GTK does not redraw until the main loop is entered again, but
3220 if there are no X events pending we will not enter it. So we sync
3221 here to get some events. */
3223 SET_FRAME_GARBAGED (f
);
3224 cancel_mouse_face (f
);
3228 /* Set the thumb size and position of scroll bar BAR. We are currently
3229 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3232 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
3233 struct scroll_bar
*bar
;
3234 int portion
, position
, whole
;
3236 GtkWidget
*wscroll
= xg_get_widget_from_map (SCROLL_BAR_X_WINDOW (bar
));
3238 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3240 if (wscroll
&& NILP (bar
->dragging
))
3249 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3251 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3252 rather than the real portion value. This makes the thumb less likely
3253 to resize and that looks better. */
3254 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3255 /* When the thumb is at the bottom, position == whole.
3256 So we need to increase `whole' to make space for the thumb. */
3263 top
= (gdouble
) position
/ whole
;
3264 shown
= (gdouble
) portion
/ whole
;
3267 size
= shown
* XG_SB_RANGE
;
3268 size
= min (size
, XG_SB_RANGE
);
3269 size
= max (size
, 1);
3271 value
= top
* XG_SB_RANGE
;
3272 value
= min (value
, XG_SB_MAX
- size
);
3273 value
= max (value
, XG_SB_MIN
);
3275 /* Assume all lines are of equal size. */
3276 new_step
= size
/ max (1, FRAME_LINES (f
));
3278 if ((int) adj
->page_size
!= size
3279 || (int) adj
->step_increment
!= new_step
)
3281 adj
->page_size
= size
;
3282 adj
->step_increment
= new_step
;
3283 /* Assume a page increment is about 95% of the page size */
3284 adj
->page_increment
= (int) (0.95*adj
->page_size
);
3288 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3290 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3294 /* gtk_range_set_value invokes the callback. Set
3295 ignore_gtk_scrollbar to make the callback do nothing */
3296 xg_ignore_gtk_scrollbar
= 1;
3298 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3299 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3301 gtk_adjustment_changed (adj
);
3303 xg_ignore_gtk_scrollbar
= 0;
3311 /***********************************************************************
3313 ***********************************************************************/
3314 /* The key for the data we put in the GtkImage widgets. The data is
3315 the image used by Emacs. We use this to see if we need to update
3316 the GtkImage with a new image. */
3317 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3319 /* The key for storing the latest modifiers so the activate callback can
3321 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3323 /* The key for storing the button widget in its proxy menu item. */
3324 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3327 xg_tool_bar_button_cb (widget
, event
, user_data
)
3329 GdkEventButton
*event
;
3332 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3333 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3334 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3339 /* Callback function invoked when a tool bar item is pressed.
3340 W is the button widget in the tool bar that got pressed,
3341 CLIENT_DATA is an integer that is the index of the button in the
3342 tool bar. 0 is the first button. */
3345 xg_tool_bar_callback (w
, client_data
)
3347 gpointer client_data
;
3349 /* The EMACS_INT cast avoids a warning. */
3350 int idx
= (int) (EMACS_INT
) client_data
;
3351 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3352 XG_TOOL_BAR_LAST_MODIFIER
);
3354 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3355 Lisp_Object key
, frame
;
3356 struct input_event event
;
3359 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3362 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3364 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3365 XSETFRAME (frame
, f
);
3366 event
.kind
= TOOL_BAR_EVENT
;
3367 event
.frame_or_window
= frame
;
3369 kbd_buffer_store_event (&event
);
3371 event
.kind
= TOOL_BAR_EVENT
;
3372 event
.frame_or_window
= frame
;
3374 /* Convert between the modifier bits GDK uses and the modifier bits
3375 Emacs uses. This assumes GDK an X masks are the same, which they are when
3377 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3378 kbd_buffer_store_event (&event
);
3381 /* Callback function invoked when a tool bar item is pressed in a detached
3382 tool bar or the overflow drop down menu.
3383 We just call xg_tool_bar_callback.
3384 W is the menu item widget that got pressed,
3385 CLIENT_DATA is an integer that is the index of the button in the
3386 tool bar. 0 is the first button. */
3389 xg_tool_bar_proxy_callback (w
, client_data
)
3391 gpointer client_data
;
3393 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3394 XG_TOOL_BAR_PROXY_BUTTON
));
3395 xg_tool_bar_callback (wbutton
, client_data
);
3398 /* This callback is called when a tool item should create a proxy item,
3399 such as for the overflow menu. Also called when the tool bar is detached.
3400 If we don't create a proxy menu item, the detached tool bar will be
3404 xg_tool_bar_menu_proxy (toolitem
, user_data
)
3405 GtkToolItem
*toolitem
;
3408 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (toolitem
));
3409 GtkButton
*wbutton
= GTK_BUTTON (gtk_bin_get_child (GTK_BIN (weventbox
)));
3410 GtkWidget
*wmenuitem
= gtk_image_menu_item_new ();
3411 GtkWidget
*wmenuimage
;
3413 if (gtk_button_get_use_stock (wbutton
))
3414 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3415 GTK_ICON_SIZE_MENU
);
3418 GtkImage
*wimage
= GTK_IMAGE (gtk_bin_get_child (GTK_BIN (wbutton
)));
3419 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3420 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3421 if (store_type
== GTK_IMAGE_STOCK
)
3424 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3425 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3427 else if (store_type
== GTK_IMAGE_ICON_SET
)
3429 GtkIconSet
*icon_set
;
3430 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3431 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3432 GTK_ICON_SIZE_MENU
);
3434 else if (store_type
== GTK_IMAGE_PIXBUF
)
3439 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3442 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3444 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3445 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3446 GDK_INTERP_BILINEAR
);
3448 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3453 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3455 g_signal_connect (G_OBJECT (wmenuitem
),
3457 GTK_SIGNAL_FUNC (xg_tool_bar_proxy_callback
),
3460 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3461 (gpointer
) wbutton
);
3462 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3467 /* This callback is called when a tool bar is detached. We must set
3468 the height of the tool bar to zero when this happens so frame sizes
3469 are correctly calculated.
3470 WBOX is the handle box widget that enables detach/attach of the tool bar.
3471 W is the tool bar widget.
3472 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3475 xg_tool_bar_detach_callback (wbox
, w
, client_data
)
3478 gpointer client_data
;
3480 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3481 extern int x_gtk_whole_detached_tool_bar
;
3483 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3488 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3490 /* When detaching a tool bar, not everything dissapear. There are
3491 a few pixels left that are used to drop the tool bar back into
3493 FRAME_TOOLBAR_HEIGHT (f
) = 2;
3495 /* The height has changed, resize outer widget and set columns
3496 rows to what we had before detaching the tool bar. */
3497 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3501 /* This callback is called when a tool bar is reattached. We must set
3502 the height of the tool bar when this happens so frame sizes
3503 are correctly calculated.
3504 WBOX is the handle box widget that enables detach/attach of the tool bar.
3505 W is the tool bar widget.
3506 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3509 xg_tool_bar_attach_callback (wbox
, w
, client_data
)
3512 gpointer client_data
;
3514 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3515 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3521 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3523 gtk_widget_size_request (w
, &req
);
3524 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3526 /* The height has changed, resize outer widget and set columns
3527 rows to what we had before attaching the tool bar. */
3528 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3532 /* This callback is called when the mouse enters or leaves a tool bar item.
3533 It is used for displaying and hiding the help text.
3534 W is the tool bar item, a button.
3535 EVENT is either an enter event or leave event.
3536 CLIENT_DATA is an integer that is the index of the button in the
3537 tool bar. 0 is the first button.
3539 Returns FALSE to tell GTK to keep processing this event. */
3542 xg_tool_bar_help_callback (w
, event
, client_data
)
3544 GdkEventCrossing
*event
;
3545 gpointer client_data
;
3547 /* The EMACS_INT cast avoids a warning. */
3548 int idx
= (int) (EMACS_INT
) client_data
;
3549 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3550 Lisp_Object help
, frame
;
3552 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3555 if (event
->type
== GDK_ENTER_NOTIFY
)
3557 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3558 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3561 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3566 XSETFRAME (frame
, f
);
3567 kbd_buffer_store_help_event (frame
, help
);
3573 /* This callback is called when a tool bar item shall be redrawn.
3574 It modifies the expose event so that the GtkImage widget redraws the
3575 whole image. This to overcome a bug that makes GtkImage draw the image
3576 in the wrong place when it tries to redraw just a part of the image.
3577 W is the GtkImage to be redrawn.
3578 EVENT is the expose event for W.
3579 CLIENT_DATA is unused.
3581 Returns FALSE to tell GTK to keep processing this event. */
3584 xg_tool_bar_item_expose_callback (w
, event
, client_data
)
3586 GdkEventExpose
*event
;
3587 gpointer client_data
;
3591 gdk_drawable_get_size (event
->window
, &width
, &height
);
3593 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3594 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3596 event
->area
.x
= max (0, event
->area
.x
);
3597 event
->area
.y
= max (0, event
->area
.y
);
3599 event
->area
.width
= max (width
, event
->area
.width
);
3600 event
->area
.height
= max (height
, event
->area
.height
);
3605 /* This callback is called when a tool bar shall be redrawn.
3606 We need to update the tool bar from here in case the image cache
3607 has deleted the pixmaps used in the tool bar.
3608 W is the GtkToolbar to be redrawn.
3609 EVENT is the expose event for W.
3610 CLIENT_DATA is pointing to the frame for this tool bar.
3612 Returns FALSE to tell GTK to keep processing this event. */
3615 xg_tool_bar_expose_callback (w
, event
, client_data
)
3617 GdkEventExpose
*event
;
3618 gpointer client_data
;
3620 update_frame_tool_bar ((FRAME_PTR
) client_data
);
3624 /* Create a tool bar for frame F. */
3627 xg_create_tool_bar (f
)
3630 struct x_output
*x
= f
->output_data
.x
;
3632 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3634 x
->toolbar_widget
= gtk_toolbar_new ();
3635 x
->handlebox_widget
= gtk_handle_box_new ();
3636 x
->toolbar_detached
= 0;
3638 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3641 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3644 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3647 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3649 /* We only have icons, so override any user setting. We could
3650 use the caption property of the toolbar item (see update_frame_tool_bar
3651 below), but some of those strings are long, making the toolbar so
3652 long it does not fit on the screen. The GtkToolbar widget makes every
3653 item equal size, so the longest caption determine the size of every
3654 tool bar item. I think the creators of the GtkToolbar widget
3655 counted on 4 or 5 character long strings. */
3656 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3657 gtk_toolbar_set_orientation (GTK_TOOLBAR (x
->toolbar_widget
),
3658 GTK_ORIENTATION_HORIZONTAL
);
3660 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3661 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3662 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3663 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3664 g_signal_connect (G_OBJECT (x
->toolbar_widget
),
3666 G_CALLBACK (xg_tool_bar_expose_callback
),
3669 gtk_widget_show_all (x
->handlebox_widget
);
3671 gtk_widget_size_request (x
->toolbar_widget
, &req
);
3672 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3674 /* The height has changed, resize outer widget and set columns
3675 rows to what we had before adding the tool bar. */
3676 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3678 SET_FRAME_GARBAGED (f
);
3681 /* Update the tool bar for frame F. Add new buttons and remove old. */
3684 update_frame_tool_bar (f
)
3688 GtkRequisition old_req
, new_req
;
3689 struct x_output
*x
= f
->output_data
.x
;
3690 int hmargin
, vmargin
;
3693 if (! FRAME_GTK_WIDGET (f
))
3698 if (INTEGERP (Vtool_bar_button_margin
)
3699 && XINT (Vtool_bar_button_margin
) > 0)
3701 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3702 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3704 else if (CONSP (Vtool_bar_button_margin
))
3706 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3707 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3708 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3710 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3711 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3712 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3715 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3716 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3717 i.e. zero. This means that margins less than
3718 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3719 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3720 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3722 if (! x
->toolbar_widget
)
3723 xg_create_tool_bar (f
);
3725 gtk_widget_size_request (x
->toolbar_widget
, &old_req
);
3727 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3729 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3731 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3732 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3738 GtkWidget
*weventbox
;
3740 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (x
->toolbar_widget
), i
);
3744 weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3745 wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3748 /* If image is a vector, choose the image according to the
3750 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3751 if (VECTORP (image
))
3755 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3756 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3759 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3760 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3762 xassert (ASIZE (image
) >= idx
);
3763 image
= AREF (image
, idx
);
3768 /* Ignore invalid image specifications. */
3769 if (!valid_image_p (image
))
3771 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
3775 img_id
= lookup_image (f
, image
);
3776 img
= IMAGE_FROM_ID (f
, img_id
);
3777 prepare_image_for_display (f
, img
);
3779 if (img
->load_failed_p
|| img
->pixmap
== None
)
3782 gtk_widget_hide_all (GTK_WIDGET (ti
));
3785 /* Insert an empty (non-image) button */
3786 weventbox
= gtk_event_box_new ();
3787 wbutton
= gtk_button_new ();
3788 gtk_button_set_focus_on_click (GTK_BUTTON (wbutton
), FALSE
);
3789 gtk_button_set_relief (GTK_BUTTON (wbutton
), GTK_RELIEF_NONE
);
3790 gtk_container_add (GTK_CONTAINER (weventbox
), wbutton
);
3791 ti
= gtk_tool_item_new ();
3792 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
3793 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
), ti
, i
);
3800 GtkWidget
*w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
3801 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
3802 wbutton
= gtk_button_new ();
3803 gtk_button_set_focus_on_click (GTK_BUTTON (wbutton
), FALSE
);
3804 gtk_button_set_relief (GTK_BUTTON (wbutton
), GTK_RELIEF_NONE
);
3805 gtk_container_add (GTK_CONTAINER (wbutton
), w
);
3806 weventbox
= gtk_event_box_new ();
3807 gtk_container_add (GTK_CONTAINER (weventbox
), wbutton
);
3808 ti
= gtk_tool_item_new ();
3809 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
3810 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
), ti
, i
);
3813 /* The EMACS_INT cast avoids a warning. */
3814 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
3815 GTK_SIGNAL_FUNC (xg_tool_bar_menu_proxy
),
3816 (gpointer
) (EMACS_INT
) i
);
3818 g_signal_connect (G_OBJECT (wbutton
), "clicked",
3819 GTK_SIGNAL_FUNC (xg_tool_bar_callback
),
3820 (gpointer
) (EMACS_INT
) i
);
3822 gtk_widget_show_all (GTK_WIDGET (ti
));
3824 /* Save the image so we can see if an update is needed when
3825 this function is called again. */
3826 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
3827 (gpointer
)img
->pixmap
);
3829 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
3831 /* Catch expose events to overcome an annoying redraw bug, see
3832 comment for xg_tool_bar_item_expose_callback. */
3833 g_signal_connect (G_OBJECT (ti
),
3835 G_CALLBACK (xg_tool_bar_item_expose_callback
),
3838 gtk_widget_set_sensitive (wbutton
, enabled_p
);
3839 gtk_tool_item_set_homogeneous (ti
, FALSE
);
3841 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
3842 no distinction based on modifiers in the activate callback,
3843 so we have to do it ourselves. */
3844 g_signal_connect (wbutton
, "button-release-event",
3845 GTK_SIGNAL_FUNC (xg_tool_bar_button_cb
),
3848 g_object_set_data (G_OBJECT (wbutton
), XG_FRAME_DATA
, (gpointer
)f
);
3850 /* Use enter/leave notify to show help. We use the events
3851 rather than the GtkButton specific signals "enter" and
3852 "leave", so we can have only one callback. The event
3853 will tell us what kind of event it is. */
3854 /* The EMACS_INT cast avoids a warning. */
3855 g_signal_connect (G_OBJECT (weventbox
),
3856 "enter-notify-event",
3857 G_CALLBACK (xg_tool_bar_help_callback
),
3858 (gpointer
) (EMACS_INT
) i
);
3859 g_signal_connect (G_OBJECT (weventbox
),
3860 "leave-notify-event",
3861 G_CALLBACK (xg_tool_bar_help_callback
),
3862 (gpointer
) (EMACS_INT
) i
);
3866 GtkWidget
*wimage
= gtk_bin_get_child (GTK_BIN (wbutton
));
3867 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
3868 XG_TOOL_BAR_IMAGE_DATA
);
3869 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
3871 if (old_img
!= img
->pixmap
)
3872 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
3874 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
3875 (gpointer
)img
->pixmap
);
3877 gtk_widget_set_sensitive (wbutton
, enabled_p
);
3878 gtk_widget_show_all (GTK_WIDGET (ti
));
3884 /* Remove buttons not longer needed. We just hide them so they
3885 can be reused later on. */
3888 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (x
->toolbar_widget
), i
++);
3889 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
3890 } while (ti
!= NULL
);
3892 gtk_widget_size_request (x
->toolbar_widget
, &new_req
);
3893 if (old_req
.height
!= new_req
.height
3894 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
3896 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
3897 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3903 /* Deallocate all resources for the tool bar on frame F.
3904 Remove the tool bar. */
3907 free_frame_tool_bar (f
)
3910 struct x_output
*x
= f
->output_data
.x
;
3912 if (x
->toolbar_widget
)
3915 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
3916 x
->handlebox_widget
);
3917 x
->toolbar_widget
= 0;
3918 x
->handlebox_widget
= 0;
3919 FRAME_TOOLBAR_HEIGHT (f
) = 0;
3921 /* The height has changed, resize outer widget and set columns
3922 rows to what we had before removing the tool bar. */
3923 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3925 SET_FRAME_GARBAGED (f
);
3932 /***********************************************************************
3934 ***********************************************************************/
3938 GtkBindingSet
*binding_set
;
3941 /* Work around a bug with corrupted data if libXft gets unloaded. This way
3942 we keep it permanently linked in. */
3945 xg_ignore_gtk_scrollbar
= 0;
3946 xg_detached_menus
= 0;
3947 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
3948 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
3950 id_to_widget
.max_size
= id_to_widget
.used
= 0;
3951 id_to_widget
.widgets
= 0;
3953 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
3954 bindings. It doesn't seem to be any way to remove properties,
3955 so we set it to VoidSymbol which in X means "no key". */
3956 gtk_settings_set_string_property (gtk_settings_get_default (),
3957 "gtk-menu-bar-accel",
3961 /* Make GTK text input widgets use Emacs style keybindings. This is
3963 gtk_settings_set_string_property (gtk_settings_get_default (),
3964 "gtk-key-theme-name",
3968 /* Make dialogs close on C-g. Since file dialog inherits from
3969 dialog, this works for them also. */
3970 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_DIALOG
));
3971 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3974 /* Make menus close on C-g. */
3975 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_MENU_SHELL
));
3976 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3980 #endif /* USE_GTK */
3982 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
3983 (do not change this comment) */