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 3, 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
));
302 file_for_image(image
)
305 Lisp_Object specified_file
= Qnil
;
307 extern Lisp_Object QCfile
;
309 for (tail
= XCDR (image
);
310 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
311 tail
= XCDR (XCDR (tail
)))
312 if (EQ (XCAR (tail
), QCfile
))
313 specified_file
= XCAR (XCDR (tail
));
315 return specified_file
;
318 /* For the image defined in IMG, make and return a GtkImage. For displays with
319 8 planes or less we must make a GdkPixbuf and apply the mask manually.
320 Otherwise the highlightning and dimming the tool bar code in GTK does
321 will look bad. For display with more than 8 planes we just use the
322 pixmap and mask directly. For monochrome displays, GTK doesn't seem
323 able to use external pixmaps, it looks bad whatever we do.
324 The image is defined on the display where frame F is.
325 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
326 If OLD_WIDGET is NULL, a new widget is constructed and returned.
327 If OLD_WIDGET is not NULL, that widget is modified. */
330 xg_get_image_for_pixmap (f
, img
, widget
, old_widget
)
334 GtkImage
*old_widget
;
340 /* If we have a file, let GTK do all the image handling.
341 This seems to be the only way to make insensitive and activated icons
342 look good in all cases. */
343 Lisp_Object specified_file
= file_for_image (img
->spec
);
346 /* We already loaded the image once before calling this
347 function, so this only fails if the image file has been removed.
348 In that case, use the pixmap already loaded. */
350 if (STRINGP (specified_file
)
351 && STRINGP (file
= x_find_image_file (specified_file
)))
354 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
356 gtk_image_set_from_file (old_widget
, SSDATA (file
));
358 return GTK_WIDGET (old_widget
);
361 /* No file, do the image handling ourselves. This will look very bad
362 on a monochrome display, and sometimes bad on all displays with
365 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
366 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
367 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
369 if (x_screen_planes (f
) > 8 || x_screen_planes (f
) == 1)
372 old_widget
= GTK_IMAGE (gtk_image_new_from_pixmap (gpix
, gmask
));
374 gtk_image_set_from_pixmap (old_widget
, gpix
, gmask
);
379 /* This is a workaround to make icons look good on pseudo color
380 displays. Apparently GTK expects the images to have an alpha
381 channel. If they don't, insensitive and activated icons will
382 look bad. This workaround does not work on monochrome displays,
383 and is not needed on true color/static color displays (i.e.
384 16 bits and higher). */
385 GdkColormap
*cmap
= gtk_widget_get_colormap (widget
);
386 GdkPixbuf
*icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
389 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
391 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
393 g_object_unref (G_OBJECT (icon_buf
));
396 g_object_unref (G_OBJECT (gpix
));
397 if (gmask
) g_object_unref (G_OBJECT (gmask
));
399 return GTK_WIDGET (old_widget
);
403 /* Set CURSOR on W and all widgets W contain. We must do like this
404 for scroll bars and menu because they create widgets internally,
405 and it is those widgets that are visible. */
408 xg_set_cursor (w
, cursor
)
412 GList
*children
= gdk_window_peek_children (w
->window
);
414 gdk_window_set_cursor (w
->window
, cursor
);
416 /* The scroll bar widget has more than one GDK window (had to look at
417 the source to figure this out), and there is no way to set cursor
418 on widgets in GTK. So we must set the cursor for all GDK windows.
421 for ( ; children
; children
= g_list_next (children
))
422 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
425 /* Timer function called when a timeout occurs for xg_timer.
426 This function processes all GTK events in a recursive event loop.
427 This is done because GTK timer events are not seen by Emacs event
428 detection, Emacs only looks for X events. When a scroll bar has the
429 pointer (detected by button press/release events below) an Emacs
430 timer is started, and this function can then check if the GTK timer
431 has expired by calling the GTK event loop.
432 Also, when a menu is active, it has a small timeout before it
433 pops down the sub menu under it. */
436 xg_process_timeouts (timer
)
437 struct atimer
*timer
;
440 /* Ideally we would like to just handle timer events, like the Xt version
441 of this does in xterm.c, but there is no such feature in GTK. */
442 while (gtk_events_pending ())
443 gtk_main_iteration ();
447 /* Start the xg_timer with an interval of 0.1 seconds, if not already started.
448 xg_process_timeouts is called when the timer expires. The timer
449 started is continuous, i.e. runs until xg_stop_timer is called. */
457 EMACS_SET_SECS_USECS (interval
, 0, 100000);
458 xg_timer
= start_atimer (ATIMER_CONTINUOUS
,
465 /* Stop the xg_timer if started. */
472 cancel_atimer (xg_timer
);
477 /* Insert NODE into linked LIST. */
480 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
482 xg_list_node
*list_start
= list
->next
;
484 if (list_start
) list_start
->prev
= node
;
485 node
->next
= list_start
;
490 /* Remove NODE from linked LIST. */
493 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
495 xg_list_node
*list_start
= list
->next
;
496 if (node
== list_start
)
498 list
->next
= node
->next
;
499 if (list
->next
) list
->next
->prev
= 0;
503 node
->prev
->next
= node
->next
;
504 if (node
->next
) node
->next
->prev
= node
->prev
;
508 /* Allocate and return a utf8 version of STR. If STR is already
509 utf8 or NULL, just return STR.
510 If not, a new string is allocated and the caller must free the result
514 get_utf8_string (str
)
517 char *utf8_str
= str
;
519 if (!str
) return NULL
;
521 /* If not UTF-8, try current locale. */
522 if (!g_utf8_validate (str
, -1, NULL
))
523 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
527 /* Probably some control characters in str. Escape them. */
531 unsigned char *p
= (unsigned char *)str
;
533 GError
*error
= NULL
;
535 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
536 &bytes_written
, &error
))
537 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
540 p
+= bytes_written
+1;
541 g_error_free (error
);
547 g_error_free (error
);
552 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
553 p
= (unsigned char *)str
;
555 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
556 &bytes_written
, &error
))
557 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
559 strncpy (up
, (char *)p
, bytes_written
);
560 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
561 up
[bytes_written
+4] = '\0';
562 up
+= bytes_written
+4;
563 p
+= bytes_written
+1;
564 g_error_free (error
);
570 strcat (utf8_str
, cp
);
575 g_error_free (error
);
584 /***********************************************************************
585 General functions for creating widgets, resizing, events, e.t.c.
586 ***********************************************************************/
588 /* Make a geometry string and pass that to GTK. It seems this is the
589 only way to get geometry position right if the user explicitly
590 asked for a position when starting Emacs.
591 F is the frame we shall set geometry for. */
597 if (f
->size_hint_flags
& USPosition
)
599 int left
= f
->left_pos
;
600 int xneg
= f
->size_hint_flags
& XNegative
;
601 int top
= f
->top_pos
;
602 int yneg
= f
->size_hint_flags
& YNegative
;
610 sprintf (geom_str
, "=%dx%d%c%d%c%d",
611 FRAME_PIXEL_WIDTH (f
),
612 FRAME_TOTAL_PIXEL_HEIGHT (f
),
613 (xneg
? '-' : '+'), left
,
614 (yneg
? '-' : '+'), top
);
616 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
618 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
619 } else if (f
->size_hint_flags
& PPosition
) {
620 gtk_window_move (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
621 f
->left_pos
, f
->top_pos
);
626 /* Resize the outer window of frame F after chainging the height.
627 This happend when the menu bar or the tool bar is added or removed.
628 COLUMNS/ROWS is the size the edit area shall have after the resize. */
631 xg_resize_outer_widget (f
, columns
, rows
)
636 /* If we are not mapped yet, set geometry once again, as window
637 height now have changed. */
638 if (! GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f
)))
641 xg_frame_set_char_size (f
, columns
, rows
);
642 gdk_window_process_all_updates ();
645 /* Function to handle resize of our widgets. Since Emacs has some layouts
646 that does not fit well with GTK standard containers, we do most layout
648 F is the frame to resize.
649 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
652 xg_resize_widgets (f
, pixelwidth
, pixelheight
)
654 int pixelwidth
, pixelheight
;
656 int mbheight
= FRAME_MENUBAR_HEIGHT (f
);
657 int tbheight
= FRAME_TOOLBAR_HEIGHT (f
);
658 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, (pixelheight
659 - mbheight
- tbheight
));
660 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
662 if (FRAME_GTK_WIDGET (f
)
663 && (columns
!= FRAME_COLS (f
)
664 || rows
!= FRAME_LINES (f
)
665 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
666 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
)))
668 struct x_output
*x
= f
->output_data
.x
;
671 all
.y
= mbheight
+ tbheight
;
674 all
.width
= pixelwidth
;
675 all
.height
= pixelheight
- mbheight
- tbheight
;
677 gtk_widget_size_allocate (x
->edit_widget
, &all
);
679 change_frame_size (f
, rows
, columns
, 0, 1, 0);
680 SET_FRAME_GARBAGED (f
);
681 cancel_mouse_face (f
);
686 /* Update our widget size to be COLS/ROWS characters for frame F. */
689 xg_frame_set_char_size (f
, cols
, rows
)
694 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
695 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
698 /* Take into account the size of the scroll bar. Always use the
699 number of columns occupied by the scroll bar here otherwise we
700 might end up with a frame width that is not a multiple of the
701 frame's character width which is bad for vertically split
703 f
->scroll_bar_actual_width
704 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
706 compute_fringe_widths (f
, 0);
708 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
709 after calculating that value. */
710 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
712 /* Must resize our top level widget. Font size may have changed,
713 but not rows/cols. */
714 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
715 pixelwidth
, pixelheight
);
716 xg_resize_widgets (f
, pixelwidth
, pixelheight
);
717 x_wm_set_size_hint (f
, 0, 0);
718 SET_FRAME_GARBAGED (f
);
719 cancel_mouse_face (f
);
722 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
723 Must be done like this, because GtkWidget:s can have "hidden"
724 X Window that aren't accessible.
726 Return 0 if no widget match WDESC. */
729 xg_win_to_widget (dpy
, wdesc
)
734 GtkWidget
*gwdesc
= 0;
738 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
743 event
.any
.window
= gdkwin
;
744 gwdesc
= gtk_get_event_widget (&event
);
751 /* Fill in the GdkColor C so that it represents PIXEL.
752 W is the widget that color will be used for. Used to find colormap. */
755 xg_pix_to_gcolor (w
, pixel
, c
)
760 GdkColormap
*map
= gtk_widget_get_colormap (w
);
761 gdk_colormap_query_color (map
, pixel
, c
);
764 /* Create and set up the GTK widgets for frame F.
765 Return 0 if creation failed, non-zero otherwise. */
768 xg_create_frame_widgets (f
)
781 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
782 xg_set_screen (wtop
, f
);
784 wvbox
= gtk_vbox_new (FALSE
, 0);
785 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
787 if (! wtop
|| ! wvbox
|| ! wfixed
)
789 if (wtop
) gtk_widget_destroy (wtop
);
790 if (wvbox
) gtk_widget_destroy (wvbox
);
791 if (wfixed
) gtk_widget_destroy (wfixed
);
797 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
798 gtk_widget_set_name (wtop
, EMACS_CLASS
);
799 gtk_widget_set_name (wvbox
, "pane");
800 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
802 /* If this frame has a title or name, set it in the title bar. */
803 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
804 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
806 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
808 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
809 FRAME_GTK_WIDGET (f
) = wfixed
;
810 f
->output_data
.x
->vbox_widget
= wvbox
;
812 gtk_fixed_set_has_window (GTK_FIXED (wfixed
), TRUE
);
814 gtk_widget_set_size_request (wfixed
, FRAME_PIXEL_WIDTH (f
),
815 FRAME_PIXEL_HEIGHT (f
));
817 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
818 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
820 if (FRAME_EXTERNAL_TOOL_BAR (f
))
821 update_frame_tool_bar (f
);
823 /* The tool bar is created but first there are no items in it.
824 This causes it to be zero height. Later items are added, but then
825 the frame is already mapped, so there is a "jumping" resize.
826 This makes geometry handling difficult, for example -0-0 will end
827 up in the wrong place as tool bar height has not been taken into account.
828 So we cheat a bit by setting a height that is what it will have
829 later on when tool bar items are added. */
830 if (FRAME_EXTERNAL_TOOL_BAR (f
) && f
->n_tool_bar_items
== 0)
831 FRAME_TOOLBAR_HEIGHT (f
) = 38;
834 /* We don't want this widget double buffered, because we draw on it
835 with regular X drawing primitives, so from a GTK/GDK point of
836 view, the widget is totally blank. When an expose comes, this
837 will make the widget blank, and then Emacs redraws it. This flickers
838 a lot, so we turn off double buffering. */
839 gtk_widget_set_double_buffered (wfixed
, FALSE
);
841 /* GTK documents says use gtk_window_set_resizable. But then a user
842 can't shrink the window from its starting size. */
843 gtk_window_set_policy (GTK_WINDOW (wtop
), TRUE
, TRUE
, TRUE
);
844 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
845 SSDATA (Vx_resource_name
),
846 SSDATA (Vx_resource_class
));
848 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
849 GTK is to destroy the widget. We want Emacs to do that instead. */
850 g_signal_connect (G_OBJECT (wtop
), "delete-event",
851 G_CALLBACK (gtk_true
), 0);
853 /* Convert our geometry parameters into a geometry string
855 GTK will itself handle calculating the real position this way. */
858 gtk_widget_add_events (wfixed
,
859 GDK_POINTER_MOTION_MASK
861 | GDK_BUTTON_PRESS_MASK
862 | GDK_BUTTON_RELEASE_MASK
864 | GDK_ENTER_NOTIFY_MASK
865 | GDK_LEAVE_NOTIFY_MASK
866 | GDK_FOCUS_CHANGE_MASK
868 | GDK_VISIBILITY_NOTIFY_MASK
);
870 /* Must realize the windows so the X window gets created. It is used
871 by callers of this function. */
872 gtk_widget_realize (wfixed
);
873 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
875 /* Since GTK clears its window by filling with the background color,
876 we must keep X and GTK background in sync. */
877 xg_pix_to_gcolor (wfixed
, FRAME_BACKGROUND_PIXEL (f
), &bg
);
878 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
880 /* Also, do not let any background pixmap to be set, this looks very
881 bad as Emacs overwrites the background pixmap with its own idea
882 of background color. */
883 style
= gtk_widget_get_modifier_style (wfixed
);
885 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
886 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
887 gtk_widget_modify_style (wfixed
, style
);
889 /* GTK does not set any border, and they look bad with GTK. */
891 f
->internal_border_width
= 0;
898 /* Set the normal size hints for the window manager, for frame F.
899 FLAGS is the flags word to use--or 0 meaning preserve the flags
900 that the window now has.
901 If USER_POSITION is nonzero, we set the User Position
902 flag (this is useful when FLAGS is 0). */
905 x_wm_set_size_hint (f
, flags
, user_position
)
910 if (FRAME_GTK_OUTER_WIDGET (f
))
912 /* Must use GTK routines here, otherwise GTK resets the size hints
913 to its own defaults. */
914 GdkGeometry size_hints
;
916 int base_width
, base_height
;
917 int min_rows
= 0, min_cols
= 0;
918 int win_gravity
= f
->win_gravity
;
922 memset (&size_hints
, 0, sizeof (size_hints
));
923 f
->output_data
.x
->size_hints
= size_hints
;
924 f
->output_data
.x
->hint_flags
= hint_flags
;
927 flags
= f
->size_hint_flags
;
929 size_hints
= f
->output_data
.x
->size_hints
;
930 hint_flags
= f
->output_data
.x
->hint_flags
;
932 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
933 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
934 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
936 hint_flags
|= GDK_HINT_BASE_SIZE
;
937 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
938 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
939 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
941 check_frame_size (f
, &min_rows
, &min_cols
);
943 size_hints
.base_width
= base_width
;
944 size_hints
.base_height
= base_height
;
945 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
946 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
949 /* These currently have a one to one mapping with the X values, but I
950 don't think we should rely on that. */
951 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
952 size_hints
.win_gravity
= 0;
953 if (win_gravity
== NorthWestGravity
)
954 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
955 else if (win_gravity
== NorthGravity
)
956 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
957 else if (win_gravity
== NorthEastGravity
)
958 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
959 else if (win_gravity
== WestGravity
)
960 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
961 else if (win_gravity
== CenterGravity
)
962 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
963 else if (win_gravity
== EastGravity
)
964 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
965 else if (win_gravity
== SouthWestGravity
)
966 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
967 else if (win_gravity
== SouthGravity
)
968 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
969 else if (win_gravity
== SouthEastGravity
)
970 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
971 else if (win_gravity
== StaticGravity
)
972 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
974 if (flags
& PPosition
) hint_flags
|= GDK_HINT_POS
;
975 if (flags
& USPosition
) hint_flags
|= GDK_HINT_USER_POS
;
976 if (flags
& USSize
) hint_flags
|= GDK_HINT_USER_SIZE
;
980 hint_flags
&= ~GDK_HINT_POS
;
981 hint_flags
|= GDK_HINT_USER_POS
;
986 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
987 FRAME_GTK_OUTER_WIDGET (f
),
991 f
->output_data
.x
->size_hints
= size_hints
;
992 f
->output_data
.x
->hint_flags
= hint_flags
;
997 /* Change background color of a frame.
998 Since GTK uses the background colour to clear the window, we must
999 keep the GTK and X colors in sync.
1000 F is the frame to change,
1001 BG is the pixel value to change to. */
1004 xg_set_background_color (f
, bg
)
1008 if (FRAME_GTK_WIDGET (f
))
1013 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
1014 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
1020 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1021 functions so GTK does not overwrite the icon. */
1024 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
)
1029 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1030 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
1031 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
1032 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
1034 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1039 /***********************************************************************
1041 ***********************************************************************/
1042 /* Return the dialog title to use for a dialog of type KEY.
1043 This is the encoding used by lwlib. We use the same for GTK. */
1046 get_dialog_title (char key
)
1056 title
= "Information";
1075 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1076 the dialog, but return TRUE so the event does not propagate further
1077 in GTK. This prevents GTK from destroying the dialog widget automatically
1078 and we can always destrou the widget manually, regardles of how
1079 it was popped down (button press or WM_DELETE_WINDOW).
1080 W is the dialog widget.
1081 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1082 user_data is NULL (not used).
1084 Returns TRUE to end propagation of event. */
1087 dialog_delete_callback (w
, event
, user_data
)
1092 gtk_widget_unmap (w
);
1096 /* Create a popup dialog window. See also xg_create_widget below.
1097 WV is a widget_value describing the dialog.
1098 SELECT_CB is the callback to use when a button has been pressed.
1099 DEACTIVATE_CB is the callback to use when the dialog pops down.
1101 Returns the GTK dialog widget. */
1104 create_dialog (wv
, select_cb
, deactivate_cb
)
1106 GCallback select_cb
;
1107 GCallback deactivate_cb
;
1109 char *title
= get_dialog_title (wv
->name
[0]);
1110 int total_buttons
= wv
->name
[1] - '0';
1111 int right_buttons
= wv
->name
[4] - '0';
1114 int button_spacing
= 10;
1115 GtkWidget
*wdialog
= gtk_dialog_new ();
1119 GtkWidget
*whbox_up
;
1120 GtkWidget
*whbox_down
;
1122 /* If the number of buttons is greater than 4, make two rows of buttons
1123 instead. This looks better. */
1124 int make_two_rows
= total_buttons
> 4;
1126 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1127 left_buttons
= total_buttons
- right_buttons
;
1129 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1130 gtk_widget_set_name (wdialog
, "emacs-dialog");
1132 cur_box
= GTK_BOX (GTK_DIALOG (wdialog
)->action_area
);
1136 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1137 whbox_up
= gtk_hbox_new (FALSE
, 0);
1138 whbox_down
= gtk_hbox_new (FALSE
, 0);
1140 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1141 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1142 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1144 cur_box
= GTK_BOX (whbox_up
);
1147 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1148 G_CALLBACK (dialog_delete_callback
), 0);
1152 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1153 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1156 for (item
= wv
->contents
; item
; item
= item
->next
)
1158 char *utf8_label
= get_utf8_string (item
->value
);
1162 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1164 /* This is the text part of the dialog. */
1165 w
= gtk_label_new (utf8_label
);
1166 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1169 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
), w
,
1171 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1173 /* Try to make dialog look better. Must realize first so
1174 the widget can calculate the size it needs. */
1175 gtk_widget_realize (w
);
1176 gtk_widget_size_request (w
, &req
);
1177 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1179 if (item
->value
&& strlen (item
->value
) > 0)
1180 button_spacing
= 2*req
.width
/strlen (item
->value
);
1184 /* This is one button to add to the dialog. */
1185 w
= gtk_button_new_with_label (utf8_label
);
1186 if (! item
->enabled
)
1187 gtk_widget_set_sensitive (w
, FALSE
);
1189 g_signal_connect (G_OBJECT (w
), "clicked",
1190 select_cb
, item
->call_data
);
1192 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1193 if (++button_nr
== left_buttons
)
1196 cur_box
= GTK_BOX (whbox_down
);
1198 gtk_box_pack_start (cur_box
,
1205 if (utf8_label
&& utf8_label
!= item
->value
)
1206 g_free (utf8_label
);
1214 /***********************************************************************
1215 File dialog functions
1216 ***********************************************************************/
1217 /* Return non-zero if the old file selection dialog is being used.
1218 Return zero if not. */
1221 xg_uses_old_file_dialog ()
1223 #ifdef HAVE_GTK_FILE_BOTH
1224 extern int x_gtk_use_old_file_dialog
;
1225 return x_gtk_use_old_file_dialog
;
1226 #else /* ! HAVE_GTK_FILE_BOTH */
1228 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1234 #endif /* ! HAVE_GTK_FILE_BOTH */
1238 /* Function that is called when the file dialog pops down.
1239 W is the dialog widget, RESPONSE is the response code.
1240 USER_DATA is what we passed in to g_signal_connect (pointer to int). */
1243 xg_file_response_cb (w
,
1250 int *ptr
= (int *) user_data
;
1255 /* Destroy the dialog. This makes it pop down. */
1258 pop_down_file_dialog (arg
)
1261 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1263 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1268 typedef char * (*xg_get_file_func
) P_ ((GtkWidget
*));
1270 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1272 /* Return the selected file for file chooser dialog W.
1273 The returned string must be free:d. */
1276 xg_get_file_name_from_chooser (w
)
1279 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1282 /* Callback called when the "Show hidden files" toggle is pressed.
1283 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1286 xg_toggle_visibility_cb (widget
, data
)
1290 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1292 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1293 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1297 /* Callback called when a property changes in a file chooser.
1298 GOBJECT is the file chooser dialog, ARG1 describes the property.
1299 USER_DATA is the toggle widget in the file chooser dialog.
1300 We use this to update the "Show hidden files" toggle when the user
1301 changes that property by right clicking in the file list. */
1304 xg_toggle_notify_cb (gobject
, arg1
, user_data
)
1309 extern int x_gtk_show_hidden_files
;
1311 if (strcmp (arg1
->name
, "show-hidden") == 0)
1313 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (gobject
);
1314 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1315 gboolean visible
, toggle_on
;
1317 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1318 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1320 if (!!visible
!= !!toggle_on
)
1322 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1323 G_CALLBACK (xg_toggle_visibility_cb
),
1325 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1326 g_signal_handlers_unblock_by_func
1327 (G_OBJECT (wtoggle
),
1328 G_CALLBACK (xg_toggle_visibility_cb
),
1331 x_gtk_show_hidden_files
= visible
;
1335 /* Read a file name from the user using a file chooser dialog.
1336 F is the current frame.
1337 PROMPT is a prompt to show to the user. May not be NULL.
1338 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1339 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1340 file. *FUNC is set to a function that can be used to retrieve the
1341 selected file name from the returned widget.
1343 Returns the created widget. */
1346 xg_get_file_with_chooser (f
, prompt
, default_filename
,
1347 mustmatch_p
, only_dir_p
, func
)
1350 char *default_filename
;
1351 int mustmatch_p
, only_dir_p
;
1352 xg_get_file_func
*func
;
1356 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1357 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1358 GtkFileChooserAction action
= (mustmatch_p
?
1359 GTK_FILE_CHOOSER_ACTION_OPEN
:
1360 GTK_FILE_CHOOSER_ACTION_SAVE
);
1361 extern int x_gtk_show_hidden_files
;
1362 extern int x_gtk_file_dialog_help_text
;
1366 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1368 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1369 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1370 (mustmatch_p
|| only_dir_p
?
1371 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1374 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1376 wbox
= gtk_vbox_new (FALSE
, 0);
1377 gtk_widget_show (wbox
);
1378 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1380 if (x_gtk_show_hidden_files
)
1382 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1383 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1385 gtk_widget_show (wtoggle
);
1386 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1387 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1388 g_signal_connect (G_OBJECT (filewin
), "notify",
1389 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1391 if (x_gtk_file_dialog_help_text
)
1394 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1395 Show the C-l help text only for versions < 2.10. */
1396 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1397 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1398 strcat (message
, "\nIf you don't like this file selector, use the "
1399 "corresponding\nkey binding or customize "
1400 "use-file-dialog to turn it off.");
1402 wmessage
= gtk_label_new (message
);
1403 gtk_widget_show (wmessage
);
1406 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1407 if (x_gtk_file_dialog_help_text
)
1408 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1409 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1411 if (default_filename
)
1414 struct gcpro gcpro1
;
1416 char *utf8_filename
;
1418 file
= build_string (default_filename
);
1420 /* File chooser does not understand ~/... in the file name. It must be
1421 an absolute name starting with /. */
1422 if (default_filename
[0] != '/')
1423 file
= Fexpand_file_name (file
, Qnil
);
1425 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1426 if (! NILP (Ffile_directory_p (file
)))
1427 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1431 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1433 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1435 char *cp
= strrchr (utf8_filename
, '/');
1437 else cp
= utf8_filename
;
1438 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1445 *func
= xg_get_file_name_from_chooser
;
1448 #endif /* HAVE_GTK_FILE_CHOOSER_DIALOG_NEW */
1450 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1452 /* Return the selected file for file selector dialog W.
1453 The returned string must be free:d. */
1456 xg_get_file_name_from_selector (w
)
1459 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1460 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1463 /* Create a file selection dialog.
1464 F is the current frame.
1465 PROMPT is a prompt to show to the user. May not be NULL.
1466 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1467 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1468 file. *FUNC is set to a function that can be used to retrieve the
1469 selected file name from the returned widget.
1471 Returns the created widget. */
1474 xg_get_file_with_selection (f
, prompt
, default_filename
,
1475 mustmatch_p
, only_dir_p
, func
)
1478 char *default_filename
;
1479 int mustmatch_p
, only_dir_p
;
1480 xg_get_file_func
*func
;
1483 GtkFileSelection
*filesel
;
1485 filewin
= gtk_file_selection_new (prompt
);
1486 filesel
= GTK_FILE_SELECTION (filewin
);
1488 if (default_filename
)
1489 gtk_file_selection_set_filename (filesel
, default_filename
);
1493 /* The selection_entry part of filesel is not documented. */
1494 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1495 gtk_file_selection_hide_fileop_buttons (filesel
);
1498 *func
= xg_get_file_name_from_selector
;
1502 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1504 /* Read a file name from the user using a file dialog, either the old
1505 file selection dialog, or the new file chooser dialog. Which to use
1506 depends on what the GTK version used has, and what the value of
1507 gtk-use-old-file-dialog.
1508 F is the current frame.
1509 PROMPT is a prompt to show to the user. May not be NULL.
1510 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1511 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1514 Returns a file name or NULL if no file was selected.
1515 The returned string must be freed by the caller. */
1518 xg_get_file_name (f
, prompt
, default_filename
, mustmatch_p
, only_dir_p
)
1521 char *default_filename
;
1522 int mustmatch_p
, only_dir_p
;
1525 int count
= SPECPDL_INDEX ();
1527 int filesel_done
= 0;
1528 xg_get_file_func func
;
1530 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1531 /* I really don't know why this is needed, but without this the GLIBC add on
1532 library linuxthreads hangs when the Gnome file chooser backend creates
1534 sigblock (sigmask (__SIGRTMIN
));
1535 #endif /* HAVE_GTK_AND_PTHREAD */
1537 #ifdef HAVE_GTK_FILE_BOTH
1539 if (xg_uses_old_file_dialog ())
1540 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1541 mustmatch_p
, only_dir_p
, &func
);
1543 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1544 mustmatch_p
, only_dir_p
, &func
);
1546 #else /* not HAVE_GTK_FILE_BOTH */
1548 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1549 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1550 mustmatch_p
, only_dir_p
, &func
);
1552 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1553 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1554 mustmatch_p
, only_dir_p
, &func
);
1557 #endif /* HAVE_GTK_FILE_BOTH */
1559 xg_set_screen (w
, f
);
1560 gtk_widget_set_name (w
, "emacs-filedialog");
1561 gtk_window_set_transient_for (GTK_WINDOW (w
),
1562 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1563 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1564 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1566 g_signal_connect (G_OBJECT (w
),
1568 G_CALLBACK (xg_file_response_cb
),
1571 /* Don't destroy the widget if closed by the window manager close button. */
1572 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1574 gtk_widget_show (w
);
1576 record_unwind_protect (pop_down_file_dialog
, make_save_value (w
, 0));
1577 while (! filesel_done
)
1579 x_menu_wait_for_event (0);
1580 gtk_main_iteration ();
1583 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1584 sigunblock (sigmask (__SIGRTMIN
));
1587 if (filesel_done
== GTK_RESPONSE_OK
)
1590 unbind_to (count
, Qnil
);
1596 /***********************************************************************
1598 ***********************************************************************/
1600 /* The name of menu items that can be used for citomization. Since GTK
1601 RC files are very crude and primitive, we have to set this on all
1602 menu item names so a user can easily cutomize menu items. */
1604 #define MENU_ITEM_NAME "emacs-menuitem"
1607 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1608 during GC. The next member points to the items. */
1609 static xg_list_node xg_menu_cb_list
;
1611 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1612 during GC. The next member points to the items. */
1613 static xg_list_node xg_menu_item_cb_list
;
1615 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1616 F is the frame CL_DATA will be initialized for.
1617 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1619 The menu bar and all sub menus under the menu bar in a frame
1620 share the same structure, hence the reference count.
1622 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1623 allocated xg_menu_cb_data if CL_DATA is NULL. */
1625 static xg_menu_cb_data
*
1626 make_cl_data (cl_data
, f
, highlight_cb
)
1627 xg_menu_cb_data
*cl_data
;
1629 GCallback highlight_cb
;
1633 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1635 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1636 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1637 cl_data
->highlight_cb
= highlight_cb
;
1638 cl_data
->ref_count
= 0;
1640 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1643 cl_data
->ref_count
++;
1648 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1649 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1651 When the menu bar is updated, menu items may have been added and/or
1652 removed, so menu_bar_vector and menu_bar_items_used change. We must
1653 then update CL_DATA since it is used to determine which menu
1654 item that is invoked in the menu.
1655 HIGHLIGHT_CB could change, there is no check that the same
1656 function is given when modifying a menu bar as was given when
1657 creating the menu bar. */
1660 update_cl_data (cl_data
, f
, highlight_cb
)
1661 xg_menu_cb_data
*cl_data
;
1663 GCallback highlight_cb
;
1668 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1669 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1670 cl_data
->highlight_cb
= highlight_cb
;
1674 /* Decrease reference count for CL_DATA.
1675 If reference count is zero, free CL_DATA. */
1678 unref_cl_data (cl_data
)
1679 xg_menu_cb_data
*cl_data
;
1681 if (cl_data
&& cl_data
->ref_count
> 0)
1683 cl_data
->ref_count
--;
1684 if (cl_data
->ref_count
== 0)
1686 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1692 /* Function that marks all lisp data during GC. */
1699 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1700 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1702 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1704 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1706 if (! NILP (cb_data
->help
))
1707 mark_object (cb_data
->help
);
1712 /* Callback called when a menu item is destroyed. Used to free data.
1713 W is the widget that is being destroyed (not used).
1714 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1717 menuitem_destroy_callback (w
, client_data
)
1719 gpointer client_data
;
1723 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1724 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1729 /* Callback called when the pointer enters/leaves a menu item.
1730 W is the parent of the menu item.
1731 EVENT is either an enter event or leave event.
1732 CLIENT_DATA is not used.
1734 Returns FALSE to tell GTK to keep processing this event. */
1737 menuitem_highlight_callback (w
, event
, client_data
)
1739 GdkEventCrossing
*event
;
1740 gpointer client_data
;
1743 GtkWidget
*subwidget
;
1744 xg_menu_item_cb_data
*data
;
1746 ev
.crossing
= *event
;
1747 subwidget
= gtk_get_event_widget (&ev
);
1748 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
1752 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1754 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
1755 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1756 (*func
) (subwidget
, call_data
);
1763 /* Callback called when a menu is destroyed. Used to free data.
1764 W is the widget that is being destroyed (not used).
1765 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1768 menu_destroy_callback (w
, client_data
)
1770 gpointer client_data
;
1772 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1775 /* Callback called when a menu does a grab or ungrab. That means the
1776 menu has been activated or deactivated.
1777 Used to start a timer so the small timeout the menus in GTK uses before
1778 popping down a menu is seen by Emacs (see xg_process_timeouts above).
1779 W is the widget that does the grab (not used).
1780 UNGRAB_P is TRUE if this is an ungrab, FALSE if it is a grab.
1781 CLIENT_DATA is NULL (not used). */
1784 menu_grab_callback (GtkWidget
*widget
,
1786 gpointer client_data
)
1788 /* Keep track of total number of grabs. */
1791 if (ungrab_p
) cnt
--;
1794 if (cnt
> 0 && ! xg_timer
) xg_start_timer ();
1795 else if (cnt
== 0 && xg_timer
) xg_stop_timer ();
1798 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1799 must be non-NULL) and can be inserted into a menu item.
1801 Returns the GtkHBox. */
1804 make_widget_for_menu_item (utf8_label
, utf8_key
)
1812 wbox
= gtk_hbox_new (FALSE
, 0);
1813 wlbl
= gtk_label_new (utf8_label
);
1814 wkey
= gtk_label_new (utf8_key
);
1816 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1817 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1819 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1820 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1822 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1823 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1824 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1829 /* Make and return a menu item widget with the key to the right.
1830 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1831 UTF8_KEY is the text representing the key binding.
1832 ITEM is the widget_value describing the menu item.
1834 GROUP is an in/out parameter. If the menu item to be created is not
1835 part of any radio menu group, *GROUP contains NULL on entry and exit.
1836 If the menu item to be created is part of a radio menu group, on entry
1837 *GROUP contains the group to use, or NULL if this is the first item
1838 in the group. On exit, *GROUP contains the radio item group.
1840 Unfortunately, keys don't line up as nicely as in Motif,
1841 but the MacOS X version doesn't either, so I guess that is OK. */
1844 make_menu_item (utf8_label
, utf8_key
, item
, group
)
1851 GtkWidget
*wtoadd
= 0;
1853 /* It has been observed that some menu items have a NULL name field.
1854 This will lead to this function being called with a NULL utf8_label.
1855 GTK crashes on that so we set a blank label. Why there is a NULL
1856 name remains to be investigated. */
1857 if (! utf8_label
) utf8_label
= " ";
1860 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1862 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1865 if (utf8_key
) w
= gtk_check_menu_item_new ();
1866 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1867 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1869 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1871 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1872 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1873 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1875 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1880 if (utf8_key
) w
= gtk_menu_item_new ();
1881 else w
= gtk_menu_item_new_with_label (utf8_label
);
1884 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1885 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1890 /* Return non-zero if LABEL specifies a separator (GTK only has one
1894 xg_separator_p (char *label
)
1896 if (! label
) return 0;
1897 else if (strlen (label
) > 3
1898 && strncmp (label
, "--", 2) == 0
1901 static char* separator_names
[] = {
1906 "single-dashed-line",
1907 "double-dashed-line",
1909 "shadow-etched-out",
1910 "shadow-etched-in-dash",
1911 "shadow-etched-out-dash",
1912 "shadow-double-etched-in",
1913 "shadow-double-etched-out",
1914 "shadow-double-etched-in-dash",
1915 "shadow-double-etched-out-dash",
1922 for (i
= 0; separator_names
[i
]; ++i
)
1923 if (strcmp (label
, separator_names
[i
]) == 0)
1928 /* Old-style separator, maybe. It's a separator if it contains
1930 while (*label
== '-')
1932 if (*label
== 0) return 1;
1938 static int xg_detached_menus
;
1940 /* Returns non-zero if there are detached menus. */
1943 xg_have_tear_offs ()
1945 return xg_detached_menus
> 0;
1948 /* Callback invoked when a detached menu window is removed. Here we
1949 decrease the xg_detached_menus count.
1950 WIDGET is the top level window that is removed (the parent of the menu).
1951 CLIENT_DATA is not used. */
1954 tearoff_remove (widget
, client_data
)
1956 gpointer client_data
;
1958 if (xg_detached_menus
> 0) --xg_detached_menus
;
1961 /* Callback invoked when a menu is detached. It increases the
1962 xg_detached_menus count.
1963 WIDGET is the GtkTearoffMenuItem.
1964 CLIENT_DATA is not used. */
1967 tearoff_activate (widget
, client_data
)
1969 gpointer client_data
;
1971 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
1972 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
1974 ++xg_detached_menus
;
1975 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
1977 G_CALLBACK (tearoff_remove
), 0);
1982 /* Create a menu item widget, and connect the callbacks.
1983 ITEM decribes the menu item.
1984 F is the frame the created menu belongs to.
1985 SELECT_CB is the callback to use when a menu item is selected.
1986 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1987 CL_DATA points to the callback data to be used for this menu.
1988 GROUP is an in/out parameter. If the menu item to be created is not
1989 part of any radio menu group, *GROUP contains NULL on entry and exit.
1990 If the menu item to be created is part of a radio menu group, on entry
1991 *GROUP contains the group to use, or NULL if this is the first item
1992 in the group. On exit, *GROUP contains the radio item group.
1994 Returns the created GtkWidget. */
1997 xg_create_one_menuitem (item
, f
, select_cb
, highlight_cb
, cl_data
, group
)
2000 GCallback select_cb
;
2001 GCallback highlight_cb
;
2002 xg_menu_cb_data
*cl_data
;
2008 xg_menu_item_cb_data
*cb_data
;
2010 utf8_label
= get_utf8_string (item
->name
);
2011 utf8_key
= get_utf8_string (item
->key
);
2013 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2015 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2016 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
2018 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2020 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2022 cb_data
->select_id
= 0;
2023 cb_data
->help
= item
->help
;
2024 cb_data
->cl_data
= cl_data
;
2025 cb_data
->call_data
= item
->call_data
;
2027 g_signal_connect (G_OBJECT (w
),
2029 G_CALLBACK (menuitem_destroy_callback
),
2032 /* Put cb_data in widget, so we can get at it when modifying menubar */
2033 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2035 /* final item, not a submenu */
2036 if (item
->call_data
&& ! item
->contents
)
2040 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2046 /* Callback called when keyboard traversal (started by x-menu-bar-open) ends.
2047 WMENU is the menu for which traversal has been done. DATA points to the
2048 frame for WMENU. We must release grabs, some bad interaction between GTK
2049 and Emacs makes the menus keep the grabs. */
2052 menu_nav_ended (wmenu
, data
)
2053 GtkMenuShell
*wmenu
;
2056 FRAME_PTR f
= (FRAME_PTR
) data
;
2058 if (FRAME_X_OUTPUT (f
)->menubar_widget
)
2060 GtkMenuShell
*w
= GTK_MENU_SHELL (FRAME_X_OUTPUT (f
)->menubar_widget
);
2061 Display
*dpy
= FRAME_X_DISPLAY (f
);
2064 gtk_menu_shell_deactivate (w
);
2065 gtk_menu_shell_deselect (w
);
2067 XUngrabKeyboard (dpy
, CurrentTime
);
2068 XUngrabPointer (dpy
, CurrentTime
);
2074 static GtkWidget
*create_menus
P_ ((widget_value
*, FRAME_PTR
, GCallback
,
2075 GCallback
, GCallback
, int, int, int,
2076 GtkWidget
*, xg_menu_cb_data
*, char *));
2078 /* Create a full menu tree specified by DATA.
2079 F is the frame the created menu belongs to.
2080 SELECT_CB is the callback to use when a menu item is selected.
2081 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2082 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2083 POP_UP_P is non-zero if we shall create a popup menu.
2084 MENU_BAR_P is non-zero if we shall create a menu bar.
2085 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2086 if MENU_BAR_P is non-zero.
2087 TOPMENU is the topmost GtkWidget that others shall be placed under.
2088 It may be NULL, in that case we create the appropriate widget
2089 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2090 CL_DATA is the callback data we shall use for this menu, or NULL
2091 if we haven't set the first callback yet.
2092 NAME is the name to give to the top level menu if this function
2093 creates it. May be NULL to not set any name.
2095 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2098 This function calls itself to create submenus. */
2101 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2102 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
2105 GCallback select_cb
;
2106 GCallback deactivate_cb
;
2107 GCallback highlight_cb
;
2112 xg_menu_cb_data
*cl_data
;
2116 GtkWidget
*wmenu
= topmenu
;
2117 GSList
*group
= NULL
;
2123 wmenu
= gtk_menu_new ();
2124 xg_set_screen (wmenu
, f
);
2125 /* Connect this to the menu instead of items so we get enter/leave for
2126 disabled items also. TODO: Still does not get enter/leave for
2127 disabled items in detached menus. */
2128 g_signal_connect (G_OBJECT (wmenu
),
2129 "enter-notify-event",
2130 G_CALLBACK (menuitem_highlight_callback
),
2132 g_signal_connect (G_OBJECT (wmenu
),
2133 "leave-notify-event",
2134 G_CALLBACK (menuitem_highlight_callback
),
2137 else wmenu
= gtk_menu_bar_new ();
2139 /* Fix up grabs after keyboard traversal ends. */
2140 g_signal_connect (G_OBJECT (wmenu
),
2142 G_CALLBACK (menu_nav_ended
),
2145 /* Put cl_data on the top menu for easier access. */
2146 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2147 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2148 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2149 G_CALLBACK (menu_destroy_callback
), cl_data
);
2152 gtk_widget_set_name (wmenu
, name
);
2155 g_signal_connect (G_OBJECT (wmenu
),
2156 "selection-done", deactivate_cb
, 0);
2158 g_signal_connect (G_OBJECT (wmenu
),
2159 "grab-notify", G_CALLBACK (menu_grab_callback
), 0);
2162 if (! menu_bar_p
&& add_tearoff_p
)
2164 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2165 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2167 g_signal_connect (G_OBJECT (tearoff
), "activate",
2168 G_CALLBACK (tearoff_activate
), 0);
2171 for (item
= data
; item
; item
= item
->next
)
2175 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2176 && !xg_separator_p (item
->name
))
2179 /* A title for a popup. We do the same as GTK does when
2180 creating titles, but it does not look good. */
2182 utf8_label
= get_utf8_string (item
->name
);
2184 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2185 w
= gtk_menu_item_new_with_label (utf8_label
);
2186 gtk_widget_set_sensitive (w
, FALSE
);
2187 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2189 else if (xg_separator_p (item
->name
))
2192 /* GTK only have one separator type. */
2193 w
= gtk_separator_menu_item_new ();
2197 w
= xg_create_one_menuitem (item
,
2199 item
->contents
? 0 : select_cb
,
2204 /* Create a possibly empty submenu for menu bar items, since some
2205 themes don't highlight items correctly without it. */
2206 if (item
->contents
|| menu_bar_p
)
2208 GtkWidget
*submenu
= create_menus (item
->contents
,
2219 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2223 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2224 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2230 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2231 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2232 with some text and buttons.
2233 F is the frame the created item belongs to.
2234 NAME is the name to use for the top widget.
2235 VAL is a widget_value structure describing items to be created.
2236 SELECT_CB is the callback to use when a menu item is selected or
2237 a dialog button is pressed.
2238 DEACTIVATE_CB is the callback to use when an item is deactivated.
2239 For a menu, when a sub menu is not shown anymore, for a dialog it is
2240 called when the dialog is popped down.
2241 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2243 Returns the widget created. */
2246 xg_create_widget (type
, name
, f
, val
,
2247 select_cb
, deactivate_cb
, highlight_cb
)
2252 GCallback select_cb
;
2253 GCallback deactivate_cb
;
2254 GCallback highlight_cb
;
2257 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2258 int pop_up_p
= strcmp (type
, "popup") == 0;
2260 if (strcmp (type
, "dialog") == 0)
2262 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2263 xg_set_screen (w
, f
);
2264 gtk_window_set_transient_for (GTK_WINDOW (w
),
2265 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2266 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2267 gtk_widget_set_name (w
, "emacs-dialog");
2268 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2270 else if (menu_bar_p
|| pop_up_p
)
2272 w
= create_menus (val
->contents
,
2284 /* Set the cursor to an arrow for popup menus when they are mapped.
2285 This is done by default for menu bar menus. */
2288 /* Must realize so the GdkWindow inside the widget is created. */
2289 gtk_widget_realize (w
);
2290 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2295 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2302 /* Return the label for menu item WITEM. */
2305 xg_get_menu_item_label (witem
)
2308 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2309 return gtk_label_get_label (wlabel
);
2312 /* Return non-zero if the menu item WITEM has the text LABEL. */
2315 xg_item_label_same_p (witem
, label
)
2320 char *utf8_label
= get_utf8_string (label
);
2321 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2323 if (! old_label
&& ! utf8_label
)
2325 else if (old_label
&& utf8_label
)
2326 is_same
= strcmp (utf8_label
, old_label
) == 0;
2328 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2333 /* Destroy widgets in LIST. */
2336 xg_destroy_widgets (list
)
2341 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2343 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2345 /* Destroying the widget will remove it from the container it is in. */
2346 gtk_widget_destroy (w
);
2350 /* Update the top level names in MENUBAR (i.e. not submenus).
2351 F is the frame the menu bar belongs to.
2352 *LIST is a list with the current menu bar names (menu item widgets).
2353 ITER is the item within *LIST that shall be updated.
2354 POS is the numerical position, starting at 0, of ITER in *LIST.
2355 VAL describes what the menu bar shall look like after the update.
2356 SELECT_CB is the callback to use when a menu item is selected.
2357 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2358 CL_DATA points to the callback data to be used for this menu bar.
2360 This function calls itself to walk through the menu bar names. */
2363 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2364 select_cb
, highlight_cb
, cl_data
)
2371 GCallback select_cb
;
2372 GCallback highlight_cb
;
2373 xg_menu_cb_data
*cl_data
;
2375 if (! iter
&& ! val
)
2377 else if (iter
&& ! val
)
2379 /* Item(s) have been removed. Remove all remaining items. */
2380 xg_destroy_widgets (iter
);
2386 else if (! iter
&& val
)
2388 /* Item(s) added. Add all new items in one call. */
2389 create_menus (val
, f
, select_cb
, 0, highlight_cb
,
2390 0, 1, 0, menubar
, cl_data
, 0);
2396 /* Below this neither iter or val is NULL */
2397 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2399 /* This item is still the same, check next item. */
2401 iter
= g_list_next (iter
);
2404 else /* This item is changed. */
2406 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2407 GtkMenuItem
*witem2
= 0;
2408 int val_in_menubar
= 0;
2409 int iter_in_new_menubar
= 0;
2413 /* See if the changed entry (val) is present later in the menu bar */
2415 iter2
&& ! val_in_menubar
;
2416 iter2
= g_list_next (iter2
))
2418 witem2
= GTK_MENU_ITEM (iter2
->data
);
2419 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2422 /* See if the current entry (iter) is present later in the
2423 specification for the new menu bar. */
2424 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2425 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2427 if (val_in_menubar
&& ! iter_in_new_menubar
)
2431 /* This corresponds to:
2436 gtk_widget_ref (GTK_WIDGET (witem
));
2437 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2438 gtk_widget_destroy (GTK_WIDGET (witem
));
2440 /* Must get new list since the old changed. */
2441 g_list_free (*list
);
2442 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2443 while (nr
-- > 0) iter
= g_list_next (iter
);
2445 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2447 /* This corresponds to:
2450 Rename B to X. This might seem to be a strange thing to do,
2451 since if there is a menu under B it will be totally wrong for X.
2452 But consider editing a C file. Then there is a C-mode menu
2453 (corresponds to B above).
2454 If then doing C-x C-f the minibuf menu (X above) replaces the
2455 C-mode menu. When returning from the minibuffer, we get
2456 back the C-mode menu. Thus we do:
2457 Rename B to X (C-mode to minibuf menu)
2458 Rename X to B (minibuf to C-mode menu).
2459 If the X menu hasn't been invoked, the menu under B
2460 is up to date when leaving the minibuffer. */
2461 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2462 char *utf8_label
= get_utf8_string (val
->name
);
2463 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2465 gtk_label_set_text (wlabel
, utf8_label
);
2467 /* If this item has a submenu that has been detached, change
2468 the title in the WM decorations also. */
2469 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2470 /* Set the title of the detached window. */
2471 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2473 iter
= g_list_next (iter
);
2477 else if (! val_in_menubar
&& iter_in_new_menubar
)
2479 /* This corresponds to:
2486 GtkWidget
*w
= xg_create_one_menuitem (val
,
2493 /* Create a possibly empty submenu for menu bar items, since some
2494 themes don't highlight items correctly without it. */
2495 GtkWidget
*submenu
= create_menus (NULL
, f
,
2496 select_cb
, NULL
, highlight_cb
,
2497 0, 0, 0, 0, cl_data
, 0);
2498 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2499 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2500 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2502 g_list_free (*list
);
2503 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2504 while (nr
-- > 0) iter
= g_list_next (iter
);
2505 iter
= g_list_next (iter
);
2509 else /* if (val_in_menubar && iter_in_new_menubar) */
2512 /* This corresponds to:
2517 gtk_widget_ref (GTK_WIDGET (witem2
));
2518 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2519 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2520 GTK_WIDGET (witem2
), pos
);
2521 gtk_widget_unref (GTK_WIDGET (witem2
));
2523 g_list_free (*list
);
2524 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2525 while (nr
-- > 0) iter
= g_list_next (iter
);
2526 if (iter
) iter
= g_list_next (iter
);
2532 /* Update the rest of the menu bar. */
2533 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2534 select_cb
, highlight_cb
, cl_data
);
2537 /* Update the menu item W so it corresponds to VAL.
2538 SELECT_CB is the callback to use when a menu item is selected.
2539 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2540 CL_DATA is the data to set in the widget for menu invokation. */
2543 xg_update_menu_item (val
, w
, select_cb
, highlight_cb
, cl_data
)
2546 GCallback select_cb
;
2547 GCallback highlight_cb
;
2548 xg_menu_cb_data
*cl_data
;
2555 const char *old_label
= 0;
2556 const char *old_key
= 0;
2557 xg_menu_item_cb_data
*cb_data
;
2559 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2560 utf8_label
= get_utf8_string (val
->name
);
2561 utf8_key
= get_utf8_string (val
->key
);
2563 /* See if W is a menu item with a key. See make_menu_item above. */
2564 if (GTK_IS_HBOX (wchild
))
2566 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2568 wlbl
= GTK_LABEL (list
->data
);
2569 wkey
= GTK_LABEL (list
->next
->data
);
2574 /* Remove the key and keep just the label. */
2575 gtk_widget_ref (GTK_WIDGET (wlbl
));
2576 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2577 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2582 else /* Just a label. */
2584 wlbl
= GTK_LABEL (wchild
);
2586 /* Check if there is now a key. */
2589 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2590 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2592 wlbl
= GTK_LABEL (list
->data
);
2593 wkey
= GTK_LABEL (list
->next
->data
);
2596 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2597 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2602 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2603 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2605 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2606 gtk_label_set_text (wkey
, utf8_key
);
2608 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2609 gtk_label_set_text (wlbl
, utf8_label
);
2611 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2612 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2614 if (! val
->enabled
&& GTK_WIDGET_SENSITIVE (w
))
2615 gtk_widget_set_sensitive (w
, FALSE
);
2616 else if (val
->enabled
&& ! GTK_WIDGET_SENSITIVE (w
))
2617 gtk_widget_set_sensitive (w
, TRUE
);
2619 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2623 cb_data
->call_data
= val
->call_data
;
2624 cb_data
->help
= val
->help
;
2625 cb_data
->cl_data
= cl_data
;
2627 /* We assume the callback functions don't change. */
2628 if (val
->call_data
&& ! val
->contents
)
2630 /* This item shall have a select callback. */
2631 if (! cb_data
->select_id
)
2633 = g_signal_connect (G_OBJECT (w
), "activate",
2634 select_cb
, cb_data
);
2636 else if (cb_data
->select_id
)
2638 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2639 cb_data
->select_id
= 0;
2644 /* Update the toggle menu item W so it corresponds to VAL. */
2647 xg_update_toggle_item (val
, w
)
2651 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2654 /* Update the radio menu item W so it corresponds to VAL. */
2657 xg_update_radio_item (val
, w
)
2661 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2664 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2665 SUBMENU may be NULL, in that case a new menu is created.
2666 F is the frame the menu bar belongs to.
2667 VAL describes the contents of the menu bar.
2668 SELECT_CB is the callback to use when a menu item is selected.
2669 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2670 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2671 CL_DATA is the call back data to use for any newly created items.
2673 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2677 xg_update_submenu (submenu
, f
, val
,
2678 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2682 GCallback select_cb
;
2683 GCallback deactivate_cb
;
2684 GCallback highlight_cb
;
2685 xg_menu_cb_data
*cl_data
;
2687 GtkWidget
*newsub
= submenu
;
2691 int has_tearoff_p
= 0;
2692 GList
*first_radio
= 0;
2695 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2697 for (cur
= val
, iter
= list
;
2699 iter
= g_list_next (iter
), cur
= cur
->next
)
2701 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2703 /* Skip tearoff items, they have no counterpart in val. */
2704 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2707 iter
= g_list_next (iter
);
2708 if (iter
) w
= GTK_WIDGET (iter
->data
);
2712 /* Remember first radio button in a group. If we get a mismatch in
2713 a radio group we must rebuild the whole group so that the connections
2714 in GTK becomes correct. */
2715 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2717 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2718 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2721 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2723 if (! xg_separator_p (cur
->name
))
2726 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2728 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2730 xg_update_toggle_item (cur
, w
);
2731 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2733 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2735 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2737 xg_update_radio_item (cur
, w
);
2738 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2740 else if (GTK_IS_MENU_ITEM (w
))
2742 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2745 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2746 xg_separator_p (cur
->name
))
2749 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2751 sub
= gtk_menu_item_get_submenu (witem
);
2752 if (sub
&& ! cur
->contents
)
2754 /* Not a submenu anymore. */
2755 gtk_widget_ref (sub
);
2756 gtk_menu_item_remove_submenu (witem
);
2757 gtk_widget_destroy (sub
);
2759 else if (cur
->contents
)
2763 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2764 select_cb
, deactivate_cb
,
2765 highlight_cb
, cl_data
);
2767 /* If this item just became a submenu, we must set it. */
2769 gtk_menu_item_set_submenu (witem
, nsub
);
2774 /* Structural difference. Remove everything from here and down
2780 /* Remove widgets from first structual change. */
2783 /* If we are adding new menu items below, we must remove from
2784 first radio button so that radio groups become correct. */
2785 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2786 else xg_destroy_widgets (iter
);
2791 /* More items added. Create them. */
2792 newsub
= create_menus (cur
,
2805 if (list
) g_list_free (list
);
2810 /* Update the MENUBAR.
2811 F is the frame the menu bar belongs to.
2812 VAL describes the contents of the menu bar.
2813 If DEEP_P is non-zero, rebuild all but the top level menu names in
2814 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2815 SELECT_CB is the callback to use when a menu item is selected.
2816 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2817 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2820 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2821 select_cb
, deactivate_cb
, highlight_cb
)
2826 GCallback select_cb
;
2827 GCallback deactivate_cb
;
2828 GCallback highlight_cb
;
2830 xg_menu_cb_data
*cl_data
;
2831 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2835 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2838 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2839 select_cb
, highlight_cb
, cl_data
);
2845 /* Update all sub menus.
2846 We must keep the submenus (GTK menu item widgets) since the
2847 X Window in the XEvent that activates the menu are those widgets. */
2849 /* Update cl_data, menu_item things in F may have changed. */
2850 update_cl_data (cl_data
, f
, highlight_cb
);
2852 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2859 /* Find sub menu that corresponds to val and update it. */
2860 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2862 witem
= GTK_MENU_ITEM (iter
->data
);
2863 if (xg_item_label_same_p (witem
, cur
->name
))
2865 sub
= gtk_menu_item_get_submenu (witem
);
2870 newsub
= xg_update_submenu (sub
,
2877 /* sub may still be NULL. If we just updated non deep and added
2878 a new menu bar item, it has no sub menu yet. So we set the
2879 newly created sub menu under witem. */
2882 xg_set_screen (newsub
, f
);
2883 gtk_menu_item_set_submenu (witem
, newsub
);
2889 gtk_widget_show_all (menubar
);
2892 /* Recompute all the widgets of frame F, when the menu bar has been
2893 changed. Value is non-zero if widgets were updated. */
2896 xg_update_frame_menubar (f
)
2899 struct x_output
*x
= f
->output_data
.x
;
2902 if (!x
->menubar_widget
|| GTK_WIDGET_MAPPED (x
->menubar_widget
))
2907 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2909 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2911 gtk_widget_show_all (x
->menubar_widget
);
2912 gtk_widget_size_request (x
->menubar_widget
, &req
);
2914 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2916 /* The height has changed, resize outer widget and set columns
2917 rows to what we had before adding the menu bar. */
2918 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2920 SET_FRAME_GARBAGED (f
);
2926 /* Get rid of the menu bar of frame F, and free its storage.
2927 This is used when deleting a frame, and when turning off the menu bar. */
2930 free_frame_menubar (f
)
2933 struct x_output
*x
= f
->output_data
.x
;
2935 if (x
->menubar_widget
)
2939 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2940 /* The menubar and its children shall be deleted when removed from
2942 x
->menubar_widget
= 0;
2943 FRAME_MENUBAR_HEIGHT (f
) = 0;
2945 /* The height has changed, resize outer widget and set columns
2946 rows to what we had before removing the menu bar. */
2947 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2949 SET_FRAME_GARBAGED (f
);
2956 /***********************************************************************
2957 Scroll bar functions
2958 ***********************************************************************/
2961 /* Setting scroll bar values invokes the callback. Use this variable
2962 to indicate that callback should do nothing. */
2964 int xg_ignore_gtk_scrollbar
;
2966 /* SET_SCROLL_BAR_X_WINDOW assumes the second argument fits in
2967 32 bits. But we want to store pointers, and they may be larger
2968 than 32 bits. Keep a mapping from integer index to widget pointers
2969 to get around the 32 bit limitation. */
2973 GtkWidget
**widgets
;
2978 /* Grow this much every time we need to allocate more */
2980 #define ID_TO_WIDGET_INCR 32
2982 /* Store the widget pointer W in id_to_widget and return the integer index. */
2985 xg_store_widget_in_map (w
)
2990 if (id_to_widget
.max_size
== id_to_widget
.used
)
2992 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
2994 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
2995 sizeof (GtkWidget
*)*new_size
);
2997 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
2998 id_to_widget
.widgets
[i
] = 0;
2999 id_to_widget
.max_size
= new_size
;
3002 /* Just loop over the array and find a free place. After all,
3003 how many scroll bars are we creating? Should be a small number.
3004 The check above guarantees we will find a free place. */
3005 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3007 if (! id_to_widget
.widgets
[i
])
3009 id_to_widget
.widgets
[i
] = w
;
3010 ++id_to_widget
.used
;
3016 /* Should never end up here */
3020 /* Remove pointer at IDX from id_to_widget.
3021 Called when scroll bar is destroyed. */
3024 xg_remove_widget_from_map (idx
)
3027 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3029 id_to_widget
.widgets
[idx
] = 0;
3030 --id_to_widget
.used
;
3034 /* Get the widget pointer at IDX from id_to_widget. */
3037 xg_get_widget_from_map (idx
)
3040 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3041 return id_to_widget
.widgets
[idx
];
3046 /* Return the scrollbar id for X Window WID on display DPY.
3047 Return -1 if WID not in id_to_widget. */
3050 xg_get_scroll_id_for_window (dpy
, wid
)
3057 w
= xg_win_to_widget (dpy
, wid
);
3061 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3062 if (id_to_widget
.widgets
[idx
] == w
)
3069 /* Callback invoked when scroll bar WIDGET is destroyed.
3070 DATA is the index into id_to_widget for WIDGET.
3071 We free pointer to last scroll bar values here and remove the index. */
3074 xg_gtk_scroll_destroy (widget
, data
)
3079 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
3081 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
3083 xg_remove_widget_from_map (id
);
3086 /* Callback for button press/release events. Used to start timer so that
3087 the scroll bar repetition timer in GTK gets handeled.
3088 Also, sets bar->dragging to Qnil when dragging (button release) is done.
3089 WIDGET is the scroll bar widget the event is for (not used).
3090 EVENT contains the event.
3091 USER_DATA points to the struct scrollbar structure.
3093 Returns FALSE to tell GTK that it shall continue propagate the event
3097 scroll_bar_button_cb (widget
, event
, user_data
)
3099 GdkEventButton
*event
;
3102 if (event
->type
== GDK_BUTTON_PRESS
&& ! xg_timer
)
3104 else if (event
->type
== GDK_BUTTON_RELEASE
)
3106 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
3107 if (xg_timer
) xg_stop_timer ();
3108 bar
->dragging
= Qnil
;
3114 /* Create a scroll bar widget for frame F. Store the scroll bar
3116 SCROLL_CALLBACK is the callback to invoke when the value of the
3118 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3119 to set resources for the widget. */
3122 xg_create_scroll_bar (f
, bar
, scroll_callback
, scroll_bar_name
)
3124 struct scroll_bar
*bar
;
3125 GCallback scroll_callback
;
3126 char *scroll_bar_name
;
3133 /* Page, step increment values are not so important here, they
3134 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3135 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3138 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3139 webox
= gtk_event_box_new ();
3140 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3141 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3143 scroll_id
= xg_store_widget_in_map (wscroll
);
3145 g_signal_connect (G_OBJECT (wscroll
),
3149 /* The EMACS_INT cast avoids a warning. */
3150 g_signal_connect (G_OBJECT (wscroll
),
3152 G_CALLBACK (xg_gtk_scroll_destroy
),
3153 (gpointer
) (EMACS_INT
) scroll_id
);
3155 /* Connect to button press and button release to detect if any scroll bar
3157 g_signal_connect (G_OBJECT (wscroll
),
3158 "button-press-event",
3159 G_CALLBACK (scroll_bar_button_cb
),
3161 g_signal_connect (G_OBJECT (wscroll
),
3162 "button-release-event",
3163 G_CALLBACK (scroll_bar_button_cb
),
3166 /* The scroll bar widget does not draw on a window of its own. Instead
3167 it draws on the parent window, in this case the edit widget. So
3168 whenever the edit widget is cleared, the scroll bar needs to redraw
3169 also, which causes flicker. Put an event box between the edit widget
3170 and the scroll bar, so the scroll bar instead draws itself on the
3171 event box window. */
3172 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3173 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3176 /* Set the cursor to an arrow. */
3177 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3179 SET_SCROLL_BAR_X_WINDOW (bar
, scroll_id
);
3182 /* Make the scroll bar represented by SCROLLBAR_ID visible. */
3185 xg_show_scroll_bar (scrollbar_id
)
3188 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3190 gtk_widget_show_all (gtk_widget_get_parent (w
));
3193 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3196 xg_remove_scroll_bar (f
, scrollbar_id
)
3200 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3203 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3204 gtk_widget_destroy (w
);
3205 gtk_widget_destroy (wparent
);
3206 SET_FRAME_GARBAGED (f
);
3210 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3212 TOP/LEFT are the new pixel positions where the bar shall appear.
3213 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3216 xg_update_scrollbar_pos (f
, scrollbar_id
, top
, left
, width
, height
)
3225 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3229 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3230 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3232 /* Move and resize to new values. */
3233 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3234 gtk_widget_set_size_request (wscroll
, width
, height
);
3235 gtk_widget_queue_draw (wparent
);
3236 gdk_window_process_all_updates ();
3237 /* GTK does not redraw until the main loop is entered again, but
3238 if there are no X events pending we will not enter it. So we sync
3239 here to get some events. */
3241 SET_FRAME_GARBAGED (f
);
3242 cancel_mouse_face (f
);
3246 /* Set the thumb size and position of scroll bar BAR. We are currently
3247 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3250 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
3251 struct scroll_bar
*bar
;
3252 int portion
, position
, whole
;
3254 GtkWidget
*wscroll
= xg_get_widget_from_map (SCROLL_BAR_X_WINDOW (bar
));
3256 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3258 if (wscroll
&& NILP (bar
->dragging
))
3267 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3269 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3270 rather than the real portion value. This makes the thumb less likely
3271 to resize and that looks better. */
3272 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3273 /* When the thumb is at the bottom, position == whole.
3274 So we need to increase `whole' to make space for the thumb. */
3281 top
= (gdouble
) position
/ whole
;
3282 shown
= (gdouble
) portion
/ whole
;
3285 size
= shown
* XG_SB_RANGE
;
3286 size
= min (size
, XG_SB_RANGE
);
3287 size
= max (size
, 1);
3289 value
= top
* XG_SB_RANGE
;
3290 value
= min (value
, XG_SB_MAX
- size
);
3291 value
= max (value
, XG_SB_MIN
);
3293 /* Assume all lines are of equal size. */
3294 new_step
= size
/ max (1, FRAME_LINES (f
));
3296 if ((int) adj
->page_size
!= size
3297 || (int) adj
->step_increment
!= new_step
)
3299 adj
->page_size
= size
;
3300 adj
->step_increment
= new_step
;
3301 /* Assume a page increment is about 95% of the page size */
3302 adj
->page_increment
= (int) (0.95*adj
->page_size
);
3306 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3308 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3312 /* gtk_range_set_value invokes the callback. Set
3313 ignore_gtk_scrollbar to make the callback do nothing */
3314 xg_ignore_gtk_scrollbar
= 1;
3316 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3317 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3319 gtk_adjustment_changed (adj
);
3321 xg_ignore_gtk_scrollbar
= 0;
3329 /***********************************************************************
3331 ***********************************************************************/
3332 /* The key for the data we put in the GtkImage widgets. The data is
3333 the image used by Emacs. We use this to see if we need to update
3334 the GtkImage with a new image. */
3335 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3337 /* The key for storing the latest modifiers so the activate callback can
3339 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3341 /* The key for storing the button widget in its proxy menu item. */
3342 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3344 /* The key for the data we put in the GtkImage widgets. The data is
3345 the stock name used by Emacs. We use this to see if we need to update
3346 the GtkImage with a new image. */
3347 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3349 /* As above, but this is used for named theme widgets, as opposed to
3351 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3353 /* Callback function invoked when a tool bar item is pressed.
3354 W is the button widget in the tool bar that got pressed,
3355 CLIENT_DATA is an integer that is the index of the button in the
3356 tool bar. 0 is the first button. */
3359 xg_tool_bar_button_cb (widget
, event
, user_data
)
3361 GdkEventButton
*event
;
3364 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3365 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3366 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3371 /* Callback function invoked when a tool bar item is pressed.
3372 W is the button widget in the tool bar that got pressed,
3373 CLIENT_DATA is an integer that is the index of the button in the
3374 tool bar. 0 is the first button. */
3377 xg_tool_bar_callback (w
, client_data
)
3379 gpointer client_data
;
3381 /* The EMACS_INT cast avoids a warning. */
3382 int idx
= (int) (EMACS_INT
) client_data
;
3383 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3384 XG_TOOL_BAR_LAST_MODIFIER
);
3386 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3387 Lisp_Object key
, frame
;
3388 struct input_event event
;
3391 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3394 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3396 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3397 XSETFRAME (frame
, f
);
3399 /* We generate two events here. The first one is to set the prefix
3400 to `(tool_bar)', see keyboard.c. */
3401 event
.kind
= TOOL_BAR_EVENT
;
3402 event
.frame_or_window
= frame
;
3404 kbd_buffer_store_event (&event
);
3406 event
.kind
= TOOL_BAR_EVENT
;
3407 event
.frame_or_window
= frame
;
3409 /* Convert between the modifier bits GDK uses and the modifier bits
3410 Emacs uses. This assumes GDK an X masks are the same, which they are when
3412 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3413 kbd_buffer_store_event (&event
);
3416 /* Callback function invoked when a tool bar item is pressed in a detached
3417 tool bar or the overflow drop down menu.
3418 We just call xg_tool_bar_callback.
3419 W is the menu item widget that got pressed,
3420 CLIENT_DATA is an integer that is the index of the button in the
3421 tool bar. 0 is the first button. */
3424 xg_tool_bar_proxy_callback (w
, client_data
)
3426 gpointer client_data
;
3428 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3429 XG_TOOL_BAR_PROXY_BUTTON
));
3430 xg_tool_bar_callback (wbutton
, client_data
);
3433 /* This callback is called when a tool item should create a proxy item,
3434 such as for the overflow menu. Also called when the tool bar is detached.
3435 If we don't create a proxy menu item, the detached tool bar will be
3439 xg_tool_bar_menu_proxy (toolitem
, user_data
)
3440 GtkToolItem
*toolitem
;
3443 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (toolitem
));
3444 GtkButton
*wbutton
= GTK_BUTTON (gtk_bin_get_child (GTK_BIN (weventbox
)));
3445 GtkWidget
*wmenuitem
= gtk_image_menu_item_new ();
3446 GtkWidget
*wmenuimage
;
3448 if (gtk_button_get_use_stock (wbutton
))
3449 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3450 GTK_ICON_SIZE_MENU
);
3453 GtkImage
*wimage
= GTK_IMAGE (gtk_bin_get_child (GTK_BIN (wbutton
)));
3454 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3455 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3456 if (store_type
== GTK_IMAGE_STOCK
)
3459 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3460 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3462 else if (store_type
== GTK_IMAGE_ICON_SET
)
3464 GtkIconSet
*icon_set
;
3465 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3466 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3467 GTK_ICON_SIZE_MENU
);
3469 else if (store_type
== GTK_IMAGE_PIXBUF
)
3474 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3477 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3479 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3480 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3481 GDK_INTERP_BILINEAR
);
3483 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3488 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3490 g_signal_connect (G_OBJECT (wmenuitem
),
3492 GTK_SIGNAL_FUNC (xg_tool_bar_proxy_callback
),
3495 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3496 (gpointer
) wbutton
);
3497 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3502 /* This callback is called when a tool bar is detached. We must set
3503 the height of the tool bar to zero when this happens so frame sizes
3504 are correctly calculated.
3505 WBOX is the handle box widget that enables detach/attach of the tool bar.
3506 W is the tool bar widget.
3507 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3510 xg_tool_bar_detach_callback (wbox
, w
, client_data
)
3513 gpointer client_data
;
3515 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3516 extern int x_gtk_whole_detached_tool_bar
;
3518 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3523 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3525 /* When detaching a tool bar, not everything dissapear. There are
3526 a few pixels left that are used to drop the tool bar back into
3528 FRAME_TOOLBAR_HEIGHT (f
) = 2;
3530 /* The height has changed, resize outer widget and set columns
3531 rows to what we had before detaching the tool bar. */
3532 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3536 /* This callback is called when a tool bar is reattached. We must set
3537 the height of the tool bar when this happens so frame sizes
3538 are correctly calculated.
3539 WBOX is the handle box widget that enables detach/attach of the tool bar.
3540 W is the tool bar widget.
3541 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3544 xg_tool_bar_attach_callback (wbox
, w
, client_data
)
3547 gpointer client_data
;
3549 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3550 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3556 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3558 gtk_widget_size_request (w
, &req
);
3559 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3561 /* The height has changed, resize outer widget and set columns
3562 rows to what we had before attaching the tool bar. */
3563 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3567 /* This callback is called when the mouse enters or leaves a tool bar item.
3568 It is used for displaying and hiding the help text.
3569 W is the tool bar item, a button.
3570 EVENT is either an enter event or leave event.
3571 CLIENT_DATA is an integer that is the index of the button in the
3572 tool bar. 0 is the first button.
3574 Returns FALSE to tell GTK to keep processing this event. */
3577 xg_tool_bar_help_callback (w
, event
, client_data
)
3579 GdkEventCrossing
*event
;
3580 gpointer client_data
;
3582 /* The EMACS_INT cast avoids a warning. */
3583 int idx
= (int) (EMACS_INT
) client_data
;
3584 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3585 Lisp_Object help
, frame
;
3587 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3590 if (event
->type
== GDK_ENTER_NOTIFY
)
3592 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3593 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3596 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3601 XSETFRAME (frame
, f
);
3602 kbd_buffer_store_help_event (frame
, help
);
3608 /* This callback is called when a tool bar item shall be redrawn.
3609 It modifies the expose event so that the GtkImage widget redraws the
3610 whole image. This to overcome a bug that makes GtkImage draw the image
3611 in the wrong place when it tries to redraw just a part of the image.
3612 W is the GtkImage to be redrawn.
3613 EVENT is the expose event for W.
3614 CLIENT_DATA is unused.
3616 Returns FALSE to tell GTK to keep processing this event. */
3619 xg_tool_bar_item_expose_callback (w
, event
, client_data
)
3621 GdkEventExpose
*event
;
3622 gpointer client_data
;
3626 gdk_drawable_get_size (event
->window
, &width
, &height
);
3628 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3629 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3631 event
->area
.x
= max (0, event
->area
.x
);
3632 event
->area
.y
= max (0, event
->area
.y
);
3634 event
->area
.width
= max (width
, event
->area
.width
);
3635 event
->area
.height
= max (height
, event
->area
.height
);
3640 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3642 /* This callback is called when a tool bar shall be redrawn.
3643 We need to update the images in case the image cache
3644 has deleted the pixmaps used in the tool bar.
3645 W is the GtkToolbar to be redrawn.
3646 EVENT is the expose event for W.
3647 CLIENT_DATA is pointing to the frame for this tool bar.
3649 Returns FALSE to tell GTK to keep processing this event. */
3652 xg_tool_bar_expose_callback (w
, event
, client_data
)
3654 GdkEventExpose
*event
;
3655 gpointer client_data
;
3657 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3658 SET_FRAME_GARBAGED (f
);
3662 /* Create a tool bar for frame F. */
3665 xg_create_tool_bar (f
)
3668 struct x_output
*x
= f
->output_data
.x
;
3670 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3672 x
->toolbar_widget
= gtk_toolbar_new ();
3673 x
->handlebox_widget
= gtk_handle_box_new ();
3674 x
->toolbar_detached
= 0;
3676 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3679 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3682 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3685 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3687 /* We only have icons, so override any user setting. We could
3688 use the caption property of the toolbar item (see update_frame_tool_bar
3689 below), but some of those strings are long, making the toolbar so
3690 long it does not fit on the screen. The GtkToolbar widget makes every
3691 item equal size, so the longest caption determine the size of every
3692 tool bar item. I think the creators of the GtkToolbar widget
3693 counted on 4 or 5 character long strings. */
3694 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3695 gtk_toolbar_set_orientation (GTK_TOOLBAR (x
->toolbar_widget
),
3696 GTK_ORIENTATION_HORIZONTAL
);
3698 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3699 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3700 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3701 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3702 g_signal_connect (G_OBJECT (x
->toolbar_widget
),
3704 G_CALLBACK (xg_tool_bar_expose_callback
),
3707 gtk_widget_show_all (x
->handlebox_widget
);
3709 gtk_widget_size_request (x
->toolbar_widget
, &req
);
3710 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3712 /* The height has changed, resize outer widget and set columns
3713 rows to what we had before adding the tool bar. */
3714 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3716 SET_FRAME_GARBAGED (f
);
3719 /* Find the right-to-left image named by RTL in the tool bar images for F.
3720 Returns IMAGE if RTL is not found. */
3723 find_rtl_image (f
, image
, rtl
)
3729 Lisp_Object file
, rtl_name
;
3730 struct gcpro gcpro1
, gcpro2
;
3731 GCPRO2 (file
, rtl_name
);
3733 rtl_name
= Ffile_name_nondirectory (rtl
);
3735 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3737 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3738 if (!NILP (file
= file_for_image (rtl_image
)))
3740 file
= call1 (intern ("file-name-sans-extension"),
3741 Ffile_name_nondirectory (file
));
3742 if (EQ (Fequal (file
, rtl_name
), Qt
))
3753 /* Update the tool bar for frame F. Add new buttons and remove old. */
3756 update_frame_tool_bar (f
)
3760 GtkRequisition old_req
, new_req
;
3761 struct x_output
*x
= f
->output_data
.x
;
3762 int hmargin
= 0, vmargin
= 0;
3763 GtkToolbar
*wtoolbar
;
3765 GtkTextDirection dir
;
3767 if (! FRAME_GTK_WIDGET (f
))
3772 if (INTEGERP (Vtool_bar_button_margin
)
3773 && XINT (Vtool_bar_button_margin
) > 0)
3775 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3776 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3778 else if (CONSP (Vtool_bar_button_margin
))
3780 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3781 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3782 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3784 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3785 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3786 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3789 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3790 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3791 i.e. zero. This means that margins less than
3792 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3793 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3794 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3796 if (! x
->toolbar_widget
)
3797 xg_create_tool_bar (f
);
3799 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
3800 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &old_req
);
3801 dir
= gtk_widget_get_direction (x
->toolbar_widget
);
3803 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3806 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3807 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3811 struct image
*img
= NULL
;
3814 GtkStockItem stock_item
;
3815 char *stock_name
= NULL
;
3816 char *icon_name
= NULL
;
3818 GtkWidget
*wbutton
= NULL
;
3819 GtkWidget
*weventbox
;
3820 Lisp_Object func
= intern ("x-gtk-map-stock");
3822 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (x
->toolbar_widget
), i
);
3826 weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3827 wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3830 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3832 /* Ignore invalid image specifications. */
3833 if (!valid_image_p (image
))
3835 if (wbutton
) gtk_widget_hide (wbutton
);
3839 if (EQ (Qt
, Ffboundp (func
)))
3840 stock
= call1 (func
, file_for_image (image
));
3842 if (! NILP (stock
) && STRINGP (stock
))
3844 stock_name
= SSDATA (stock
);
3845 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
3847 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
3848 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
3850 icon_name
= stock_name
+ 2;
3854 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
3857 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3859 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
3860 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3868 if (stock_name
== NULL
&& icon_name
== NULL
)
3870 /* No stock image, or stock item not known. Try regular image. */
3872 /* If image is a vector, choose the image according to the
3874 if (dir
== GTK_TEXT_DIR_RTL
3875 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
3878 image
= find_rtl_image (f
, image
, rtl
);
3881 if (VECTORP (image
))
3885 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3886 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3889 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3890 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3892 xassert (ASIZE (image
) >= idx
);
3893 image
= AREF (image
, idx
);
3898 img_id
= lookup_image (f
, image
);
3899 img
= IMAGE_FROM_ID (f
, img_id
);
3900 prepare_image_for_display (f
, img
);
3902 if (img
->load_failed_p
|| img
->pixmap
== None
)
3905 gtk_widget_hide_all (GTK_WIDGET (ti
));
3908 /* Insert an empty (non-image) button */
3909 weventbox
= gtk_event_box_new ();
3910 wbutton
= gtk_button_new ();
3911 gtk_button_set_focus_on_click (GTK_BUTTON (wbutton
), FALSE
);
3912 gtk_button_set_relief (GTK_BUTTON (wbutton
),
3914 gtk_container_add (GTK_CONTAINER (weventbox
), wbutton
);
3915 ti
= gtk_tool_item_new ();
3916 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
3917 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
), ti
, -1);
3928 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
3929 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
3930 (gpointer
) xstrdup (stock_name
),
3931 (GDestroyNotify
) xfree
);
3935 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
3936 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
3937 (gpointer
) xstrdup (icon_name
),
3938 (GDestroyNotify
) xfree
);
3942 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
3943 /* Save the image so we can see if an update is needed when
3944 this function is called again. */
3945 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
3946 (gpointer
)img
->pixmap
);
3949 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
3950 wbutton
= gtk_button_new ();
3951 gtk_button_set_focus_on_click (GTK_BUTTON (wbutton
), FALSE
);
3952 gtk_button_set_relief (GTK_BUTTON (wbutton
), GTK_RELIEF_NONE
);
3953 gtk_container_add (GTK_CONTAINER (wbutton
), w
);
3954 weventbox
= gtk_event_box_new ();
3955 gtk_container_add (GTK_CONTAINER (weventbox
), wbutton
);
3956 ti
= gtk_tool_item_new ();
3957 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
3958 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
), ti
, -1);
3961 /* The EMACS_INT cast avoids a warning. */
3962 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
3963 GTK_SIGNAL_FUNC (xg_tool_bar_menu_proxy
),
3964 (gpointer
) (EMACS_INT
) i
);
3966 g_signal_connect (G_OBJECT (wbutton
), "clicked",
3967 GTK_SIGNAL_FUNC (xg_tool_bar_callback
),
3968 (gpointer
) (EMACS_INT
) i
);
3970 gtk_widget_show_all (GTK_WIDGET (ti
));
3973 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
3975 /* Catch expose events to overcome an annoying redraw bug, see
3976 comment for xg_tool_bar_item_expose_callback. */
3977 g_signal_connect (G_OBJECT (ti
),
3979 G_CALLBACK (xg_tool_bar_item_expose_callback
),
3982 gtk_widget_set_sensitive (wbutton
, enabled_p
);
3983 gtk_tool_item_set_homogeneous (ti
, FALSE
);
3985 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
3986 no distinction based on modifiers in the activate callback,
3987 so we have to do it ourselves. */
3988 g_signal_connect (wbutton
, "button-release-event",
3989 GTK_SIGNAL_FUNC (xg_tool_bar_button_cb
),
3992 g_object_set_data (G_OBJECT (wbutton
), XG_FRAME_DATA
, (gpointer
)f
);
3994 /* Use enter/leave notify to show help. We use the events
3995 rather than the GtkButton specific signals "enter" and
3996 "leave", so we can have only one callback. The event
3997 will tell us what kind of event it is. */
3998 /* The EMACS_INT cast avoids a warning. */
3999 g_signal_connect (G_OBJECT (weventbox
),
4000 "enter-notify-event",
4001 G_CALLBACK (xg_tool_bar_help_callback
),
4002 (gpointer
) (EMACS_INT
) i
);
4003 g_signal_connect (G_OBJECT (weventbox
),
4004 "leave-notify-event",
4005 G_CALLBACK (xg_tool_bar_help_callback
),
4006 (gpointer
) (EMACS_INT
) i
);
4010 GtkWidget
*wimage
= gtk_bin_get_child (GTK_BIN (wbutton
));
4011 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
4012 XG_TOOL_BAR_IMAGE_DATA
);
4013 gpointer old_stock_name
= g_object_get_data (G_OBJECT (wimage
),
4014 XG_TOOL_BAR_STOCK_NAME
);
4015 gpointer old_icon_name
= g_object_get_data (G_OBJECT (wimage
),
4016 XG_TOOL_BAR_ICON_NAME
);
4018 (! old_stock_name
|| strcmp (old_stock_name
, stock_name
) != 0))
4020 gtk_image_set_from_stock (GTK_IMAGE (wimage
),
4021 stock_name
, icon_size
);
4022 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4023 (gpointer
) xstrdup (stock_name
),
4024 (GDestroyNotify
) xfree
);
4025 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4027 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
, NULL
);
4029 else if (icon_name
&&
4030 (! old_icon_name
|| strcmp (old_icon_name
, icon_name
) != 0))
4032 gtk_image_set_from_icon_name (GTK_IMAGE (wimage
),
4033 icon_name
, icon_size
);
4034 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4035 (gpointer
) xstrdup (icon_name
),
4036 (GDestroyNotify
) xfree
);
4037 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4039 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4042 else if (img
&& old_img
!= img
->pixmap
)
4044 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
4045 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4046 (gpointer
)img
->pixmap
);
4048 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4050 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
, NULL
);
4053 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
4055 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4056 gtk_widget_show_all (GTK_WIDGET (ti
));
4062 /* Remove buttons not longer needed. We just hide them so they
4063 can be reused later on. */
4066 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (x
->toolbar_widget
), i
++);
4067 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
4068 } while (ti
!= NULL
);
4070 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &new_req
);
4071 if (old_req
.height
!= new_req
.height
4072 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
4074 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
4075 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
4081 /* Deallocate all resources for the tool bar on frame F.
4082 Remove the tool bar. */
4085 free_frame_tool_bar (f
)
4088 struct x_output
*x
= f
->output_data
.x
;
4090 if (x
->toolbar_widget
)
4093 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4094 x
->handlebox_widget
);
4095 x
->toolbar_widget
= 0;
4096 x
->handlebox_widget
= 0;
4097 FRAME_TOOLBAR_HEIGHT (f
) = 0;
4099 /* The height has changed, resize outer widget and set columns
4100 rows to what we had before removing the tool bar. */
4101 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
4103 SET_FRAME_GARBAGED (f
);
4110 /***********************************************************************
4112 ***********************************************************************/
4116 GtkBindingSet
*binding_set
;
4119 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4120 we keep it permanently linked in. */
4123 xg_ignore_gtk_scrollbar
= 0;
4124 xg_detached_menus
= 0;
4125 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4126 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4128 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4129 id_to_widget
.widgets
= 0;
4131 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4132 bindings. It doesn't seem to be any way to remove properties,
4133 so we set it to VoidSymbol which in X means "no key". */
4134 gtk_settings_set_string_property (gtk_settings_get_default (),
4135 "gtk-menu-bar-accel",
4139 /* Make GTK text input widgets use Emacs style keybindings. This is
4141 gtk_settings_set_string_property (gtk_settings_get_default (),
4142 "gtk-key-theme-name",
4146 /* Make dialogs close on C-g. Since file dialog inherits from
4147 dialog, this works for them also. */
4148 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_DIALOG
));
4149 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4152 /* Make menus close on C-g. */
4153 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_MENU_SHELL
));
4154 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4158 #endif /* USE_GTK */
4160 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
4161 (do not change this comment) */