1 /* Functions for creating and updating GTK widgets.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
29 #include "blockinput.h"
30 #include "syssignal.h"
34 #include "termhooks.h"
38 #include <gdk/gdkkeysyms.h>
41 #include <X11/Xft/Xft.h>
44 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
45 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
47 /* Avoid "differ in sign" warnings */
48 #define SSDATA(x) ((char *) SDATA (x))
51 /***********************************************************************
52 Display handling functions
53 ***********************************************************************/
55 #ifdef HAVE_GTK_MULTIDISPLAY
57 /* Keep track of the default display, or NULL if there is none. Emacs
58 may close all its displays. */
60 static GdkDisplay
*gdpy_def
;
62 /* Return the GdkDisplay that corresponds to the X display DPY. */
65 xg_get_gdk_display (dpy
)
68 return gdk_x11_lookup_xdisplay (dpy
);
71 /* When the GTK widget W is to be created on a display for F that
72 is not the default display, set the display for W.
73 W can be a GtkMenu or a GtkWindow widget. */
80 if (FRAME_X_DISPLAY (f
) != GDK_DISPLAY ())
82 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
83 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
86 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
88 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
93 #else /* not HAVE_GTK_MULTIDISPLAY */
95 /* Make some defines so we can use the GTK 2.2 functions when
96 compiling with GTK 2.0. */
98 #define xg_set_screen(w, f)
99 #define gdk_xid_table_lookup_for_display(dpy, w) gdk_xid_table_lookup (w)
100 #define gdk_pixmap_foreign_new_for_display(dpy, p) gdk_pixmap_foreign_new (p)
101 #define gdk_cursor_new_for_display(dpy, c) gdk_cursor_new (c)
102 #define gdk_x11_lookup_xdisplay(dpy) 0
103 #define GdkDisplay void
105 #endif /* not HAVE_GTK_MULTIDISPLAY */
107 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
108 *DPY is set to NULL if the display can't be opened.
110 Returns non-zero if display could be opened, zero if display could not
111 be opened, and less than zero if the GTK version doesn't support
115 xg_display_open (display_name
, dpy
)
119 #ifdef HAVE_GTK_MULTIDISPLAY
122 gdpy
= gdk_display_open (display_name
);
123 if (!gdpy_def
&& gdpy
)
126 gdk_display_manager_set_default_display (gdk_display_manager_get (),
130 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
133 #else /* not HAVE_GTK_MULTIDISPLAY */
136 #endif /* not HAVE_GTK_MULTIDISPLAY */
140 /* Close display DPY. */
143 xg_display_close (Display
*dpy
)
145 #ifdef HAVE_GTK_MULTIDISPLAY
146 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
148 /* If this is the default display, try to change it before closing.
149 If there is no other display to use, gdpy_def is set to NULL, and
150 the next call to xg_display_open resets the default display. */
151 if (gdk_display_get_default () == gdpy
)
153 struct x_display_info
*dpyinfo
;
154 GdkDisplay
*gdpy_new
= NULL
;
156 /* Find another display. */
157 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
158 if (dpyinfo
->display
!= dpy
)
160 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
161 gdk_display_manager_set_default_display (gdk_display_manager_get (),
168 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
169 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
170 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
171 can continue running, but there will be memory leaks. */
172 g_object_run_dispose (G_OBJECT (gdpy
));
174 /* This seems to be fixed in GTK 2.10. */
175 gdk_display_close (gdpy
);
177 #endif /* HAVE_GTK_MULTIDISPLAY */
181 /***********************************************************************
183 ***********************************************************************/
184 /* The timer for scroll bar repetition and menu bar timeouts.
185 NULL if no timer is started. */
186 static struct atimer
*xg_timer
;
189 /* The next two variables and functions are taken from lwlib. */
190 static widget_value
*widget_value_free_list
;
191 static int malloc_cpt
;
193 /* Allocate a widget_value structure, either by taking one from the
194 widget_value_free_list or by malloc:ing a new one.
196 Return a pointer to the allocated structure. */
199 malloc_widget_value ()
202 if (widget_value_free_list
)
204 wv
= widget_value_free_list
;
205 widget_value_free_list
= wv
->free_list
;
210 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
213 memset (wv
, 0, sizeof (widget_value
));
217 /* This is analogous to free. It frees only what was allocated
218 by malloc_widget_value, and no substructures. */
221 free_widget_value (wv
)
229 /* When the number of already allocated cells is too big,
236 wv
->free_list
= widget_value_free_list
;
237 widget_value_free_list
= wv
;
242 /* Create and return the cursor to be used for popup menus and
243 scroll bars on display DPY. */
246 xg_create_default_cursor (dpy
)
249 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
250 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
253 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
256 xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
)
261 int x
, y
, width
, height
, rowstride
, mask_rowstride
;
262 GdkPixbuf
*icon_buf
, *tmp_buf
;
266 gdk_drawable_get_size (gpix
, &width
, &height
);
267 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
268 0, 0, 0, 0, width
, height
);
269 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
270 g_object_unref (G_OBJECT (tmp_buf
));
274 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
279 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
280 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
281 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
282 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
285 for (y
= 0; y
< height
; ++y
)
287 guchar
*iconptr
, *maskptr
;
290 iconptr
= pixels
+ y
* rowstride
;
291 maskptr
= mask_pixels
+ y
* mask_rowstride
;
293 for (x
= 0; x
< width
; ++x
)
295 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
296 just R is sufficient. */
298 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
300 iconptr
+= rowstride
/width
;
301 maskptr
+= mask_rowstride
/width
;
305 g_object_unref (G_OBJECT (mask_buf
));
312 file_for_image (image
)
315 Lisp_Object specified_file
= Qnil
;
317 extern Lisp_Object QCfile
;
319 for (tail
= XCDR (image
);
320 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
321 tail
= XCDR (XCDR (tail
)))
322 if (EQ (XCAR (tail
), QCfile
))
323 specified_file
= XCAR (XCDR (tail
));
325 return specified_file
;
328 /* For the image defined in IMG, make and return a GtkImage. For displays with
329 8 planes or less we must make a GdkPixbuf and apply the mask manually.
330 Otherwise the highlightning and dimming the tool bar code in GTK does
331 will look bad. For display with more than 8 planes we just use the
332 pixmap and mask directly. For monochrome displays, GTK doesn't seem
333 able to use external pixmaps, it looks bad whatever we do.
334 The image is defined on the display where frame F is.
335 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
336 If OLD_WIDGET is NULL, a new widget is constructed and returned.
337 If OLD_WIDGET is not NULL, that widget is modified. */
340 xg_get_image_for_pixmap (f
, img
, widget
, old_widget
)
344 GtkImage
*old_widget
;
352 /* If we have a file, let GTK do all the image handling.
353 This seems to be the only way to make insensitive and activated icons
354 look good in all cases. */
355 Lisp_Object specified_file
= file_for_image (img
->spec
);
358 /* We already loaded the image once before calling this
359 function, so this only fails if the image file has been removed.
360 In that case, use the pixmap already loaded. */
362 if (STRINGP (specified_file
)
363 && STRINGP (file
= x_find_image_file (specified_file
)))
366 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
368 gtk_image_set_from_file (old_widget
, SSDATA (file
));
370 return GTK_WIDGET (old_widget
);
373 /* No file, do the image handling ourselves. This will look very bad
374 on a monochrome display, and sometimes bad on all displays with
377 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
378 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
379 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
381 /* This is a workaround to make icons look good on pseudo color
382 displays. Apparently GTK expects the images to have an alpha
383 channel. If they don't, insensitive and activated icons will
384 look bad. This workaround does not work on monochrome displays,
385 and is strictly not needed on true color/static color displays (i.e.
386 16 bits and higher). But we do it anyway so we get a pixbuf that is
387 not associated with the img->pixmap. The img->pixmap may be removed
388 by clearing the image cache and then the tool bar redraw fails, since
389 Gtk+ assumes the pixmap is always there. */
390 cmap
= gtk_widget_get_colormap (widget
);
391 icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
394 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
396 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
398 g_object_unref (G_OBJECT (icon_buf
));
400 g_object_unref (G_OBJECT (gpix
));
401 if (gmask
) g_object_unref (G_OBJECT (gmask
));
403 return GTK_WIDGET (old_widget
);
407 /* Set CURSOR on W and all widgets W contain. We must do like this
408 for scroll bars and menu because they create widgets internally,
409 and it is those widgets that are visible. */
412 xg_set_cursor (w
, cursor
)
416 GList
*children
= gdk_window_peek_children (w
->window
);
418 gdk_window_set_cursor (w
->window
, cursor
);
420 /* The scroll bar widget has more than one GDK window (had to look at
421 the source to figure this out), and there is no way to set cursor
422 on widgets in GTK. So we must set the cursor for all GDK windows.
425 for ( ; children
; children
= g_list_next (children
))
426 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
429 /* Timer function called when a timeout occurs for xg_timer.
430 This function processes all GTK events in a recursive event loop.
431 This is done because GTK timer events are not seen by Emacs event
432 detection, Emacs only looks for X events. When a scroll bar has the
433 pointer (detected by button press/release events below) an Emacs
434 timer is started, and this function can then check if the GTK timer
435 has expired by calling the GTK event loop.
436 Also, when a menu is active, it has a small timeout before it
437 pops down the sub menu under it. */
440 xg_process_timeouts (timer
)
441 struct atimer
*timer
;
444 /* Ideally we would like to just handle timer events, like the Xt version
445 of this does in xterm.c, but there is no such feature in GTK. */
446 while (gtk_events_pending ())
447 gtk_main_iteration ();
451 /* Start the xg_timer with an interval of 0.1 seconds, if not already started.
452 xg_process_timeouts is called when the timer expires. The timer
453 started is continuous, i.e. runs until xg_stop_timer is called. */
461 EMACS_SET_SECS_USECS (interval
, 0, 100000);
462 xg_timer
= start_atimer (ATIMER_CONTINUOUS
,
469 /* Stop the xg_timer if started. */
476 cancel_atimer (xg_timer
);
481 /* Insert NODE into linked LIST. */
484 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
486 xg_list_node
*list_start
= list
->next
;
488 if (list_start
) list_start
->prev
= node
;
489 node
->next
= list_start
;
494 /* Remove NODE from linked LIST. */
497 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
499 xg_list_node
*list_start
= list
->next
;
500 if (node
== list_start
)
502 list
->next
= node
->next
;
503 if (list
->next
) list
->next
->prev
= 0;
507 node
->prev
->next
= node
->next
;
508 if (node
->next
) node
->next
->prev
= node
->prev
;
512 /* Allocate and return a utf8 version of STR. If STR is already
513 utf8 or NULL, just return STR.
514 If not, a new string is allocated and the caller must free the result
518 get_utf8_string (str
)
521 char *utf8_str
= str
;
523 if (!str
) return NULL
;
525 /* If not UTF-8, try current locale. */
526 if (!g_utf8_validate (str
, -1, NULL
))
527 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
531 /* Probably some control characters in str. Escape them. */
535 unsigned char *p
= (unsigned char *)str
;
537 GError
*error
= NULL
;
539 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
540 &bytes_written
, &error
))
541 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
544 p
+= bytes_written
+1;
545 g_error_free (error
);
551 g_error_free (error
);
556 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
557 p
= (unsigned char *)str
;
559 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
560 &bytes_written
, &error
))
561 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
563 strncpy (up
, (char *)p
, bytes_written
);
564 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
565 up
[bytes_written
+4] = '\0';
566 up
+= bytes_written
+4;
567 p
+= bytes_written
+1;
568 g_error_free (error
);
574 strcat (utf8_str
, cp
);
579 g_error_free (error
);
588 /***********************************************************************
589 General functions for creating widgets, resizing, events, e.t.c.
590 ***********************************************************************/
592 /* Make a geometry string and pass that to GTK. It seems this is the
593 only way to get geometry position right if the user explicitly
594 asked for a position when starting Emacs.
595 F is the frame we shall set geometry for. */
601 if (f
->size_hint_flags
& USPosition
)
603 int left
= f
->left_pos
;
604 int xneg
= f
->size_hint_flags
& XNegative
;
605 int top
= f
->top_pos
;
606 int yneg
= f
->size_hint_flags
& YNegative
;
614 sprintf (geom_str
, "=%dx%d%c%d%c%d",
615 FRAME_PIXEL_WIDTH (f
),
616 FRAME_TOTAL_PIXEL_HEIGHT (f
),
617 (xneg
? '-' : '+'), left
,
618 (yneg
? '-' : '+'), top
);
620 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
622 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
624 else if (f
->size_hint_flags
& PPosition
)
625 gtk_window_move (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
626 f
->left_pos
, f
->top_pos
);
629 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
630 and a Gtk+ menu bar, we get resize events for the edit part of the
631 frame only. We let Gtk+ deal with the Gtk+ parts.
632 F is the frame to resize.
633 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
636 xg_frame_resized (f
, pixelwidth
, pixelheight
)
638 int pixelwidth
, pixelheight
;
642 if (pixelwidth
== -1 && pixelheight
== -1)
644 if (FRAME_GTK_WIDGET (f
) && GTK_WIDGET_MAPPED (FRAME_GTK_WIDGET (f
)))
645 gdk_window_get_geometry(FRAME_GTK_WIDGET (f
)->window
, 0, 0,
646 &pixelwidth
, &pixelheight
, 0);
651 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
652 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
654 if (columns
!= FRAME_COLS (f
)
655 || rows
!= FRAME_LINES (f
)
656 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
657 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
659 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
660 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
662 change_frame_size (f
, rows
, columns
, 0, 1, 0);
663 SET_FRAME_GARBAGED (f
);
664 cancel_mouse_face (f
);
668 /* Resize the outer window of frame F after chainging the height.
669 COLUMNS/ROWS is the size the edit area shall have after the resize. */
672 xg_frame_set_char_size (f
, cols
, rows
)
677 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
678 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
681 if (FRAME_PIXEL_HEIGHT (f
) == 0)
684 /* Take into account the size of the scroll bar. Always use the
685 number of columns occupied by the scroll bar here otherwise we
686 might end up with a frame width that is not a multiple of the
687 frame's character width which is bad for vertically split
689 f
->scroll_bar_actual_width
690 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
692 compute_fringe_widths (f
, 0);
694 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
695 after calculating that value. */
696 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
698 /* Must resize our top level widget. Font size may have changed,
699 but not rows/cols. */
700 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
701 pixelwidth
, pixelheight
);
702 x_wm_set_size_hint (f
, 0, 0);
704 SET_FRAME_GARBAGED (f
);
705 cancel_mouse_face (f
);
707 /* We can not call change_frame_size for a mapped frame,
708 we can not set pixel width/height either. The window manager may
709 override our resize request, XMonad does this all the time.
710 The best we can do is try to sync, so lisp code sees the updated
711 size as fast as possible.
712 For unmapped windows, we can set rows/cols. When
713 the frame is mapped again we will (hopefully) get the correct size. */
714 if (f
->async_visible
)
716 /* Must call this to flush out events */
717 (void)gtk_events_pending ();
719 x_wait_for_event (f
, ConfigureNotify
);
723 change_frame_size (f
, rows
, cols
, 0, 1, 0);
724 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
725 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
729 /* Handle height changes (i.e. add/remove menu/toolbar).
730 The policy is to keep the number of editable lines. */
733 xg_height_changed (f
)
736 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
737 FRAME_PIXEL_WIDTH (f
), FRAME_TOTAL_PIXEL_HEIGHT (f
));
738 f
->output_data
.x
->hint_flags
= 0;
739 x_wm_set_size_hint (f
, 0, 0);
742 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
743 Must be done like this, because GtkWidget:s can have "hidden"
744 X Window that aren't accessible.
746 Return 0 if no widget match WDESC. */
749 xg_win_to_widget (dpy
, wdesc
)
754 GtkWidget
*gwdesc
= 0;
758 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
763 event
.any
.window
= gdkwin
;
764 gwdesc
= gtk_get_event_widget (&event
);
771 /* Fill in the GdkColor C so that it represents PIXEL.
772 W is the widget that color will be used for. Used to find colormap. */
775 xg_pix_to_gcolor (w
, pixel
, c
)
780 GdkColormap
*map
= gtk_widget_get_colormap (w
);
781 gdk_colormap_query_color (map
, pixel
, c
);
784 /* Create and set up the GTK widgets for frame F.
785 Return 0 if creation failed, non-zero otherwise. */
788 xg_create_frame_widgets (f
)
801 if (FRAME_X_EMBEDDED_P (f
))
802 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
804 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
806 xg_set_screen (wtop
, f
);
808 wvbox
= gtk_vbox_new (FALSE
, 0);
809 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
811 if (! wtop
|| ! wvbox
|| ! wfixed
)
813 if (wtop
) gtk_widget_destroy (wtop
);
814 if (wvbox
) gtk_widget_destroy (wvbox
);
815 if (wfixed
) gtk_widget_destroy (wfixed
);
821 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
822 gtk_widget_set_name (wtop
, EMACS_CLASS
);
823 gtk_widget_set_name (wvbox
, "pane");
824 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
826 /* If this frame has a title or name, set it in the title bar. */
827 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
828 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
830 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
832 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
833 FRAME_GTK_WIDGET (f
) = wfixed
;
834 f
->output_data
.x
->vbox_widget
= wvbox
;
836 gtk_fixed_set_has_window (GTK_FIXED (wfixed
), TRUE
);
838 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
839 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
841 if (FRAME_EXTERNAL_TOOL_BAR (f
))
842 update_frame_tool_bar (f
);
844 /* We don't want this widget double buffered, because we draw on it
845 with regular X drawing primitives, so from a GTK/GDK point of
846 view, the widget is totally blank. When an expose comes, this
847 will make the widget blank, and then Emacs redraws it. This flickers
848 a lot, so we turn off double buffering. */
849 gtk_widget_set_double_buffered (wfixed
, FALSE
);
851 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
852 SSDATA (Vx_resource_name
),
853 SSDATA (Vx_resource_class
));
855 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
856 GTK is to destroy the widget. We want Emacs to do that instead. */
857 g_signal_connect (G_OBJECT (wtop
), "delete-event",
858 G_CALLBACK (gtk_true
), 0);
860 /* Convert our geometry parameters into a geometry string
862 GTK will itself handle calculating the real position this way. */
864 int grav
= gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
865 f
->win_gravity
= grav
;
867 gtk_widget_add_events (wfixed
,
868 GDK_POINTER_MOTION_MASK
870 | GDK_BUTTON_PRESS_MASK
871 | GDK_BUTTON_RELEASE_MASK
873 | GDK_ENTER_NOTIFY_MASK
874 | GDK_LEAVE_NOTIFY_MASK
875 | GDK_FOCUS_CHANGE_MASK
877 | GDK_VISIBILITY_NOTIFY_MASK
);
879 /* Must realize the windows so the X window gets created. It is used
880 by callers of this function. */
881 gtk_widget_realize (wfixed
);
882 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
884 /* Since GTK clears its window by filling with the background color,
885 we must keep X and GTK background in sync. */
886 xg_pix_to_gcolor (wfixed
, FRAME_BACKGROUND_PIXEL (f
), &bg
);
887 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
889 /* Also, do not let any background pixmap to be set, this looks very
890 bad as Emacs overwrites the background pixmap with its own idea
891 of background color. */
892 style
= gtk_widget_get_modifier_style (wfixed
);
894 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
895 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
896 gtk_widget_modify_style (wfixed
, style
);
898 /* GTK does not set any border, and they look bad with GTK. */
899 /* That they look bad is no excuse for imposing this here. --Stef
900 It should be done by providing the proper default in Fx_create_Frame.
902 f->internal_border_width = 0; */
909 /* Set the normal size hints for the window manager, for frame F.
910 FLAGS is the flags word to use--or 0 meaning preserve the flags
911 that the window now has.
912 If USER_POSITION is nonzero, we set the User Position
913 flag (this is useful when FLAGS is 0). */
916 x_wm_set_size_hint (f
, flags
, user_position
)
921 /* Don't set size hints during initialization; that apparently leads
922 to a race condition. See the thread at
923 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
924 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
927 /* Must use GTK routines here, otherwise GTK resets the size hints
928 to its own defaults. */
929 GdkGeometry size_hints
;
931 int base_width
, base_height
;
932 int min_rows
= 0, min_cols
= 0;
933 int win_gravity
= f
->win_gravity
;
937 memset (&size_hints
, 0, sizeof (size_hints
));
938 f
->output_data
.x
->size_hints
= size_hints
;
939 f
->output_data
.x
->hint_flags
= hint_flags
;
942 flags
= f
->size_hint_flags
;
944 size_hints
= f
->output_data
.x
->size_hints
;
945 hint_flags
= f
->output_data
.x
->hint_flags
;
947 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
948 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
949 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
951 hint_flags
|= GDK_HINT_BASE_SIZE
;
952 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
953 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
954 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
956 check_frame_size (f
, &min_rows
, &min_cols
);
958 size_hints
.base_width
= base_width
;
959 size_hints
.base_height
= base_height
;
960 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
961 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
963 /* These currently have a one to one mapping with the X values, but I
964 don't think we should rely on that. */
965 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
966 size_hints
.win_gravity
= 0;
967 if (win_gravity
== NorthWestGravity
)
968 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
969 else if (win_gravity
== NorthGravity
)
970 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
971 else if (win_gravity
== NorthEastGravity
)
972 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
973 else if (win_gravity
== WestGravity
)
974 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
975 else if (win_gravity
== CenterGravity
)
976 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
977 else if (win_gravity
== EastGravity
)
978 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
979 else if (win_gravity
== SouthWestGravity
)
980 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
981 else if (win_gravity
== SouthGravity
)
982 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
983 else if (win_gravity
== SouthEastGravity
)
984 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
985 else if (win_gravity
== StaticGravity
)
986 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
988 if (flags
& PPosition
) hint_flags
|= GDK_HINT_POS
;
989 if (flags
& USPosition
) hint_flags
|= GDK_HINT_USER_POS
;
990 if (flags
& USSize
) hint_flags
|= GDK_HINT_USER_SIZE
;
994 hint_flags
&= ~GDK_HINT_POS
;
995 hint_flags
|= GDK_HINT_USER_POS
;
998 if (hint_flags
!= f
->output_data
.x
->hint_flags
999 || memcmp (&size_hints
,
1000 &f
->output_data
.x
->size_hints
,
1001 sizeof (size_hints
)) != 0)
1004 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1005 NULL
, &size_hints
, hint_flags
);
1006 f
->output_data
.x
->size_hints
= size_hints
;
1007 f
->output_data
.x
->hint_flags
= hint_flags
;
1012 /* Change background color of a frame.
1013 Since GTK uses the background color to clear the window, we must
1014 keep the GTK and X colors in sync.
1015 F is the frame to change,
1016 BG is the pixel value to change to. */
1019 xg_set_background_color (f
, bg
)
1023 if (FRAME_GTK_WIDGET (f
))
1028 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
1029 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
1035 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1036 functions so GTK does not overwrite the icon. */
1039 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
)
1044 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1045 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
1046 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
1047 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
1049 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1054 /***********************************************************************
1056 ***********************************************************************/
1057 /* Return the dialog title to use for a dialog of type KEY.
1058 This is the encoding used by lwlib. We use the same for GTK. */
1061 get_dialog_title (char key
)
1071 title
= "Information";
1090 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1091 the dialog, but return TRUE so the event does not propagate further
1092 in GTK. This prevents GTK from destroying the dialog widget automatically
1093 and we can always destrou the widget manually, regardles of how
1094 it was popped down (button press or WM_DELETE_WINDOW).
1095 W is the dialog widget.
1096 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1097 user_data is NULL (not used).
1099 Returns TRUE to end propagation of event. */
1102 dialog_delete_callback (w
, event
, user_data
)
1107 gtk_widget_unmap (w
);
1111 /* Create a popup dialog window. See also xg_create_widget below.
1112 WV is a widget_value describing the dialog.
1113 SELECT_CB is the callback to use when a button has been pressed.
1114 DEACTIVATE_CB is the callback to use when the dialog pops down.
1116 Returns the GTK dialog widget. */
1119 create_dialog (wv
, select_cb
, deactivate_cb
)
1121 GCallback select_cb
;
1122 GCallback deactivate_cb
;
1124 char *title
= get_dialog_title (wv
->name
[0]);
1125 int total_buttons
= wv
->name
[1] - '0';
1126 int right_buttons
= wv
->name
[4] - '0';
1129 int button_spacing
= 10;
1130 GtkWidget
*wdialog
= gtk_dialog_new ();
1134 GtkWidget
*whbox_up
;
1135 GtkWidget
*whbox_down
;
1137 /* If the number of buttons is greater than 4, make two rows of buttons
1138 instead. This looks better. */
1139 int make_two_rows
= total_buttons
> 4;
1141 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1142 left_buttons
= total_buttons
- right_buttons
;
1144 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1145 gtk_widget_set_name (wdialog
, "emacs-dialog");
1147 cur_box
= GTK_BOX (GTK_DIALOG (wdialog
)->action_area
);
1151 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1152 whbox_up
= gtk_hbox_new (FALSE
, 0);
1153 whbox_down
= gtk_hbox_new (FALSE
, 0);
1155 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1156 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1157 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1159 cur_box
= GTK_BOX (whbox_up
);
1162 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1163 G_CALLBACK (dialog_delete_callback
), 0);
1167 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1168 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1171 for (item
= wv
->contents
; item
; item
= item
->next
)
1173 char *utf8_label
= get_utf8_string (item
->value
);
1177 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1179 /* This is the text part of the dialog. */
1180 w
= gtk_label_new (utf8_label
);
1181 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1184 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
), w
,
1186 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1188 /* Try to make dialog look better. Must realize first so
1189 the widget can calculate the size it needs. */
1190 gtk_widget_realize (w
);
1191 gtk_widget_size_request (w
, &req
);
1192 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1194 if (item
->value
&& strlen (item
->value
) > 0)
1195 button_spacing
= 2*req
.width
/strlen (item
->value
);
1199 /* This is one button to add to the dialog. */
1200 w
= gtk_button_new_with_label (utf8_label
);
1201 if (! item
->enabled
)
1202 gtk_widget_set_sensitive (w
, FALSE
);
1204 g_signal_connect (G_OBJECT (w
), "clicked",
1205 select_cb
, item
->call_data
);
1207 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1208 if (++button_nr
== left_buttons
)
1211 cur_box
= GTK_BOX (whbox_down
);
1213 gtk_box_pack_start (cur_box
,
1220 if (utf8_label
&& utf8_label
!= item
->value
)
1221 g_free (utf8_label
);
1229 /***********************************************************************
1230 File dialog functions
1231 ***********************************************************************/
1232 /* Return non-zero if the old file selection dialog is being used.
1233 Return zero if not. */
1236 xg_uses_old_file_dialog ()
1238 #ifdef HAVE_GTK_FILE_BOTH
1239 extern int x_gtk_use_old_file_dialog
;
1240 return x_gtk_use_old_file_dialog
;
1241 #else /* ! HAVE_GTK_FILE_BOTH */
1243 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1249 #endif /* ! HAVE_GTK_FILE_BOTH */
1253 /* Function that is called when the file or font dialogs pop down.
1254 W is the dialog widget, RESPONSE is the response code.
1255 USER_DATA is what we passed in to g_signal_connect (pointer to int). */
1258 xg_dialog_response_cb (w
,
1265 int *ptr
= (int *) user_data
;
1270 /* Destroy the dialog. This makes it pop down. */
1273 pop_down_dialog (arg
)
1276 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1278 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1283 typedef char * (*xg_get_file_func
) P_ ((GtkWidget
*));
1285 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1287 /* Return the selected file for file chooser dialog W.
1288 The returned string must be free:d. */
1291 xg_get_file_name_from_chooser (w
)
1294 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1297 /* Callback called when the "Show hidden files" toggle is pressed.
1298 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1301 xg_toggle_visibility_cb (widget
, data
)
1305 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1307 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1308 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1312 /* Callback called when a property changes in a file chooser.
1313 GOBJECT is the file chooser dialog, ARG1 describes the property.
1314 USER_DATA is the toggle widget in the file chooser dialog.
1315 We use this to update the "Show hidden files" toggle when the user
1316 changes that property by right clicking in the file list. */
1319 xg_toggle_notify_cb (gobject
, arg1
, user_data
)
1324 extern int x_gtk_show_hidden_files
;
1326 if (strcmp (arg1
->name
, "show-hidden") == 0)
1328 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (gobject
);
1329 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1330 gboolean visible
, toggle_on
;
1332 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1333 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1335 if (!!visible
!= !!toggle_on
)
1337 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1338 G_CALLBACK (xg_toggle_visibility_cb
),
1340 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1341 g_signal_handlers_unblock_by_func
1342 (G_OBJECT (wtoggle
),
1343 G_CALLBACK (xg_toggle_visibility_cb
),
1346 x_gtk_show_hidden_files
= visible
;
1350 /* Read a file name from the user using a file chooser dialog.
1351 F is the current frame.
1352 PROMPT is a prompt to show to the user. May not be NULL.
1353 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1354 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1355 file. *FUNC is set to a function that can be used to retrieve the
1356 selected file name from the returned widget.
1358 Returns the created widget. */
1361 xg_get_file_with_chooser (f
, prompt
, default_filename
,
1362 mustmatch_p
, only_dir_p
, func
)
1365 char *default_filename
;
1366 int mustmatch_p
, only_dir_p
;
1367 xg_get_file_func
*func
;
1371 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1372 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1373 GtkFileChooserAction action
= (mustmatch_p
?
1374 GTK_FILE_CHOOSER_ACTION_OPEN
:
1375 GTK_FILE_CHOOSER_ACTION_SAVE
);
1376 extern int x_gtk_show_hidden_files
;
1377 extern int x_gtk_file_dialog_help_text
;
1381 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1383 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1384 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1385 (mustmatch_p
|| only_dir_p
?
1386 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1389 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1391 wbox
= gtk_vbox_new (FALSE
, 0);
1392 gtk_widget_show (wbox
);
1393 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1395 if (x_gtk_show_hidden_files
)
1397 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1398 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1400 gtk_widget_show (wtoggle
);
1401 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1402 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1403 g_signal_connect (G_OBJECT (filewin
), "notify",
1404 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1406 if (x_gtk_file_dialog_help_text
)
1409 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1410 Show the C-l help text only for versions < 2.10. */
1411 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1412 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1413 strcat (message
, "\nIf you don't like this file selector, use the "
1414 "corresponding\nkey binding or customize "
1415 "use-file-dialog to turn it off.");
1417 wmessage
= gtk_label_new (message
);
1418 gtk_widget_show (wmessage
);
1421 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1422 if (x_gtk_file_dialog_help_text
)
1423 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1424 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1426 if (default_filename
)
1429 struct gcpro gcpro1
;
1430 char *utf8_filename
;
1433 file
= build_string (default_filename
);
1435 /* File chooser does not understand ~/... in the file name. It must be
1436 an absolute name starting with /. */
1437 if (default_filename
[0] != '/')
1438 file
= Fexpand_file_name (file
, Qnil
);
1440 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1441 if (! NILP (Ffile_directory_p (file
)))
1442 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1446 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1448 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1450 char *cp
= strrchr (utf8_filename
, '/');
1452 else cp
= utf8_filename
;
1453 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1460 *func
= xg_get_file_name_from_chooser
;
1463 #endif /* HAVE_GTK_FILE_CHOOSER_DIALOG_NEW */
1465 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1467 /* Return the selected file for file selector dialog W.
1468 The returned string must be free:d. */
1471 xg_get_file_name_from_selector (w
)
1474 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1475 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1478 /* Create a file selection dialog.
1479 F is the current frame.
1480 PROMPT is a prompt to show to the user. May not be NULL.
1481 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1482 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1483 file. *FUNC is set to a function that can be used to retrieve the
1484 selected file name from the returned widget.
1486 Returns the created widget. */
1489 xg_get_file_with_selection (f
, prompt
, default_filename
,
1490 mustmatch_p
, only_dir_p
, func
)
1493 char *default_filename
;
1494 int mustmatch_p
, only_dir_p
;
1495 xg_get_file_func
*func
;
1498 GtkFileSelection
*filesel
;
1500 filewin
= gtk_file_selection_new (prompt
);
1501 filesel
= GTK_FILE_SELECTION (filewin
);
1503 if (default_filename
)
1504 gtk_file_selection_set_filename (filesel
, default_filename
);
1508 /* The selection_entry part of filesel is not documented. */
1509 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1510 gtk_file_selection_hide_fileop_buttons (filesel
);
1513 *func
= xg_get_file_name_from_selector
;
1517 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1519 /* Read a file name from the user using a file dialog, either the old
1520 file selection dialog, or the new file chooser dialog. Which to use
1521 depends on what the GTK version used has, and what the value of
1522 gtk-use-old-file-dialog.
1523 F is the current frame.
1524 PROMPT is a prompt to show to the user. May not be NULL.
1525 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1526 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1529 Returns a file name or NULL if no file was selected.
1530 The returned string must be freed by the caller. */
1533 xg_get_file_name (f
, prompt
, default_filename
, mustmatch_p
, only_dir_p
)
1536 char *default_filename
;
1537 int mustmatch_p
, only_dir_p
;
1540 int count
= SPECPDL_INDEX ();
1542 int filesel_done
= 0;
1543 xg_get_file_func func
;
1545 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1546 /* I really don't know why this is needed, but without this the GLIBC add on
1547 library linuxthreads hangs when the Gnome file chooser backend creates
1549 sigblock (sigmask (__SIGRTMIN
));
1550 #endif /* HAVE_GTK_AND_PTHREAD */
1552 #ifdef HAVE_GTK_FILE_BOTH
1554 if (xg_uses_old_file_dialog ())
1555 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1556 mustmatch_p
, only_dir_p
, &func
);
1558 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1559 mustmatch_p
, only_dir_p
, &func
);
1561 #else /* not HAVE_GTK_FILE_BOTH */
1563 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1564 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1565 mustmatch_p
, only_dir_p
, &func
);
1567 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1568 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1569 mustmatch_p
, only_dir_p
, &func
);
1572 #endif /* HAVE_GTK_FILE_BOTH */
1574 xg_set_screen (w
, f
);
1575 gtk_widget_set_name (w
, "emacs-filedialog");
1576 gtk_window_set_transient_for (GTK_WINDOW (w
),
1577 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1578 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1579 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1581 g_signal_connect (G_OBJECT (w
),
1583 G_CALLBACK (xg_dialog_response_cb
),
1586 /* Don't destroy the widget if closed by the window manager close button. */
1587 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1589 gtk_widget_show (w
);
1591 record_unwind_protect (pop_down_dialog
, make_save_value (w
, 0));
1592 while (! filesel_done
)
1594 x_menu_wait_for_event (0);
1595 gtk_main_iteration ();
1598 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1599 sigunblock (sigmask (__SIGRTMIN
));
1602 if (filesel_done
== GTK_RESPONSE_OK
)
1605 unbind_to (count
, Qnil
);
1610 #ifdef HAVE_FREETYPE
1611 /* Pop up a GTK font selector and return the name of the font the user
1612 selects, as a C string. The returned font name follows GTK's own
1615 `FAMILY [VALUE1 VALUE2] SIZE'
1617 This can be parsed using font_parse_fcname in font.c.
1618 DEFAULT_NAME, if non-zero, is the default font name. */
1621 xg_get_font_name (f
, default_name
)
1626 int count
= SPECPDL_INDEX ();
1627 char *fontname
= NULL
;
1630 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1631 sigblock (sigmask (__SIGRTMIN
));
1632 #endif /* HAVE_GTK_AND_PTHREAD */
1634 w
= gtk_font_selection_dialog_new ("Pick a font");
1636 default_name
= "Monospace 10";
1637 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1640 xg_set_screen (w
, f
);
1641 gtk_widget_set_name (w
, "emacs-fontdialog");
1642 gtk_window_set_transient_for (GTK_WINDOW (w
),
1643 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1644 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1645 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1647 g_signal_connect (G_OBJECT (w
), "response",
1648 G_CALLBACK (xg_dialog_response_cb
), &done
);
1650 /* Don't destroy the widget if closed by the window manager close button. */
1651 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1653 gtk_widget_show (w
);
1655 record_unwind_protect (pop_down_dialog
, make_save_value (w
, 0));
1658 x_menu_wait_for_event (0);
1659 gtk_main_iteration ();
1662 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1663 sigunblock (sigmask (__SIGRTMIN
));
1666 if (done
== GTK_RESPONSE_OK
)
1667 fontname
= gtk_font_selection_dialog_get_font_name
1668 ((GtkFontSelectionDialog
*) w
);
1670 unbind_to (count
, Qnil
);
1674 #endif /* HAVE_FREETYPE */
1678 /***********************************************************************
1680 ***********************************************************************/
1682 /* The name of menu items that can be used for customization. Since GTK
1683 RC files are very crude and primitive, we have to set this on all
1684 menu item names so a user can easily customize menu items. */
1686 #define MENU_ITEM_NAME "emacs-menuitem"
1689 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1690 during GC. The next member points to the items. */
1691 static xg_list_node xg_menu_cb_list
;
1693 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1694 during GC. The next member points to the items. */
1695 static xg_list_node xg_menu_item_cb_list
;
1697 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1698 F is the frame CL_DATA will be initialized for.
1699 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1701 The menu bar and all sub menus under the menu bar in a frame
1702 share the same structure, hence the reference count.
1704 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1705 allocated xg_menu_cb_data if CL_DATA is NULL. */
1707 static xg_menu_cb_data
*
1708 make_cl_data (cl_data
, f
, highlight_cb
)
1709 xg_menu_cb_data
*cl_data
;
1711 GCallback highlight_cb
;
1715 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1717 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1718 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1719 cl_data
->highlight_cb
= highlight_cb
;
1720 cl_data
->ref_count
= 0;
1722 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1725 cl_data
->ref_count
++;
1730 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1731 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1733 When the menu bar is updated, menu items may have been added and/or
1734 removed, so menu_bar_vector and menu_bar_items_used change. We must
1735 then update CL_DATA since it is used to determine which menu
1736 item that is invoked in the menu.
1737 HIGHLIGHT_CB could change, there is no check that the same
1738 function is given when modifying a menu bar as was given when
1739 creating the menu bar. */
1742 update_cl_data (cl_data
, f
, highlight_cb
)
1743 xg_menu_cb_data
*cl_data
;
1745 GCallback highlight_cb
;
1750 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1751 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1752 cl_data
->highlight_cb
= highlight_cb
;
1756 /* Decrease reference count for CL_DATA.
1757 If reference count is zero, free CL_DATA. */
1760 unref_cl_data (cl_data
)
1761 xg_menu_cb_data
*cl_data
;
1763 if (cl_data
&& cl_data
->ref_count
> 0)
1765 cl_data
->ref_count
--;
1766 if (cl_data
->ref_count
== 0)
1768 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1774 /* Function that marks all lisp data during GC. */
1781 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1782 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1784 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1786 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1788 if (! NILP (cb_data
->help
))
1789 mark_object (cb_data
->help
);
1794 /* Callback called when a menu item is destroyed. Used to free data.
1795 W is the widget that is being destroyed (not used).
1796 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1799 menuitem_destroy_callback (w
, client_data
)
1801 gpointer client_data
;
1805 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1806 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1811 /* Callback called when the pointer enters/leaves a menu item.
1812 W is the parent of the menu item.
1813 EVENT is either an enter event or leave event.
1814 CLIENT_DATA is not used.
1816 Returns FALSE to tell GTK to keep processing this event. */
1819 menuitem_highlight_callback (w
, event
, client_data
)
1821 GdkEventCrossing
*event
;
1822 gpointer client_data
;
1825 GtkWidget
*subwidget
;
1826 xg_menu_item_cb_data
*data
;
1828 ev
.crossing
= *event
;
1829 subwidget
= gtk_get_event_widget (&ev
);
1830 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
1834 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1836 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
1837 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1838 (*func
) (subwidget
, call_data
);
1845 /* Callback called when a menu is destroyed. Used to free data.
1846 W is the widget that is being destroyed (not used).
1847 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1850 menu_destroy_callback (w
, client_data
)
1852 gpointer client_data
;
1854 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1857 /* Callback called when a menu does a grab or ungrab. That means the
1858 menu has been activated or deactivated.
1859 Used to start a timer so the small timeout the menus in GTK uses before
1860 popping down a menu is seen by Emacs (see xg_process_timeouts above).
1861 W is the widget that does the grab (not used).
1862 UNGRAB_P is TRUE if this is an ungrab, FALSE if it is a grab.
1863 CLIENT_DATA is NULL (not used). */
1865 /* Keep track of total number of grabs. */
1866 static int menu_grab_callback_cnt
;
1869 menu_grab_callback (GtkWidget
*widget
,
1871 gpointer client_data
)
1873 if (ungrab_p
) menu_grab_callback_cnt
--;
1874 else menu_grab_callback_cnt
++;
1876 if (menu_grab_callback_cnt
> 0 && ! xg_timer
) xg_start_timer ();
1877 else if (menu_grab_callback_cnt
== 0 && xg_timer
) xg_stop_timer ();
1880 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1881 must be non-NULL) and can be inserted into a menu item.
1883 Returns the GtkHBox. */
1886 make_widget_for_menu_item (utf8_label
, utf8_key
)
1894 wbox
= gtk_hbox_new (FALSE
, 0);
1895 wlbl
= gtk_label_new (utf8_label
);
1896 wkey
= gtk_label_new (utf8_key
);
1898 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1899 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1901 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1902 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1904 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1905 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1906 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1911 /* Make and return a menu item widget with the key to the right.
1912 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1913 UTF8_KEY is the text representing the key binding.
1914 ITEM is the widget_value describing the menu item.
1916 GROUP is an in/out parameter. If the menu item to be created is not
1917 part of any radio menu group, *GROUP contains NULL on entry and exit.
1918 If the menu item to be created is part of a radio menu group, on entry
1919 *GROUP contains the group to use, or NULL if this is the first item
1920 in the group. On exit, *GROUP contains the radio item group.
1922 Unfortunately, keys don't line up as nicely as in Motif,
1923 but the MacOS X version doesn't either, so I guess that is OK. */
1926 make_menu_item (utf8_label
, utf8_key
, item
, group
)
1933 GtkWidget
*wtoadd
= 0;
1935 /* It has been observed that some menu items have a NULL name field.
1936 This will lead to this function being called with a NULL utf8_label.
1937 GTK crashes on that so we set a blank label. Why there is a NULL
1938 name remains to be investigated. */
1939 if (! utf8_label
) utf8_label
= " ";
1942 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1944 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1947 if (utf8_key
) w
= gtk_check_menu_item_new ();
1948 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1949 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1951 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1953 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1954 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1955 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1957 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1962 if (utf8_key
) w
= gtk_menu_item_new ();
1963 else w
= gtk_menu_item_new_with_label (utf8_label
);
1966 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1967 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1972 /* Return non-zero if LABEL specifies a separator (GTK only has one
1975 static char* separator_names
[] = {
1980 "single-dashed-line",
1981 "double-dashed-line",
1983 "shadow-etched-out",
1984 "shadow-etched-in-dash",
1985 "shadow-etched-out-dash",
1986 "shadow-double-etched-in",
1987 "shadow-double-etched-out",
1988 "shadow-double-etched-in-dash",
1989 "shadow-double-etched-out-dash",
1994 xg_separator_p (char *label
)
1996 if (! label
) return 0;
1997 else if (strlen (label
) > 3
1998 && strncmp (label
, "--", 2) == 0
2004 for (i
= 0; separator_names
[i
]; ++i
)
2005 if (strcmp (label
, separator_names
[i
]) == 0)
2010 /* Old-style separator, maybe. It's a separator if it contains
2012 while (*label
== '-')
2014 if (*label
== 0) return 1;
2020 static int xg_detached_menus
;
2022 /* Returns non-zero if there are detached menus. */
2025 xg_have_tear_offs ()
2027 return xg_detached_menus
> 0;
2030 /* Callback invoked when a detached menu window is removed. Here we
2031 decrease the xg_detached_menus count.
2032 WIDGET is the top level window that is removed (the parent of the menu).
2033 CLIENT_DATA is not used. */
2036 tearoff_remove (widget
, client_data
)
2038 gpointer client_data
;
2040 if (xg_detached_menus
> 0) --xg_detached_menus
;
2043 /* Callback invoked when a menu is detached. It increases the
2044 xg_detached_menus count.
2045 WIDGET is the GtkTearoffMenuItem.
2046 CLIENT_DATA is not used. */
2049 tearoff_activate (widget
, client_data
)
2051 gpointer client_data
;
2053 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2054 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2056 ++xg_detached_menus
;
2057 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2059 G_CALLBACK (tearoff_remove
), 0);
2064 /* Create a menu item widget, and connect the callbacks.
2065 ITEM decribes the menu item.
2066 F is the frame the created menu belongs to.
2067 SELECT_CB is the callback to use when a menu item is selected.
2068 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2069 CL_DATA points to the callback data to be used for this menu.
2070 GROUP is an in/out parameter. If the menu item to be created is not
2071 part of any radio menu group, *GROUP contains NULL on entry and exit.
2072 If the menu item to be created is part of a radio menu group, on entry
2073 *GROUP contains the group to use, or NULL if this is the first item
2074 in the group. On exit, *GROUP contains the radio item group.
2076 Returns the created GtkWidget. */
2079 xg_create_one_menuitem (item
, f
, select_cb
, highlight_cb
, cl_data
, group
)
2082 GCallback select_cb
;
2083 GCallback highlight_cb
;
2084 xg_menu_cb_data
*cl_data
;
2090 xg_menu_item_cb_data
*cb_data
;
2092 utf8_label
= get_utf8_string (item
->name
);
2093 utf8_key
= get_utf8_string (item
->key
);
2095 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2097 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2098 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
2100 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2102 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2104 cb_data
->select_id
= 0;
2105 cb_data
->help
= item
->help
;
2106 cb_data
->cl_data
= cl_data
;
2107 cb_data
->call_data
= item
->call_data
;
2109 g_signal_connect (G_OBJECT (w
),
2111 G_CALLBACK (menuitem_destroy_callback
),
2114 /* Put cb_data in widget, so we can get at it when modifying menubar */
2115 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2117 /* final item, not a submenu */
2118 if (item
->call_data
&& ! item
->contents
)
2122 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2128 static GtkWidget
*create_menus
P_ ((widget_value
*, FRAME_PTR
, GCallback
,
2129 GCallback
, GCallback
, int, int, int,
2130 GtkWidget
*, xg_menu_cb_data
*, char *));
2132 /* Create a full menu tree specified by DATA.
2133 F is the frame the created menu belongs to.
2134 SELECT_CB is the callback to use when a menu item is selected.
2135 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2136 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2137 POP_UP_P is non-zero if we shall create a popup menu.
2138 MENU_BAR_P is non-zero if we shall create a menu bar.
2139 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2140 if MENU_BAR_P is non-zero.
2141 TOPMENU is the topmost GtkWidget that others shall be placed under.
2142 It may be NULL, in that case we create the appropriate widget
2143 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2144 CL_DATA is the callback data we shall use for this menu, or NULL
2145 if we haven't set the first callback yet.
2146 NAME is the name to give to the top level menu if this function
2147 creates it. May be NULL to not set any name.
2149 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2152 This function calls itself to create submenus. */
2155 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2156 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
2159 GCallback select_cb
;
2160 GCallback deactivate_cb
;
2161 GCallback highlight_cb
;
2166 xg_menu_cb_data
*cl_data
;
2170 GtkWidget
*wmenu
= topmenu
;
2171 GSList
*group
= NULL
;
2177 wmenu
= gtk_menu_new ();
2178 xg_set_screen (wmenu
, f
);
2179 /* Connect this to the menu instead of items so we get enter/leave for
2180 disabled items also. TODO: Still does not get enter/leave for
2181 disabled items in detached menus. */
2182 g_signal_connect (G_OBJECT (wmenu
),
2183 "enter-notify-event",
2184 G_CALLBACK (menuitem_highlight_callback
),
2186 g_signal_connect (G_OBJECT (wmenu
),
2187 "leave-notify-event",
2188 G_CALLBACK (menuitem_highlight_callback
),
2193 wmenu
= gtk_menu_bar_new ();
2194 // Set width of menu bar to a small value so it doesn't enlarge
2195 // a small initial frame size. The width will be set to the
2196 // width of the frame later on when it is added to a container.
2197 // height -1: Natural height.
2198 gtk_widget_set_size_request (wmenu
, 1, -1);
2201 /* Put cl_data on the top menu for easier access. */
2202 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2203 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2204 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2205 G_CALLBACK (menu_destroy_callback
), cl_data
);
2208 gtk_widget_set_name (wmenu
, name
);
2211 g_signal_connect (G_OBJECT (wmenu
),
2212 "selection-done", deactivate_cb
, 0);
2214 g_signal_connect (G_OBJECT (wmenu
),
2215 "grab-notify", G_CALLBACK (menu_grab_callback
), 0);
2218 if (! menu_bar_p
&& add_tearoff_p
)
2220 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2221 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2223 g_signal_connect (G_OBJECT (tearoff
), "activate",
2224 G_CALLBACK (tearoff_activate
), 0);
2227 for (item
= data
; item
; item
= item
->next
)
2231 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2232 && !xg_separator_p (item
->name
))
2235 /* A title for a popup. We do the same as GTK does when
2236 creating titles, but it does not look good. */
2238 utf8_label
= get_utf8_string (item
->name
);
2240 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2241 w
= gtk_menu_item_new_with_label (utf8_label
);
2242 gtk_widget_set_sensitive (w
, FALSE
);
2243 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2245 else if (xg_separator_p (item
->name
))
2248 /* GTK only have one separator type. */
2249 w
= gtk_separator_menu_item_new ();
2253 w
= xg_create_one_menuitem (item
,
2255 item
->contents
? 0 : select_cb
,
2260 /* Create a possibly empty submenu for menu bar items, since some
2261 themes don't highlight items correctly without it. */
2262 if (item
->contents
|| menu_bar_p
)
2264 GtkWidget
*submenu
= create_menus (item
->contents
,
2275 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2279 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2280 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2286 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2287 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2288 with some text and buttons.
2289 F is the frame the created item belongs to.
2290 NAME is the name to use for the top widget.
2291 VAL is a widget_value structure describing items to be created.
2292 SELECT_CB is the callback to use when a menu item is selected or
2293 a dialog button is pressed.
2294 DEACTIVATE_CB is the callback to use when an item is deactivated.
2295 For a menu, when a sub menu is not shown anymore, for a dialog it is
2296 called when the dialog is popped down.
2297 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2299 Returns the widget created. */
2302 xg_create_widget (type
, name
, f
, val
,
2303 select_cb
, deactivate_cb
, highlight_cb
)
2308 GCallback select_cb
;
2309 GCallback deactivate_cb
;
2310 GCallback highlight_cb
;
2313 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2314 int pop_up_p
= strcmp (type
, "popup") == 0;
2316 if (strcmp (type
, "dialog") == 0)
2318 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2319 xg_set_screen (w
, f
);
2320 gtk_window_set_transient_for (GTK_WINDOW (w
),
2321 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2322 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2323 gtk_widget_set_name (w
, "emacs-dialog");
2324 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2326 else if (menu_bar_p
|| pop_up_p
)
2328 w
= create_menus (val
->contents
,
2340 /* Set the cursor to an arrow for popup menus when they are mapped.
2341 This is done by default for menu bar menus. */
2344 /* Must realize so the GdkWindow inside the widget is created. */
2345 gtk_widget_realize (w
);
2346 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2351 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2358 /* Return the label for menu item WITEM. */
2361 xg_get_menu_item_label (witem
)
2364 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2365 return gtk_label_get_label (wlabel
);
2368 /* Return non-zero if the menu item WITEM has the text LABEL. */
2371 xg_item_label_same_p (witem
, label
)
2376 char *utf8_label
= get_utf8_string (label
);
2377 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2379 if (! old_label
&& ! utf8_label
)
2381 else if (old_label
&& utf8_label
)
2382 is_same
= strcmp (utf8_label
, old_label
) == 0;
2384 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2389 /* Destroy widgets in LIST. */
2392 xg_destroy_widgets (list
)
2397 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2399 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2401 /* Destroying the widget will remove it from the container it is in. */
2402 gtk_widget_destroy (w
);
2406 /* Update the top level names in MENUBAR (i.e. not submenus).
2407 F is the frame the menu bar belongs to.
2408 *LIST is a list with the current menu bar names (menu item widgets).
2409 ITER is the item within *LIST that shall be updated.
2410 POS is the numerical position, starting at 0, of ITER in *LIST.
2411 VAL describes what the menu bar shall look like after the update.
2412 SELECT_CB is the callback to use when a menu item is selected.
2413 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2414 CL_DATA points to the callback data to be used for this menu bar.
2416 This function calls itself to walk through the menu bar names. */
2419 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2420 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2427 GCallback select_cb
;
2428 GCallback deactivate_cb
;
2429 GCallback highlight_cb
;
2430 xg_menu_cb_data
*cl_data
;
2432 if (! iter
&& ! val
)
2434 else if (iter
&& ! val
)
2436 /* Item(s) have been removed. Remove all remaining items. */
2437 xg_destroy_widgets (iter
);
2443 else if (! iter
&& val
)
2445 /* Item(s) added. Add all new items in one call. */
2446 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2447 0, 1, 0, menubar
, cl_data
, 0);
2453 /* Below this neither iter or val is NULL */
2454 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2456 /* This item is still the same, check next item. */
2458 iter
= g_list_next (iter
);
2461 else /* This item is changed. */
2463 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2464 GtkMenuItem
*witem2
= 0;
2465 int val_in_menubar
= 0;
2466 int iter_in_new_menubar
= 0;
2470 /* See if the changed entry (val) is present later in the menu bar */
2472 iter2
&& ! val_in_menubar
;
2473 iter2
= g_list_next (iter2
))
2475 witem2
= GTK_MENU_ITEM (iter2
->data
);
2476 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2479 /* See if the current entry (iter) is present later in the
2480 specification for the new menu bar. */
2481 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2482 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2484 if (val_in_menubar
&& ! iter_in_new_menubar
)
2488 /* This corresponds to:
2493 gtk_widget_ref (GTK_WIDGET (witem
));
2494 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2495 gtk_widget_destroy (GTK_WIDGET (witem
));
2497 /* Must get new list since the old changed. */
2498 g_list_free (*list
);
2499 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2500 while (nr
-- > 0) iter
= g_list_next (iter
);
2502 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2504 /* This corresponds to:
2507 Rename B to X. This might seem to be a strange thing to do,
2508 since if there is a menu under B it will be totally wrong for X.
2509 But consider editing a C file. Then there is a C-mode menu
2510 (corresponds to B above).
2511 If then doing C-x C-f the minibuf menu (X above) replaces the
2512 C-mode menu. When returning from the minibuffer, we get
2513 back the C-mode menu. Thus we do:
2514 Rename B to X (C-mode to minibuf menu)
2515 Rename X to B (minibuf to C-mode menu).
2516 If the X menu hasn't been invoked, the menu under B
2517 is up to date when leaving the minibuffer. */
2518 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2519 char *utf8_label
= get_utf8_string (val
->name
);
2520 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2522 gtk_label_set_text (wlabel
, utf8_label
);
2524 /* If this item has a submenu that has been detached, change
2525 the title in the WM decorations also. */
2526 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2527 /* Set the title of the detached window. */
2528 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2530 iter
= g_list_next (iter
);
2534 else if (! val_in_menubar
&& iter_in_new_menubar
)
2536 /* This corresponds to:
2543 GtkWidget
*w
= xg_create_one_menuitem (val
,
2550 /* Create a possibly empty submenu for menu bar items, since some
2551 themes don't highlight items correctly without it. */
2552 GtkWidget
*submenu
= create_menus (NULL
, f
,
2553 select_cb
, deactivate_cb
,
2555 0, 0, 0, 0, cl_data
, 0);
2556 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2557 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2558 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2560 g_list_free (*list
);
2561 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2562 while (nr
-- > 0) iter
= g_list_next (iter
);
2563 iter
= g_list_next (iter
);
2567 else /* if (val_in_menubar && iter_in_new_menubar) */
2570 /* This corresponds to:
2575 gtk_widget_ref (GTK_WIDGET (witem2
));
2576 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2577 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2578 GTK_WIDGET (witem2
), pos
);
2579 gtk_widget_unref (GTK_WIDGET (witem2
));
2581 g_list_free (*list
);
2582 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2583 while (nr
-- > 0) iter
= g_list_next (iter
);
2584 if (iter
) iter
= g_list_next (iter
);
2590 /* Update the rest of the menu bar. */
2591 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2592 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2595 /* Update the menu item W so it corresponds to VAL.
2596 SELECT_CB is the callback to use when a menu item is selected.
2597 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2598 CL_DATA is the data to set in the widget for menu invocation. */
2601 xg_update_menu_item (val
, w
, select_cb
, highlight_cb
, cl_data
)
2604 GCallback select_cb
;
2605 GCallback highlight_cb
;
2606 xg_menu_cb_data
*cl_data
;
2613 const char *old_label
= 0;
2614 const char *old_key
= 0;
2615 xg_menu_item_cb_data
*cb_data
;
2617 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2618 utf8_label
= get_utf8_string (val
->name
);
2619 utf8_key
= get_utf8_string (val
->key
);
2621 /* See if W is a menu item with a key. See make_menu_item above. */
2622 if (GTK_IS_HBOX (wchild
))
2624 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2626 wlbl
= GTK_LABEL (list
->data
);
2627 wkey
= GTK_LABEL (list
->next
->data
);
2632 /* Remove the key and keep just the label. */
2633 gtk_widget_ref (GTK_WIDGET (wlbl
));
2634 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2635 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2640 else /* Just a label. */
2642 wlbl
= GTK_LABEL (wchild
);
2644 /* Check if there is now a key. */
2647 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2648 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2650 wlbl
= GTK_LABEL (list
->data
);
2651 wkey
= GTK_LABEL (list
->next
->data
);
2654 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2655 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2660 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2661 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2663 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2664 gtk_label_set_text (wkey
, utf8_key
);
2666 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2667 gtk_label_set_text (wlbl
, utf8_label
);
2669 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2670 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2672 if (! val
->enabled
&& GTK_WIDGET_SENSITIVE (w
))
2673 gtk_widget_set_sensitive (w
, FALSE
);
2674 else if (val
->enabled
&& ! GTK_WIDGET_SENSITIVE (w
))
2675 gtk_widget_set_sensitive (w
, TRUE
);
2677 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2681 cb_data
->call_data
= val
->call_data
;
2682 cb_data
->help
= val
->help
;
2683 cb_data
->cl_data
= cl_data
;
2685 /* We assume the callback functions don't change. */
2686 if (val
->call_data
&& ! val
->contents
)
2688 /* This item shall have a select callback. */
2689 if (! cb_data
->select_id
)
2691 = g_signal_connect (G_OBJECT (w
), "activate",
2692 select_cb
, cb_data
);
2694 else if (cb_data
->select_id
)
2696 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2697 cb_data
->select_id
= 0;
2702 /* Update the toggle menu item W so it corresponds to VAL. */
2705 xg_update_toggle_item (val
, w
)
2709 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2712 /* Update the radio menu item W so it corresponds to VAL. */
2715 xg_update_radio_item (val
, w
)
2719 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2722 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2723 SUBMENU may be NULL, in that case a new menu is created.
2724 F is the frame the menu bar belongs to.
2725 VAL describes the contents of the menu bar.
2726 SELECT_CB is the callback to use when a menu item is selected.
2727 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2728 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2729 CL_DATA is the call back data to use for any newly created items.
2731 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2735 xg_update_submenu (submenu
, f
, val
,
2736 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2740 GCallback select_cb
;
2741 GCallback deactivate_cb
;
2742 GCallback highlight_cb
;
2743 xg_menu_cb_data
*cl_data
;
2745 GtkWidget
*newsub
= submenu
;
2749 int has_tearoff_p
= 0;
2750 GList
*first_radio
= 0;
2753 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2755 for (cur
= val
, iter
= list
;
2757 iter
= g_list_next (iter
), cur
= cur
->next
)
2759 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2761 /* Skip tearoff items, they have no counterpart in val. */
2762 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2765 iter
= g_list_next (iter
);
2766 if (iter
) w
= GTK_WIDGET (iter
->data
);
2770 /* Remember first radio button in a group. If we get a mismatch in
2771 a radio group we must rebuild the whole group so that the connections
2772 in GTK becomes correct. */
2773 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2775 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2776 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2779 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2781 if (! xg_separator_p (cur
->name
))
2784 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2786 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2788 xg_update_toggle_item (cur
, w
);
2789 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2791 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2793 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2795 xg_update_radio_item (cur
, w
);
2796 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2798 else if (GTK_IS_MENU_ITEM (w
))
2800 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2803 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2804 xg_separator_p (cur
->name
))
2807 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2809 sub
= gtk_menu_item_get_submenu (witem
);
2810 if (sub
&& ! cur
->contents
)
2812 /* Not a submenu anymore. */
2813 gtk_widget_ref (sub
);
2814 gtk_menu_item_remove_submenu (witem
);
2815 gtk_widget_destroy (sub
);
2817 else if (cur
->contents
)
2821 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2822 select_cb
, deactivate_cb
,
2823 highlight_cb
, cl_data
);
2825 /* If this item just became a submenu, we must set it. */
2827 gtk_menu_item_set_submenu (witem
, nsub
);
2832 /* Structural difference. Remove everything from here and down
2838 /* Remove widgets from first structual change. */
2841 /* If we are adding new menu items below, we must remove from
2842 first radio button so that radio groups become correct. */
2843 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2844 else xg_destroy_widgets (iter
);
2849 /* More items added. Create them. */
2850 newsub
= create_menus (cur
,
2863 if (list
) g_list_free (list
);
2868 /* Update the MENUBAR.
2869 F is the frame the menu bar belongs to.
2870 VAL describes the contents of the menu bar.
2871 If DEEP_P is non-zero, rebuild all but the top level menu names in
2872 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2873 SELECT_CB is the callback to use when a menu item is selected.
2874 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2875 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2878 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2879 select_cb
, deactivate_cb
, highlight_cb
)
2884 GCallback select_cb
;
2885 GCallback deactivate_cb
;
2886 GCallback highlight_cb
;
2888 xg_menu_cb_data
*cl_data
;
2889 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2893 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2896 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2897 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2903 /* Update all sub menus.
2904 We must keep the submenus (GTK menu item widgets) since the
2905 X Window in the XEvent that activates the menu are those widgets. */
2907 /* Update cl_data, menu_item things in F may have changed. */
2908 update_cl_data (cl_data
, f
, highlight_cb
);
2910 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2917 /* Find sub menu that corresponds to val and update it. */
2918 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2920 witem
= GTK_MENU_ITEM (iter
->data
);
2921 if (xg_item_label_same_p (witem
, cur
->name
))
2923 sub
= gtk_menu_item_get_submenu (witem
);
2928 newsub
= xg_update_submenu (sub
,
2935 /* sub may still be NULL. If we just updated non deep and added
2936 a new menu bar item, it has no sub menu yet. So we set the
2937 newly created sub menu under witem. */
2940 xg_set_screen (newsub
, f
);
2941 gtk_menu_item_set_submenu (witem
, newsub
);
2947 gtk_widget_show_all (menubar
);
2950 /* Recompute all the widgets of frame F, when the menu bar has been
2951 changed. Value is non-zero if widgets were updated. */
2954 xg_update_frame_menubar (f
)
2957 struct x_output
*x
= f
->output_data
.x
;
2960 if (!x
->menubar_widget
|| GTK_WIDGET_MAPPED (x
->menubar_widget
))
2965 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2967 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2969 gtk_widget_show_all (x
->menubar_widget
);
2970 gtk_widget_size_request (x
->menubar_widget
, &req
);
2971 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2972 xg_height_changed (f
);
2978 /* Get rid of the menu bar of frame F, and free its storage.
2979 This is used when deleting a frame, and when turning off the menu bar. */
2982 free_frame_menubar (f
)
2985 struct x_output
*x
= f
->output_data
.x
;
2987 if (x
->menubar_widget
)
2991 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2992 /* The menubar and its children shall be deleted when removed from
2994 x
->menubar_widget
= 0;
2995 FRAME_MENUBAR_HEIGHT (f
) = 0;
2996 xg_height_changed (f
);
3003 /***********************************************************************
3004 Scroll bar functions
3005 ***********************************************************************/
3008 /* Setting scroll bar values invokes the callback. Use this variable
3009 to indicate that callback should do nothing. */
3011 int xg_ignore_gtk_scrollbar
;
3013 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3014 may be larger than 32 bits. Keep a mapping from integer index to widget
3015 pointers to get around the 32 bit limitation. */
3019 GtkWidget
**widgets
;
3024 /* Grow this much every time we need to allocate more */
3026 #define ID_TO_WIDGET_INCR 32
3028 /* Store the widget pointer W in id_to_widget and return the integer index. */
3031 xg_store_widget_in_map (w
)
3036 if (id_to_widget
.max_size
== id_to_widget
.used
)
3038 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3040 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
3041 sizeof (GtkWidget
*)*new_size
);
3043 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3044 id_to_widget
.widgets
[i
] = 0;
3045 id_to_widget
.max_size
= new_size
;
3048 /* Just loop over the array and find a free place. After all,
3049 how many scroll bars are we creating? Should be a small number.
3050 The check above guarantees we will find a free place. */
3051 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3053 if (! id_to_widget
.widgets
[i
])
3055 id_to_widget
.widgets
[i
] = w
;
3056 ++id_to_widget
.used
;
3062 /* Should never end up here */
3066 /* Remove pointer at IDX from id_to_widget.
3067 Called when scroll bar is destroyed. */
3070 xg_remove_widget_from_map (idx
)
3073 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3075 id_to_widget
.widgets
[idx
] = 0;
3076 --id_to_widget
.used
;
3080 /* Get the widget pointer at IDX from id_to_widget. */
3083 xg_get_widget_from_map (idx
)
3086 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3087 return id_to_widget
.widgets
[idx
];
3092 /* Return the scrollbar id for X Window WID on display DPY.
3093 Return -1 if WID not in id_to_widget. */
3096 xg_get_scroll_id_for_window (dpy
, wid
)
3103 w
= xg_win_to_widget (dpy
, wid
);
3107 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3108 if (id_to_widget
.widgets
[idx
] == w
)
3115 /* Callback invoked when scroll bar WIDGET is destroyed.
3116 DATA is the index into id_to_widget for WIDGET.
3117 We free pointer to last scroll bar values here and remove the index. */
3120 xg_gtk_scroll_destroy (widget
, data
)
3125 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
3127 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
3129 xg_remove_widget_from_map (id
);
3132 /* Callback for button press/release events. Used to start timer so that
3133 the scroll bar repetition timer in GTK gets handled.
3134 Also, sets bar->dragging to Qnil when dragging (button release) is done.
3135 WIDGET is the scroll bar widget the event is for (not used).
3136 EVENT contains the event.
3137 USER_DATA points to the struct scrollbar structure.
3139 Returns FALSE to tell GTK that it shall continue propagate the event
3143 scroll_bar_button_cb (widget
, event
, user_data
)
3145 GdkEventButton
*event
;
3148 if (event
->type
== GDK_BUTTON_PRESS
&& ! xg_timer
)
3150 else if (event
->type
== GDK_BUTTON_RELEASE
)
3152 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
3153 if (xg_timer
) xg_stop_timer ();
3154 bar
->dragging
= Qnil
;
3160 /* Create a scroll bar widget for frame F. Store the scroll bar
3162 SCROLL_CALLBACK is the callback to invoke when the value of the
3164 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3165 to set resources for the widget. */
3168 xg_create_scroll_bar (f
, bar
, scroll_callback
, scroll_bar_name
)
3170 struct scroll_bar
*bar
;
3171 GCallback scroll_callback
;
3172 char *scroll_bar_name
;
3179 /* Page, step increment values are not so important here, they
3180 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3181 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3184 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3185 webox
= gtk_event_box_new ();
3186 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3187 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3189 scroll_id
= xg_store_widget_in_map (wscroll
);
3191 g_signal_connect (G_OBJECT (wscroll
),
3195 /* The EMACS_INT cast avoids a warning. */
3196 g_signal_connect (G_OBJECT (wscroll
),
3198 G_CALLBACK (xg_gtk_scroll_destroy
),
3199 (gpointer
) (EMACS_INT
) scroll_id
);
3201 /* Connect to button press and button release to detect if any scroll bar
3203 g_signal_connect (G_OBJECT (wscroll
),
3204 "button-press-event",
3205 G_CALLBACK (scroll_bar_button_cb
),
3207 g_signal_connect (G_OBJECT (wscroll
),
3208 "button-release-event",
3209 G_CALLBACK (scroll_bar_button_cb
),
3212 /* The scroll bar widget does not draw on a window of its own. Instead
3213 it draws on the parent window, in this case the edit widget. So
3214 whenever the edit widget is cleared, the scroll bar needs to redraw
3215 also, which causes flicker. Put an event box between the edit widget
3216 and the scroll bar, so the scroll bar instead draws itself on the
3217 event box window. */
3218 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3219 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3222 /* Set the cursor to an arrow. */
3223 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3225 bar
->x_window
= scroll_id
;
3228 /* Make the scroll bar represented by SCROLLBAR_ID visible. */
3231 xg_show_scroll_bar (scrollbar_id
)
3234 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3236 gtk_widget_show_all (gtk_widget_get_parent (w
));
3239 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3242 xg_remove_scroll_bar (f
, scrollbar_id
)
3246 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3249 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3250 gtk_widget_destroy (w
);
3251 gtk_widget_destroy (wparent
);
3252 SET_FRAME_GARBAGED (f
);
3256 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3258 TOP/LEFT are the new pixel positions where the bar shall appear.
3259 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3262 xg_update_scrollbar_pos (f
, scrollbar_id
, top
, left
, width
, height
)
3271 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3275 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3276 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3278 /* Move and resize to new values. */
3279 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3280 gtk_widget_set_size_request (wscroll
, width
, height
);
3281 gtk_widget_queue_draw (wparent
);
3282 gdk_window_process_all_updates ();
3283 /* GTK does not redraw until the main loop is entered again, but
3284 if there are no X events pending we will not enter it. So we sync
3285 here to get some events. */
3287 SET_FRAME_GARBAGED (f
);
3288 cancel_mouse_face (f
);
3292 /* Set the thumb size and position of scroll bar BAR. We are currently
3293 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3296 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
3297 struct scroll_bar
*bar
;
3298 int portion
, position
, whole
;
3300 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3302 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3304 if (wscroll
&& NILP (bar
->dragging
))
3313 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3315 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3316 rather than the real portion value. This makes the thumb less likely
3317 to resize and that looks better. */
3318 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3319 /* When the thumb is at the bottom, position == whole.
3320 So we need to increase `whole' to make space for the thumb. */
3327 top
= (gdouble
) position
/ whole
;
3328 shown
= (gdouble
) portion
/ whole
;
3331 size
= shown
* XG_SB_RANGE
;
3332 size
= min (size
, XG_SB_RANGE
);
3333 size
= max (size
, 1);
3335 value
= top
* XG_SB_RANGE
;
3336 value
= min (value
, XG_SB_MAX
- size
);
3337 value
= max (value
, XG_SB_MIN
);
3339 /* Assume all lines are of equal size. */
3340 new_step
= size
/ max (1, FRAME_LINES (f
));
3342 if ((int) adj
->page_size
!= size
3343 || (int) adj
->step_increment
!= new_step
)
3345 adj
->page_size
= size
;
3346 adj
->step_increment
= new_step
;
3347 /* Assume a page increment is about 95% of the page size */
3348 adj
->page_increment
= (int) (0.95*adj
->page_size
);
3352 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3354 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3358 /* gtk_range_set_value invokes the callback. Set
3359 ignore_gtk_scrollbar to make the callback do nothing */
3360 xg_ignore_gtk_scrollbar
= 1;
3362 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3363 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3365 gtk_adjustment_changed (adj
);
3367 xg_ignore_gtk_scrollbar
= 0;
3375 /***********************************************************************
3377 ***********************************************************************/
3378 /* The key for the data we put in the GtkImage widgets. The data is
3379 the image used by Emacs. We use this to see if we need to update
3380 the GtkImage with a new image. */
3381 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3383 /* The key for storing the latest modifiers so the activate callback can
3385 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3387 /* The key for storing the button widget in its proxy menu item. */
3388 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3390 /* The key for the data we put in the GtkImage widgets. The data is
3391 the stock name used by Emacs. We use this to see if we need to update
3392 the GtkImage with a new image. */
3393 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3395 /* As above, but this is used for named theme widgets, as opposed to
3397 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3399 /* Callback function invoked when a tool bar item is pressed.
3400 W is the button widget in the tool bar that got pressed,
3401 CLIENT_DATA is an integer that is the index of the button in the
3402 tool bar. 0 is the first button. */
3405 xg_tool_bar_button_cb (widget
, event
, user_data
)
3407 GdkEventButton
*event
;
3410 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3411 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3412 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3417 /* Callback function invoked when a tool bar item is pressed.
3418 W is the button widget in the tool bar that got pressed,
3419 CLIENT_DATA is an integer that is the index of the button in the
3420 tool bar. 0 is the first button. */
3423 xg_tool_bar_callback (w
, client_data
)
3425 gpointer client_data
;
3427 /* The EMACS_INT cast avoids a warning. */
3428 int idx
= (int) (EMACS_INT
) client_data
;
3429 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3430 XG_TOOL_BAR_LAST_MODIFIER
);
3432 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3433 Lisp_Object key
, frame
;
3434 struct input_event event
;
3437 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3440 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3442 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3443 XSETFRAME (frame
, f
);
3445 /* We generate two events here. The first one is to set the prefix
3446 to `(tool_bar)', see keyboard.c. */
3447 event
.kind
= TOOL_BAR_EVENT
;
3448 event
.frame_or_window
= frame
;
3450 kbd_buffer_store_event (&event
);
3452 event
.kind
= TOOL_BAR_EVENT
;
3453 event
.frame_or_window
= frame
;
3455 /* Convert between the modifier bits GDK uses and the modifier bits
3456 Emacs uses. This assumes GDK and X masks are the same, which they are when
3458 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3459 kbd_buffer_store_event (&event
);
3461 /* Return focus to the frame after we have clicked on a detached
3463 Fx_focus_frame (frame
);
3466 /* Callback function invoked when a tool bar item is pressed in a detached
3467 tool bar or the overflow drop down menu.
3468 We just call xg_tool_bar_callback.
3469 W is the menu item widget that got pressed,
3470 CLIENT_DATA is an integer that is the index of the button in the
3471 tool bar. 0 is the first button. */
3474 xg_tool_bar_proxy_callback (w
, client_data
)
3476 gpointer client_data
;
3478 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3479 XG_TOOL_BAR_PROXY_BUTTON
));
3480 xg_tool_bar_callback (wbutton
, client_data
);
3485 xg_tool_bar_help_callback
P_ ((GtkWidget
*w
,
3486 GdkEventCrossing
*event
,
3487 gpointer client_data
));
3489 /* This callback is called when a help is to be shown for an item in
3490 the detached tool bar when the detached tool bar it is not expanded. */
3493 xg_tool_bar_proxy_help_callback (w
, event
, client_data
)
3495 GdkEventCrossing
*event
;
3496 gpointer client_data
;
3498 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3499 XG_TOOL_BAR_PROXY_BUTTON
));
3501 xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3505 /* This callback is called when a tool item should create a proxy item,
3506 such as for the overflow menu. Also called when the tool bar is detached.
3507 If we don't create a proxy menu item, the detached tool bar will be
3511 xg_tool_bar_menu_proxy (toolitem
, user_data
)
3512 GtkToolItem
*toolitem
;
3515 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (toolitem
));
3516 GtkButton
*wbutton
= GTK_BUTTON (gtk_bin_get_child (GTK_BIN (weventbox
)));
3517 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label ("");
3518 GtkWidget
*wmenuimage
;
3520 if (gtk_button_get_use_stock (wbutton
))
3521 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3522 GTK_ICON_SIZE_MENU
);
3525 GtkImage
*wimage
= GTK_IMAGE (gtk_bin_get_child (GTK_BIN (wbutton
)));
3526 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3527 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3529 if (store_type
== GTK_IMAGE_STOCK
)
3532 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3533 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3535 else if (store_type
== GTK_IMAGE_ICON_SET
)
3537 GtkIconSet
*icon_set
;
3538 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3539 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3540 GTK_ICON_SIZE_MENU
);
3542 else if (store_type
== GTK_IMAGE_PIXBUF
)
3547 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3550 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3552 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3553 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3554 GDK_INTERP_BILINEAR
);
3556 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3560 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3564 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3566 const gchar
*icon_name
;
3567 GtkIconSize icon_size
;
3569 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3570 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3571 GTK_ICON_SIZE_MENU
);
3575 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3580 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3582 g_signal_connect (G_OBJECT (wmenuitem
),
3584 G_CALLBACK (xg_tool_bar_proxy_callback
),
3588 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3589 (gpointer
) wbutton
);
3590 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3591 gtk_widget_set_sensitive (wmenuitem
, GTK_WIDGET_SENSITIVE (wbutton
));
3593 /* Use enter/leave notify to show help. We use the events
3594 rather than the GtkButton specific signals "enter" and
3595 "leave", so we can have only one callback. The event
3596 will tell us what kind of event it is. */
3597 g_signal_connect (G_OBJECT (wmenuitem
),
3598 "enter-notify-event",
3599 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3601 g_signal_connect (G_OBJECT (wmenuitem
),
3602 "leave-notify-event",
3603 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3609 /* This callback is called when a tool bar is detached. We must set
3610 the height of the tool bar to zero when this happens so frame sizes
3611 are correctly calculated.
3612 WBOX is the handle box widget that enables detach/attach of the tool bar.
3613 W is the tool bar widget.
3614 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3617 xg_tool_bar_detach_callback (wbox
, w
, client_data
)
3620 gpointer client_data
;
3622 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3623 extern int x_gtk_whole_detached_tool_bar
;
3625 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3630 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3632 /* When detaching a tool bar, not everything dissapear. There are
3633 a few pixels left that are used to drop the tool bar back into
3635 FRAME_TOOLBAR_HEIGHT (f
) = 4;
3636 xg_height_changed (f
);
3640 /* This callback is called when a tool bar is reattached. We must set
3641 the height of the tool bar when this happens so frame sizes
3642 are correctly calculated.
3643 WBOX is the handle box widget that enables detach/attach of the tool bar.
3644 W is the tool bar widget.
3645 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3648 xg_tool_bar_attach_callback (wbox
, w
, client_data
)
3651 gpointer client_data
;
3653 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3654 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3660 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3662 gtk_widget_size_request (w
, &req
);
3663 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3664 xg_height_changed (f
);
3668 /* This callback is called when the mouse enters or leaves a tool bar item.
3669 It is used for displaying and hiding the help text.
3670 W is the tool bar item, a button.
3671 EVENT is either an enter event or leave event.
3672 CLIENT_DATA is an integer that is the index of the button in the
3673 tool bar. 0 is the first button.
3675 Returns FALSE to tell GTK to keep processing this event. */
3678 xg_tool_bar_help_callback (w
, event
, client_data
)
3680 GdkEventCrossing
*event
;
3681 gpointer client_data
;
3683 /* The EMACS_INT cast avoids a warning. */
3684 int idx
= (int) (EMACS_INT
) client_data
;
3685 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3686 Lisp_Object help
, frame
;
3688 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3691 if (event
->type
== GDK_ENTER_NOTIFY
)
3693 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3694 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3697 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3702 XSETFRAME (frame
, f
);
3703 kbd_buffer_store_help_event (frame
, help
);
3709 /* This callback is called when a tool bar item shall be redrawn.
3710 It modifies the expose event so that the GtkImage widget redraws the
3711 whole image. This to overcome a bug that makes GtkImage draw the image
3712 in the wrong place when it tries to redraw just a part of the image.
3713 W is the GtkImage to be redrawn.
3714 EVENT is the expose event for W.
3715 CLIENT_DATA is unused.
3717 Returns FALSE to tell GTK to keep processing this event. */
3720 xg_tool_bar_item_expose_callback (w
, event
, client_data
)
3722 GdkEventExpose
*event
;
3723 gpointer client_data
;
3727 gdk_drawable_get_size (event
->window
, &width
, &height
);
3729 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3730 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3732 event
->area
.x
= max (0, event
->area
.x
);
3733 event
->area
.y
= max (0, event
->area
.y
);
3735 event
->area
.width
= max (width
, event
->area
.width
);
3736 event
->area
.height
= max (height
, event
->area
.height
);
3741 /* Attach a tool bar to frame F. */
3744 xg_pack_tool_bar (f
)
3747 struct x_output
*x
= f
->output_data
.x
;
3748 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3750 x
->handlebox_widget
= gtk_handle_box_new ();
3751 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3752 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3753 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3754 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3756 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3759 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3762 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3764 gtk_widget_show_all (x
->handlebox_widget
);
3767 /* Create a tool bar for frame F. */
3770 xg_create_tool_bar (f
)
3773 struct x_output
*x
= f
->output_data
.x
;
3776 x
->toolbar_widget
= gtk_toolbar_new ();
3777 x
->toolbar_detached
= 0;
3779 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3781 /* We only have icons, so override any user setting. We could
3782 use the caption property of the toolbar item (see update_frame_tool_bar
3783 below), but some of those strings are long, making the toolbar so
3784 long it does not fit on the screen. The GtkToolbar widget makes every
3785 item equal size, so the longest caption determine the size of every
3786 tool bar item. I think the creators of the GtkToolbar widget
3787 counted on 4 or 5 character long strings. */
3788 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3789 gtk_toolbar_set_orientation (GTK_TOOLBAR (x
->toolbar_widget
),
3790 GTK_ORIENTATION_HORIZONTAL
);
3794 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3796 /* Find the right-to-left image named by RTL in the tool bar images for F.
3797 Returns IMAGE if RTL is not found. */
3800 find_rtl_image (f
, image
, rtl
)
3806 Lisp_Object file
, rtl_name
;
3807 struct gcpro gcpro1
, gcpro2
;
3808 GCPRO2 (file
, rtl_name
);
3810 rtl_name
= Ffile_name_nondirectory (rtl
);
3812 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3814 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3815 if (!NILP (file
= file_for_image (rtl_image
)))
3817 file
= call1 (intern ("file-name-sans-extension"),
3818 Ffile_name_nondirectory (file
));
3819 if (EQ (Fequal (file
, rtl_name
), Qt
))
3830 /* Update the tool bar for frame F. Add new buttons and remove old. */
3832 extern Lisp_Object Qx_gtk_map_stock
;
3835 update_frame_tool_bar (f
)
3839 GtkRequisition old_req
, new_req
;
3840 struct x_output
*x
= f
->output_data
.x
;
3841 int hmargin
= 0, vmargin
= 0;
3842 GtkToolbar
*wtoolbar
;
3844 GtkTextDirection dir
;
3845 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
3847 if (! FRAME_GTK_WIDGET (f
))
3852 if (INTEGERP (Vtool_bar_button_margin
)
3853 && XINT (Vtool_bar_button_margin
) > 0)
3855 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3856 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3858 else if (CONSP (Vtool_bar_button_margin
))
3860 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3861 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3862 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3864 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3865 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3866 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3869 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3870 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3871 i.e. zero. This means that margins less than
3872 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3873 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3874 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3876 if (! x
->toolbar_widget
)
3877 xg_create_tool_bar (f
);
3879 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
3880 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &old_req
);
3881 dir
= gtk_widget_get_direction (x
->toolbar_widget
);
3883 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3885 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3886 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3890 struct image
*img
= NULL
;
3892 Lisp_Object stock
= Qnil
;
3893 GtkStockItem stock_item
;
3894 char *stock_name
= NULL
;
3895 char *icon_name
= NULL
;
3897 GtkWidget
*wbutton
= NULL
;
3898 GtkWidget
*weventbox
;
3899 Lisp_Object specified_file
;
3901 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (x
->toolbar_widget
), i
);
3905 weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3906 wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3909 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3911 /* Ignore invalid image specifications. */
3912 if (!valid_image_p (image
))
3914 if (wbutton
) gtk_widget_hide (wbutton
);
3918 specified_file
= file_for_image (image
);
3919 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
3920 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
3922 if (STRINGP (stock
))
3924 stock_name
= SSDATA (stock
);
3925 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
3927 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
3928 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
3930 icon_name
= stock_name
+ 2;
3934 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
3937 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3939 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
3940 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3948 if (stock_name
== NULL
&& icon_name
== NULL
)
3950 /* No stock image, or stock item not known. Try regular image. */
3952 /* If image is a vector, choose the image according to the
3954 if (dir
== GTK_TEXT_DIR_RTL
3955 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
3958 image
= find_rtl_image (f
, image
, rtl
);
3961 if (VECTORP (image
))
3965 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3966 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3969 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3970 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3972 xassert (ASIZE (image
) >= idx
);
3973 image
= AREF (image
, idx
);
3978 img_id
= lookup_image (f
, image
);
3979 img
= IMAGE_FROM_ID (f
, img_id
);
3980 prepare_image_for_display (f
, img
);
3982 if (img
->load_failed_p
|| img
->pixmap
== None
)
3985 gtk_widget_hide_all (GTK_WIDGET (ti
));
3988 /* Insert an empty (non-image) button */
3989 weventbox
= gtk_event_box_new ();
3990 wbutton
= gtk_button_new ();
3991 gtk_button_set_focus_on_click (GTK_BUTTON (wbutton
), FALSE
);
3992 gtk_button_set_relief (GTK_BUTTON (wbutton
),
3994 gtk_container_add (GTK_CONTAINER (weventbox
), wbutton
);
3995 ti
= gtk_tool_item_new ();
3996 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
3997 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
), ti
, -1);
4008 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4009 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4010 (gpointer
) xstrdup (stock_name
),
4011 (GDestroyNotify
) xfree
);
4015 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4016 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4017 (gpointer
) xstrdup (icon_name
),
4018 (GDestroyNotify
) xfree
);
4022 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4023 /* Save the image so we can see if an update is needed when
4024 this function is called again. */
4025 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4026 (gpointer
)img
->pixmap
);
4029 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4030 wbutton
= gtk_button_new ();
4031 gtk_button_set_focus_on_click (GTK_BUTTON (wbutton
), FALSE
);
4032 gtk_button_set_relief (GTK_BUTTON (wbutton
), GTK_RELIEF_NONE
);
4033 gtk_container_add (GTK_CONTAINER (wbutton
), w
);
4034 weventbox
= gtk_event_box_new ();
4035 gtk_container_add (GTK_CONTAINER (weventbox
), wbutton
);
4036 ti
= gtk_tool_item_new ();
4037 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4038 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
), ti
, -1);
4041 /* The EMACS_INT cast avoids a warning. */
4042 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4043 G_CALLBACK (xg_tool_bar_menu_proxy
),
4044 (gpointer
) (EMACS_INT
) i
);
4046 g_signal_connect (G_OBJECT (wbutton
), "clicked",
4047 G_CALLBACK (xg_tool_bar_callback
),
4048 (gpointer
) (EMACS_INT
) i
);
4050 gtk_widget_show_all (GTK_WIDGET (ti
));
4053 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4055 /* Catch expose events to overcome an annoying redraw bug, see
4056 comment for xg_tool_bar_item_expose_callback. */
4057 g_signal_connect (G_OBJECT (ti
),
4059 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4062 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4063 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4065 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
4066 no distinction based on modifiers in the activate callback,
4067 so we have to do it ourselves. */
4068 g_signal_connect (wbutton
, "button-release-event",
4069 G_CALLBACK (xg_tool_bar_button_cb
),
4072 g_object_set_data (G_OBJECT (wbutton
), XG_FRAME_DATA
, (gpointer
)f
);
4074 /* Use enter/leave notify to show help. We use the events
4075 rather than the GtkButton specific signals "enter" and
4076 "leave", so we can have only one callback. The event
4077 will tell us what kind of event it is. */
4078 /* The EMACS_INT cast avoids a warning. */
4079 g_signal_connect (G_OBJECT (weventbox
),
4080 "enter-notify-event",
4081 G_CALLBACK (xg_tool_bar_help_callback
),
4082 (gpointer
) (EMACS_INT
) i
);
4083 g_signal_connect (G_OBJECT (weventbox
),
4084 "leave-notify-event",
4085 G_CALLBACK (xg_tool_bar_help_callback
),
4086 (gpointer
) (EMACS_INT
) i
);
4090 GtkWidget
*wimage
= gtk_bin_get_child (GTK_BIN (wbutton
));
4091 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
4092 XG_TOOL_BAR_IMAGE_DATA
);
4093 gpointer old_stock_name
= g_object_get_data (G_OBJECT (wimage
),
4094 XG_TOOL_BAR_STOCK_NAME
);
4095 gpointer old_icon_name
= g_object_get_data (G_OBJECT (wimage
),
4096 XG_TOOL_BAR_ICON_NAME
);
4098 (! old_stock_name
|| strcmp (old_stock_name
, stock_name
) != 0))
4100 gtk_image_set_from_stock (GTK_IMAGE (wimage
),
4101 stock_name
, icon_size
);
4102 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4103 (gpointer
) xstrdup (stock_name
),
4104 (GDestroyNotify
) xfree
);
4105 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4107 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
, NULL
);
4109 else if (icon_name
&&
4110 (! old_icon_name
|| strcmp (old_icon_name
, icon_name
) != 0))
4112 gtk_image_set_from_icon_name (GTK_IMAGE (wimage
),
4113 icon_name
, icon_size
);
4114 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4115 (gpointer
) xstrdup (icon_name
),
4116 (GDestroyNotify
) xfree
);
4117 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4119 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4122 else if (img
&& old_img
!= img
->pixmap
)
4124 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
4125 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4126 (gpointer
)img
->pixmap
);
4128 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4130 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
, NULL
);
4133 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
4135 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4136 gtk_widget_show_all (GTK_WIDGET (ti
));
4142 /* Remove buttons not longer needed. We just hide them so they
4143 can be reused later on. */
4146 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (x
->toolbar_widget
), i
++);
4147 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
4148 } while (ti
!= NULL
);
4151 if (pack_tool_bar
&& f
->n_tool_bar_items
!= 0)
4152 xg_pack_tool_bar (f
);
4155 gtk_widget_size_request (GTK_WIDGET (x
->toolbar_widget
), &new_req
);
4156 if (old_req
.height
!= new_req
.height
4157 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
4159 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
4160 xg_height_changed (f
);
4165 /* Deallocate all resources for the tool bar on frame F.
4166 Remove the tool bar. */
4169 free_frame_tool_bar (f
)
4172 struct x_output
*x
= f
->output_data
.x
;
4174 if (x
->toolbar_widget
)
4176 int is_packed
= x
->handlebox_widget
!= 0;
4178 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4179 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4181 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4182 x
->handlebox_widget
);
4184 gtk_widget_destroy (x
->toolbar_widget
);
4186 x
->toolbar_widget
= 0;
4187 x
->handlebox_widget
= 0;
4188 FRAME_TOOLBAR_HEIGHT (f
) = 0;
4189 xg_height_changed (f
);
4197 /***********************************************************************
4199 ***********************************************************************/
4203 GtkBindingSet
*binding_set
;
4206 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4207 we keep it permanently linked in. */
4212 xg_ignore_gtk_scrollbar
= 0;
4213 xg_detached_menus
= 0;
4214 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4215 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4217 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4218 id_to_widget
.widgets
= 0;
4220 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4221 bindings. It doesn't seem to be any way to remove properties,
4222 so we set it to VoidSymbol which in X means "no key". */
4223 gtk_settings_set_string_property (gtk_settings_get_default (),
4224 "gtk-menu-bar-accel",
4228 /* Make GTK text input widgets use Emacs style keybindings. This is
4230 gtk_settings_set_string_property (gtk_settings_get_default (),
4231 "gtk-key-theme-name",
4235 /* Make dialogs close on C-g. Since file dialog inherits from
4236 dialog, this works for them also. */
4237 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4238 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4241 /* Make menus close on C-g. */
4242 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4243 (GTK_TYPE_MENU_SHELL
));
4244 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4248 #endif /* USE_GTK */
4250 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
4251 (do not change this comment) */