1 /* Functions for creating and updating GTK widgets.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
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/>. */
28 #include "blockinput.h"
29 #include "syssignal.h"
33 #include "termhooks.h"
37 #include <gdk/gdkkeysyms.h>
40 #include <X11/Xft/Xft.h>
43 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
44 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
46 /* Avoid "differ in sign" warnings */
47 #define SSDATA(x) ((char *) SDATA (x))
50 /***********************************************************************
51 Display handling functions
52 ***********************************************************************/
54 #ifdef HAVE_GTK_MULTIDISPLAY
56 /* Keep track of the default display, or NULL if there is none. Emacs
57 may close all its displays. */
59 static GdkDisplay
*gdpy_def
;
61 /* Return the GdkDisplay that corresponds to the X display DPY. */
64 xg_get_gdk_display (dpy
)
67 return gdk_x11_lookup_xdisplay (dpy
);
70 /* When the GTK widget W is to be created on a display for F that
71 is not the default display, set the display for W.
72 W can be a GtkMenu or a GtkWindow widget. */
79 if (FRAME_X_DISPLAY (f
) != GDK_DISPLAY ())
81 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
82 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
85 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
87 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
92 #else /* not HAVE_GTK_MULTIDISPLAY */
94 /* Make some defines so we can use the GTK 2.2 functions when
95 compiling with GTK 2.0. */
97 #define xg_set_screen(w, f)
98 #define gdk_xid_table_lookup_for_display(dpy, w) gdk_xid_table_lookup (w)
99 #define gdk_pixmap_foreign_new_for_display(dpy, p) gdk_pixmap_foreign_new (p)
100 #define gdk_cursor_new_for_display(dpy, c) gdk_cursor_new (c)
101 #define gdk_x11_lookup_xdisplay(dpy) 0
102 #define GdkDisplay void
104 #endif /* not HAVE_GTK_MULTIDISPLAY */
106 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
107 *DPY is set to NULL if the display can't be opened.
109 Returns non-zero if display could be opened, zero if display could not
110 be opened, and less than zero if the GTK version doesn't support
114 xg_display_open (display_name
, dpy
)
118 #ifdef HAVE_GTK_MULTIDISPLAY
121 gdpy
= gdk_display_open (display_name
);
123 gdk_display_manager_set_default_display (gdk_display_manager_get (),
126 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
129 #else /* not HAVE_GTK_MULTIDISPLAY */
132 #endif /* not HAVE_GTK_MULTIDISPLAY */
136 /* Close display DPY. */
139 xg_display_close (Display
*dpy
)
141 #ifdef HAVE_GTK_MULTIDISPLAY
142 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
144 /* If this is the default display, try to change it before closing.
145 If there is no other display to use, gdpy_def is set to NULL, and
146 the next call to xg_display_open resets the default display. */
147 if (gdk_display_get_default () == gdpy
)
149 struct x_display_info
*dpyinfo
;
150 GdkDisplay
*gdpy_new
= NULL
;
152 /* Find another display. */
153 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
154 if (dpyinfo
->display
!= dpy
)
156 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
157 gdk_display_manager_set_default_display (gdk_display_manager_get (),
164 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
165 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
166 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
167 can continue running, but there will be memory leaks. */
168 g_object_run_dispose (G_OBJECT (gdpy
));
170 /* This seems to be fixed in GTK 2.10. */
171 gdk_display_close (gdpy
);
173 #endif /* HAVE_GTK_MULTIDISPLAY */
177 /***********************************************************************
179 ***********************************************************************/
180 /* The timer for scroll bar repetition and menu bar timeouts.
181 NULL if no timer is started. */
182 static struct atimer
*xg_timer
;
185 /* The next two variables and functions are taken from lwlib. */
186 static widget_value
*widget_value_free_list
;
187 static int malloc_cpt
;
189 /* Allocate a widget_value structure, either by taking one from the
190 widget_value_free_list or by malloc:ing a new one.
192 Return a pointer to the allocated structure. */
195 malloc_widget_value ()
198 if (widget_value_free_list
)
200 wv
= widget_value_free_list
;
201 widget_value_free_list
= wv
->free_list
;
206 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
209 memset (wv
, 0, sizeof (widget_value
));
213 /* This is analogous to free. It frees only what was allocated
214 by malloc_widget_value, and no substructures. */
217 free_widget_value (wv
)
225 /* When the number of already allocated cells is too big,
232 wv
->free_list
= widget_value_free_list
;
233 widget_value_free_list
= wv
;
238 /* Create and return the cursor to be used for popup menus and
239 scroll bars on display DPY. */
242 xg_create_default_cursor (dpy
)
245 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
246 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
249 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
252 xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
)
257 int x
, y
, width
, height
, rowstride
, mask_rowstride
;
258 GdkPixbuf
*icon_buf
, *tmp_buf
;
262 gdk_drawable_get_size (gpix
, &width
, &height
);
263 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
264 0, 0, 0, 0, width
, height
);
265 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
266 g_object_unref (G_OBJECT (tmp_buf
));
270 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
275 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
276 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
277 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
278 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
281 for (y
= 0; y
< height
; ++y
)
283 guchar
*iconptr
, *maskptr
;
286 iconptr
= pixels
+ y
* rowstride
;
287 maskptr
= mask_pixels
+ y
* mask_rowstride
;
289 for (x
= 0; x
< width
; ++x
)
291 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
292 just R is sufficient. */
294 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
296 iconptr
+= rowstride
/width
;
297 maskptr
+= mask_rowstride
/width
;
301 g_object_unref (G_OBJECT (mask_buf
));
308 file_for_image(image
)
311 Lisp_Object specified_file
= Qnil
;
313 extern Lisp_Object QCfile
;
315 for (tail
= XCDR (image
);
316 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
317 tail
= XCDR (XCDR (tail
)))
318 if (EQ (XCAR (tail
), QCfile
))
319 specified_file
= XCAR (XCDR (tail
));
321 return specified_file
;
324 /* For the image defined in IMG, make and return a GtkImage. For displays with
325 8 planes or less we must make a GdkPixbuf and apply the mask manually.
326 Otherwise the highlightning and dimming the tool bar code in GTK does
327 will look bad. For display with more than 8 planes we just use the
328 pixmap and mask directly. For monochrome displays, GTK doesn't seem
329 able to use external pixmaps, it looks bad whatever we do.
330 The image is defined on the display where frame F is.
331 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
332 If OLD_WIDGET is NULL, a new widget is constructed and returned.
333 If OLD_WIDGET is not NULL, that widget is modified. */
336 xg_get_image_for_pixmap (f
, img
, widget
, old_widget
)
340 GtkImage
*old_widget
;
348 /* If we have a file, let GTK do all the image handling.
349 This seems to be the only way to make insensitive and activated icons
350 look good in all cases. */
351 Lisp_Object specified_file
= file_for_image (img
->spec
);
354 /* We already loaded the image once before calling this
355 function, so this only fails if the image file has been removed.
356 In that case, use the pixmap already loaded. */
358 if (STRINGP (specified_file
)
359 && STRINGP (file
= x_find_image_file (specified_file
)))
362 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
364 gtk_image_set_from_file (old_widget
, SSDATA (file
));
366 return GTK_WIDGET (old_widget
);
369 /* No file, do the image handling ourselves. This will look very bad
370 on a monochrome display, and sometimes bad on all displays with
373 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
374 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
375 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
377 /* This is a workaround to make icons look good on pseudo color
378 displays. Apparently GTK expects the images to have an alpha
379 channel. If they don't, insensitive and activated icons will
380 look bad. This workaround does not work on monochrome displays,
381 and is strictly not needed on true color/static color displays (i.e.
382 16 bits and higher). But we do it anyway so we get a pixbuf that is
383 not associated with the img->pixmap. The img->pixmap may be removed
384 by clearing the image cache and then the tool bar redraw fails, since
385 Gtk+ assumes the pixmap is always there. */
386 cmap
= gtk_widget_get_colormap (widget
);
387 icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
390 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
392 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
394 g_object_unref (G_OBJECT (icon_buf
));
396 g_object_unref (G_OBJECT (gpix
));
397 if (gmask
) g_object_unref (G_OBJECT (gmask
));
399 return GTK_WIDGET (old_widget
);
403 /* Set CURSOR on W and all widgets W contain. We must do like this
404 for scroll bars and menu because they create widgets internally,
405 and it is those widgets that are visible. */
408 xg_set_cursor (w
, cursor
)
412 GList
*children
= gdk_window_peek_children (w
->window
);
414 gdk_window_set_cursor (w
->window
, cursor
);
416 /* The scroll bar widget has more than one GDK window (had to look at
417 the source to figure this out), and there is no way to set cursor
418 on widgets in GTK. So we must set the cursor for all GDK windows.
421 for ( ; children
; children
= g_list_next (children
))
422 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
425 /* Timer function called when a timeout occurs for xg_timer.
426 This function processes all GTK events in a recursive event loop.
427 This is done because GTK timer events are not seen by Emacs event
428 detection, Emacs only looks for X events. When a scroll bar has the
429 pointer (detected by button press/release events below) an Emacs
430 timer is started, and this function can then check if the GTK timer
431 has expired by calling the GTK event loop.
432 Also, when a menu is active, it has a small timeout before it
433 pops down the sub menu under it. */
436 xg_process_timeouts (timer
)
437 struct atimer
*timer
;
440 /* Ideally we would like to just handle timer events, like the Xt version
441 of this does in xterm.c, but there is no such feature in GTK. */
442 while (gtk_events_pending ())
443 gtk_main_iteration ();
447 /* Start the xg_timer with an interval of 0.1 seconds, if not already started.
448 xg_process_timeouts is called when the timer expires. The timer
449 started is continuous, i.e. runs until xg_stop_timer is called. */
457 EMACS_SET_SECS_USECS (interval
, 0, 100000);
458 xg_timer
= start_atimer (ATIMER_CONTINUOUS
,
465 /* Stop the xg_timer if started. */
472 cancel_atimer (xg_timer
);
477 /* Insert NODE into linked LIST. */
480 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
482 xg_list_node
*list_start
= list
->next
;
484 if (list_start
) list_start
->prev
= node
;
485 node
->next
= list_start
;
490 /* Remove NODE from linked LIST. */
493 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
495 xg_list_node
*list_start
= list
->next
;
496 if (node
== list_start
)
498 list
->next
= node
->next
;
499 if (list
->next
) list
->next
->prev
= 0;
503 node
->prev
->next
= node
->next
;
504 if (node
->next
) node
->next
->prev
= node
->prev
;
508 /* Allocate and return a utf8 version of STR. If STR is already
509 utf8 or NULL, just return STR.
510 If not, a new string is allocated and the caller must free the result
514 get_utf8_string (str
)
517 char *utf8_str
= str
;
519 if (!str
) return NULL
;
521 /* If not UTF-8, try current locale. */
522 if (!g_utf8_validate (str
, -1, NULL
))
523 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
527 /* Probably some control characters in str. Escape them. */
531 unsigned char *p
= (unsigned char *)str
;
533 GError
*error
= NULL
;
535 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
536 &bytes_written
, &error
))
537 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
540 p
+= bytes_written
+1;
541 g_error_free (error
);
547 g_error_free (error
);
552 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
553 p
= (unsigned char *)str
;
555 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
556 &bytes_written
, &error
))
557 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
559 strncpy (up
, (char *)p
, bytes_written
);
560 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
561 up
[bytes_written
+4] = '\0';
562 up
+= bytes_written
+4;
563 p
+= bytes_written
+1;
564 g_error_free (error
);
570 strcat (utf8_str
, cp
);
575 g_error_free (error
);
584 /***********************************************************************
585 General functions for creating widgets, resizing, events, e.t.c.
586 ***********************************************************************/
588 /* Make a geometry string and pass that to GTK. It seems this is the
589 only way to get geometry position right if the user explicitly
590 asked for a position when starting Emacs.
591 F is the frame we shall set geometry for. */
597 if (f
->size_hint_flags
& USPosition
)
599 int left
= f
->left_pos
;
600 int xneg
= f
->size_hint_flags
& XNegative
;
601 int top
= f
->top_pos
;
602 int yneg
= f
->size_hint_flags
& YNegative
;
610 sprintf (geom_str
, "=%dx%d%c%d%c%d",
611 FRAME_PIXEL_WIDTH (f
),
612 FRAME_TOTAL_PIXEL_HEIGHT (f
),
613 (xneg
? '-' : '+'), left
,
614 (yneg
? '-' : '+'), top
);
616 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
618 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
620 else if (f
->size_hint_flags
& PPosition
)
621 gtk_window_move (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
622 f
->left_pos
, f
->top_pos
);
626 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
627 and a Gtk+ menu bar, we get resize events for the edit part of the
628 frame only. We let Gtk+ deal with the Gtk+ parts.
629 F is the frame to resize.
630 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
633 xg_frame_resized (f
, pixelwidth
, pixelheight
)
635 int pixelwidth
, pixelheight
;
637 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
638 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
640 if (FRAME_GTK_WIDGET (f
)
641 && (columns
!= FRAME_COLS (f
)
642 || rows
!= FRAME_LINES (f
)
643 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
644 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
)))
646 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
647 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
649 if (rows
!= FRAME_LINES (f
) || columns
!= FRAME_COLS (f
)
650 || (f
->new_text_lines
!= 0 && f
->new_text_lines
!= rows
)
651 || (f
->new_text_cols
!= 0 && f
->new_text_cols
!= columns
))
653 change_frame_size (f
, rows
, columns
, 0, 1, 0);
654 SET_FRAME_GARBAGED (f
);
655 cancel_mouse_face (f
);
660 /* Process all pending events on the display for frame F. */
666 gdk_window_process_all_updates ();
668 while (gtk_events_pending ())
670 gtk_main_iteration ();
671 gdk_window_process_all_updates ();
676 /* Turn wm hints for resize off on frame F */
679 x_wm_size_hint_off (f
)
682 GdkGeometry size_hints
;
684 memset (&size_hints
, 0, sizeof (size_hints
));
685 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
686 size_hints
.width_inc
= 1;
687 size_hints
.height_inc
= 1;
688 hint_flags
|= GDK_HINT_BASE_SIZE
;
689 size_hints
.base_width
= 1;
690 size_hints
.base_height
= 1;
691 size_hints
.min_width
= 1;
692 size_hints
.min_height
= 1;
693 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
697 /* Make sure these get set again in next call to x_wm_set_size_hint. */
698 f
->output_data
.x
->hint_flags
&= ~hint_flags
;
702 /* Resize the outer window of frame F after chainging the height.
703 This happend when the menu bar or the tool bar is added or removed.
704 COLUMNS/ROWS is the size the edit area shall have after the resize. */
707 xg_frame_set_char_size (f
, cols
, rows
)
712 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
713 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
716 if (FRAME_PIXEL_HEIGHT (f
) == 0)
719 /* Take into account the size of the scroll bar. Always use the
720 number of columns occupied by the scroll bar here otherwise we
721 might end up with a frame width that is not a multiple of the
722 frame's character width which is bad for vertically split
724 f
->scroll_bar_actual_width
725 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
727 compute_fringe_widths (f
, 0);
729 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
730 after calculating that value. */
731 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
733 /* Must resize our top level widget. Font size may have changed,
735 Turn wm hints (min/max size and size increments) of temporarly.
736 It interferes too much, when for example adding or removing the
738 x_wm_size_hint_off (f
);
739 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
740 pixelwidth
, pixelheight
);
742 x_wm_set_size_hint (f
, 0, 0);
745 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
746 Must be done like this, because GtkWidget:s can have "hidden"
747 X Window that aren't accessible.
749 Return 0 if no widget match WDESC. */
752 xg_win_to_widget (dpy
, wdesc
)
757 GtkWidget
*gwdesc
= 0;
761 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
766 event
.any
.window
= gdkwin
;
767 gwdesc
= gtk_get_event_widget (&event
);
774 /* Fill in the GdkColor C so that it represents PIXEL.
775 W is the widget that color will be used for. Used to find colormap. */
778 xg_pix_to_gcolor (w
, pixel
, c
)
783 GdkColormap
*map
= gtk_widget_get_colormap (w
);
784 gdk_colormap_query_color (map
, pixel
, c
);
787 /* Create and set up the GTK widgets for frame F.
788 Return 0 if creation failed, non-zero otherwise. */
791 xg_create_frame_widgets (f
)
804 if (FRAME_X_EMBEDDED_P (f
))
805 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
807 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
809 xg_set_screen (wtop
, f
);
811 wvbox
= gtk_vbox_new (FALSE
, 0);
812 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
814 if (! wtop
|| ! wvbox
|| ! wfixed
)
816 if (wtop
) gtk_widget_destroy (wtop
);
817 if (wvbox
) gtk_widget_destroy (wvbox
);
818 if (wfixed
) gtk_widget_destroy (wfixed
);
824 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
825 gtk_widget_set_name (wtop
, EMACS_CLASS
);
826 gtk_widget_set_name (wvbox
, "pane");
827 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
829 /* If this frame has a title or name, set it in the title bar. */
830 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
831 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
833 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
835 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
836 FRAME_GTK_WIDGET (f
) = wfixed
;
837 f
->output_data
.x
->vbox_widget
= wvbox
;
839 gtk_fixed_set_has_window (GTK_FIXED (wfixed
), TRUE
);
841 gtk_widget_set_size_request (wfixed
, FRAME_PIXEL_WIDTH (f
),
842 FRAME_PIXEL_HEIGHT (f
));
844 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
845 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
847 if (FRAME_EXTERNAL_TOOL_BAR (f
))
848 update_frame_tool_bar (f
);
850 /* We don't want this widget double buffered, because we draw on it
851 with regular X drawing primitives, so from a GTK/GDK point of
852 view, the widget is totally blank. When an expose comes, this
853 will make the widget blank, and then Emacs redraws it. This flickers
854 a lot, so we turn off double buffering. */
855 gtk_widget_set_double_buffered (wfixed
, FALSE
);
857 /* GTK documents says use gtk_window_set_resizable. But then a user
858 can't shrink the window from its starting size. */
859 gtk_window_set_policy (GTK_WINDOW (wtop
), TRUE
, TRUE
, TRUE
);
860 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
861 SSDATA (Vx_resource_name
),
862 SSDATA (Vx_resource_class
));
864 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
865 GTK is to destroy the widget. We want Emacs to do that instead. */
866 g_signal_connect (G_OBJECT (wtop
), "delete-event",
867 G_CALLBACK (gtk_true
), 0);
869 /* Convert our geometry parameters into a geometry string
871 GTK will itself handle calculating the real position this way. */
874 gtk_widget_add_events (wfixed
,
875 GDK_POINTER_MOTION_MASK
877 | GDK_BUTTON_PRESS_MASK
878 | GDK_BUTTON_RELEASE_MASK
880 | GDK_ENTER_NOTIFY_MASK
881 | GDK_LEAVE_NOTIFY_MASK
882 | GDK_FOCUS_CHANGE_MASK
884 | GDK_VISIBILITY_NOTIFY_MASK
);
886 /* Must realize the windows so the X window gets created. It is used
887 by callers of this function. */
888 gtk_widget_realize (wfixed
);
889 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
891 /* Since GTK clears its window by filling with the background color,
892 we must keep X and GTK background in sync. */
893 xg_pix_to_gcolor (wfixed
, FRAME_BACKGROUND_PIXEL (f
), &bg
);
894 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
896 /* Also, do not let any background pixmap to be set, this looks very
897 bad as Emacs overwrites the background pixmap with its own idea
898 of background color. */
899 style
= gtk_widget_get_modifier_style (wfixed
);
901 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
902 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
903 gtk_widget_modify_style (wfixed
, style
);
905 /* GTK does not set any border, and they look bad with GTK. */
906 /* That they look bad is no excuse for imposing this here. --Stef
907 It should be done by providing the proper default in Fx_create_Frame.
909 f->internal_border_width = 0; */
916 /* Set the normal size hints for the window manager, for frame F.
917 FLAGS is the flags word to use--or 0 meaning preserve the flags
918 that the window now has.
919 If USER_POSITION is nonzero, we set the User Position
920 flag (this is useful when FLAGS is 0). */
923 x_wm_set_size_hint (f
, flags
, user_position
)
928 /* Don't set size hints during initialization; that apparently leads
929 to a race condition. See the thread at
930 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
931 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
934 /* Must use GTK routines here, otherwise GTK resets the size hints
935 to its own defaults. */
936 GdkGeometry size_hints
;
938 int base_width
, base_height
;
939 int min_rows
= 0, min_cols
= 0;
940 int win_gravity
= f
->win_gravity
;
944 memset (&size_hints
, 0, sizeof (size_hints
));
945 f
->output_data
.x
->size_hints
= size_hints
;
946 f
->output_data
.x
->hint_flags
= hint_flags
;
949 flags
= f
->size_hint_flags
;
951 size_hints
= f
->output_data
.x
->size_hints
;
952 hint_flags
= f
->output_data
.x
->hint_flags
;
954 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
955 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
956 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
958 hint_flags
|= GDK_HINT_BASE_SIZE
;
959 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
960 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
961 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
963 check_frame_size (f
, &min_rows
, &min_cols
);
965 size_hints
.base_width
= base_width
;
966 size_hints
.base_height
= base_height
;
967 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
968 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
970 /* These currently have a one to one mapping with the X values, but I
971 don't think we should rely on that. */
972 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
973 size_hints
.win_gravity
= 0;
974 if (win_gravity
== NorthWestGravity
)
975 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
976 else if (win_gravity
== NorthGravity
)
977 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
978 else if (win_gravity
== NorthEastGravity
)
979 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
980 else if (win_gravity
== WestGravity
)
981 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
982 else if (win_gravity
== CenterGravity
)
983 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
984 else if (win_gravity
== EastGravity
)
985 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
986 else if (win_gravity
== SouthWestGravity
)
987 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
988 else if (win_gravity
== SouthGravity
)
989 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
990 else if (win_gravity
== SouthEastGravity
)
991 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
992 else if (win_gravity
== StaticGravity
)
993 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
995 if (flags
& PPosition
) hint_flags
|= GDK_HINT_POS
;
996 if (flags
& USPosition
) hint_flags
|= GDK_HINT_USER_POS
;
997 if (flags
& USSize
) hint_flags
|= GDK_HINT_USER_SIZE
;
1001 hint_flags
&= ~GDK_HINT_POS
;
1002 hint_flags
|= GDK_HINT_USER_POS
;
1005 if (hint_flags
!= f
->output_data
.x
->hint_flags
1006 || memcmp (&size_hints
,
1007 &f
->output_data
.x
->size_hints
,
1008 sizeof (size_hints
)) != 0)
1011 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1012 NULL
, &size_hints
, hint_flags
);
1013 f
->output_data
.x
->size_hints
= size_hints
;
1014 f
->output_data
.x
->hint_flags
= hint_flags
;
1019 /* Change background color of a frame.
1020 Since GTK uses the background color to clear the window, we must
1021 keep the GTK and X colors in sync.
1022 F is the frame to change,
1023 BG is the pixel value to change to. */
1026 xg_set_background_color (f
, bg
)
1030 if (FRAME_GTK_WIDGET (f
))
1035 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
1036 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
1042 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1043 functions so GTK does not overwrite the icon. */
1046 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
)
1051 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1052 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
1053 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
1054 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
1056 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1061 /***********************************************************************
1063 ***********************************************************************/
1064 /* Return the dialog title to use for a dialog of type KEY.
1065 This is the encoding used by lwlib. We use the same for GTK. */
1068 get_dialog_title (char key
)
1078 title
= "Information";
1097 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1098 the dialog, but return TRUE so the event does not propagate further
1099 in GTK. This prevents GTK from destroying the dialog widget automatically
1100 and we can always destrou the widget manually, regardles of how
1101 it was popped down (button press or WM_DELETE_WINDOW).
1102 W is the dialog widget.
1103 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1104 user_data is NULL (not used).
1106 Returns TRUE to end propagation of event. */
1109 dialog_delete_callback (w
, event
, user_data
)
1114 gtk_widget_unmap (w
);
1118 /* Create a popup dialog window. See also xg_create_widget below.
1119 WV is a widget_value describing the dialog.
1120 SELECT_CB is the callback to use when a button has been pressed.
1121 DEACTIVATE_CB is the callback to use when the dialog pops down.
1123 Returns the GTK dialog widget. */
1126 create_dialog (wv
, select_cb
, deactivate_cb
)
1128 GCallback select_cb
;
1129 GCallback deactivate_cb
;
1131 char *title
= get_dialog_title (wv
->name
[0]);
1132 int total_buttons
= wv
->name
[1] - '0';
1133 int right_buttons
= wv
->name
[4] - '0';
1136 int button_spacing
= 10;
1137 GtkWidget
*wdialog
= gtk_dialog_new ();
1141 GtkWidget
*whbox_up
;
1142 GtkWidget
*whbox_down
;
1144 /* If the number of buttons is greater than 4, make two rows of buttons
1145 instead. This looks better. */
1146 int make_two_rows
= total_buttons
> 4;
1148 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1149 left_buttons
= total_buttons
- right_buttons
;
1151 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1152 gtk_widget_set_name (wdialog
, "emacs-dialog");
1154 cur_box
= GTK_BOX (GTK_DIALOG (wdialog
)->action_area
);
1158 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1159 whbox_up
= gtk_hbox_new (FALSE
, 0);
1160 whbox_down
= gtk_hbox_new (FALSE
, 0);
1162 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1163 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1164 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1166 cur_box
= GTK_BOX (whbox_up
);
1169 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1170 G_CALLBACK (dialog_delete_callback
), 0);
1174 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1175 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1178 for (item
= wv
->contents
; item
; item
= item
->next
)
1180 char *utf8_label
= get_utf8_string (item
->value
);
1184 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1186 /* This is the text part of the dialog. */
1187 w
= gtk_label_new (utf8_label
);
1188 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1191 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
), w
,
1193 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1195 /* Try to make dialog look better. Must realize first so
1196 the widget can calculate the size it needs. */
1197 gtk_widget_realize (w
);
1198 gtk_widget_size_request (w
, &req
);
1199 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1201 if (item
->value
&& strlen (item
->value
) > 0)
1202 button_spacing
= 2*req
.width
/strlen (item
->value
);
1206 /* This is one button to add to the dialog. */
1207 w
= gtk_button_new_with_label (utf8_label
);
1208 if (! item
->enabled
)
1209 gtk_widget_set_sensitive (w
, FALSE
);
1211 g_signal_connect (G_OBJECT (w
), "clicked",
1212 select_cb
, item
->call_data
);
1214 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1215 if (++button_nr
== left_buttons
)
1218 cur_box
= GTK_BOX (whbox_down
);
1220 gtk_box_pack_start (cur_box
,
1227 if (utf8_label
&& utf8_label
!= item
->value
)
1228 g_free (utf8_label
);
1236 /***********************************************************************
1237 File dialog functions
1238 ***********************************************************************/
1239 /* Return non-zero if the old file selection dialog is being used.
1240 Return zero if not. */
1243 xg_uses_old_file_dialog ()
1245 #ifdef HAVE_GTK_FILE_BOTH
1246 extern int x_gtk_use_old_file_dialog
;
1247 return x_gtk_use_old_file_dialog
;
1248 #else /* ! HAVE_GTK_FILE_BOTH */
1250 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1256 #endif /* ! HAVE_GTK_FILE_BOTH */
1260 /* Function that is called when the file or font dialogs pop down.
1261 W is the dialog widget, RESPONSE is the response code.
1262 USER_DATA is what we passed in to g_signal_connect (pointer to int). */
1265 xg_dialog_response_cb (w
,
1272 int *ptr
= (int *) user_data
;
1277 /* Destroy the dialog. This makes it pop down. */
1280 pop_down_dialog (arg
)
1283 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1285 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1290 typedef char * (*xg_get_file_func
) P_ ((GtkWidget
*));
1292 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1294 /* Return the selected file for file chooser dialog W.
1295 The returned string must be free:d. */
1298 xg_get_file_name_from_chooser (w
)
1301 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1304 /* Callback called when the "Show hidden files" toggle is pressed.
1305 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1308 xg_toggle_visibility_cb (widget
, data
)
1312 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1314 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1315 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1319 /* Callback called when a property changes in a file chooser.
1320 GOBJECT is the file chooser dialog, ARG1 describes the property.
1321 USER_DATA is the toggle widget in the file chooser dialog.
1322 We use this to update the "Show hidden files" toggle when the user
1323 changes that property by right clicking in the file list. */
1326 xg_toggle_notify_cb (gobject
, arg1
, user_data
)
1331 extern int x_gtk_show_hidden_files
;
1333 if (strcmp (arg1
->name
, "show-hidden") == 0)
1335 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (gobject
);
1336 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1337 gboolean visible
, toggle_on
;
1339 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1340 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1342 if (!!visible
!= !!toggle_on
)
1344 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1345 G_CALLBACK (xg_toggle_visibility_cb
),
1347 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1348 g_signal_handlers_unblock_by_func
1349 (G_OBJECT (wtoggle
),
1350 G_CALLBACK (xg_toggle_visibility_cb
),
1353 x_gtk_show_hidden_files
= visible
;
1357 /* Read a file name from the user using a file chooser dialog.
1358 F is the current frame.
1359 PROMPT is a prompt to show to the user. May not be NULL.
1360 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1361 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1362 file. *FUNC is set to a function that can be used to retrieve the
1363 selected file name from the returned widget.
1365 Returns the created widget. */
1368 xg_get_file_with_chooser (f
, prompt
, default_filename
,
1369 mustmatch_p
, only_dir_p
, func
)
1372 char *default_filename
;
1373 int mustmatch_p
, only_dir_p
;
1374 xg_get_file_func
*func
;
1378 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1379 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1380 GtkFileChooserAction action
= (mustmatch_p
?
1381 GTK_FILE_CHOOSER_ACTION_OPEN
:
1382 GTK_FILE_CHOOSER_ACTION_SAVE
);
1383 extern int x_gtk_show_hidden_files
;
1384 extern int x_gtk_file_dialog_help_text
;
1388 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1390 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1391 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1392 (mustmatch_p
|| only_dir_p
?
1393 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1396 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1398 wbox
= gtk_vbox_new (FALSE
, 0);
1399 gtk_widget_show (wbox
);
1400 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1402 if (x_gtk_show_hidden_files
)
1404 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1405 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1407 gtk_widget_show (wtoggle
);
1408 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1409 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1410 g_signal_connect (G_OBJECT (filewin
), "notify",
1411 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1413 if (x_gtk_file_dialog_help_text
)
1416 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1417 Show the C-l help text only for versions < 2.10. */
1418 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1419 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1420 strcat (message
, "\nIf you don't like this file selector, use the "
1421 "corresponding\nkey binding or customize "
1422 "use-file-dialog to turn it off.");
1424 wmessage
= gtk_label_new (message
);
1425 gtk_widget_show (wmessage
);
1428 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1429 if (x_gtk_file_dialog_help_text
)
1430 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1431 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1433 if (default_filename
)
1436 struct gcpro gcpro1
;
1437 char *utf8_filename
;
1440 file
= build_string (default_filename
);
1442 /* File chooser does not understand ~/... in the file name. It must be
1443 an absolute name starting with /. */
1444 if (default_filename
[0] != '/')
1445 file
= Fexpand_file_name (file
, Qnil
);
1447 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1448 if (! NILP (Ffile_directory_p (file
)))
1449 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1453 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1455 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1457 char *cp
= strrchr (utf8_filename
, '/');
1459 else cp
= utf8_filename
;
1460 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1467 *func
= xg_get_file_name_from_chooser
;
1470 #endif /* HAVE_GTK_FILE_CHOOSER_DIALOG_NEW */
1472 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1474 /* Return the selected file for file selector dialog W.
1475 The returned string must be free:d. */
1478 xg_get_file_name_from_selector (w
)
1481 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1482 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1485 /* Create a file selection dialog.
1486 F is the current frame.
1487 PROMPT is a prompt to show to the user. May not be NULL.
1488 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1489 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1490 file. *FUNC is set to a function that can be used to retrieve the
1491 selected file name from the returned widget.
1493 Returns the created widget. */
1496 xg_get_file_with_selection (f
, prompt
, default_filename
,
1497 mustmatch_p
, only_dir_p
, func
)
1500 char *default_filename
;
1501 int mustmatch_p
, only_dir_p
;
1502 xg_get_file_func
*func
;
1505 GtkFileSelection
*filesel
;
1507 filewin
= gtk_file_selection_new (prompt
);
1508 filesel
= GTK_FILE_SELECTION (filewin
);
1510 if (default_filename
)
1511 gtk_file_selection_set_filename (filesel
, default_filename
);
1515 /* The selection_entry part of filesel is not documented. */
1516 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1517 gtk_file_selection_hide_fileop_buttons (filesel
);
1520 *func
= xg_get_file_name_from_selector
;
1524 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1526 /* Read a file name from the user using a file dialog, either the old
1527 file selection dialog, or the new file chooser dialog. Which to use
1528 depends on what the GTK version used has, and what the value of
1529 gtk-use-old-file-dialog.
1530 F is the current frame.
1531 PROMPT is a prompt to show to the user. May not be NULL.
1532 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1533 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1536 Returns a file name or NULL if no file was selected.
1537 The returned string must be freed by the caller. */
1540 xg_get_file_name (f
, prompt
, default_filename
, mustmatch_p
, only_dir_p
)
1543 char *default_filename
;
1544 int mustmatch_p
, only_dir_p
;
1547 int count
= SPECPDL_INDEX ();
1549 int filesel_done
= 0;
1550 xg_get_file_func func
;
1552 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1553 /* I really don't know why this is needed, but without this the GLIBC add on
1554 library linuxthreads hangs when the Gnome file chooser backend creates
1556 sigblock (sigmask (__SIGRTMIN
));
1557 #endif /* HAVE_GTK_AND_PTHREAD */
1559 #ifdef HAVE_GTK_FILE_BOTH
1561 if (xg_uses_old_file_dialog ())
1562 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1563 mustmatch_p
, only_dir_p
, &func
);
1565 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1566 mustmatch_p
, only_dir_p
, &func
);
1568 #else /* not HAVE_GTK_FILE_BOTH */
1570 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1571 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1572 mustmatch_p
, only_dir_p
, &func
);
1574 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1575 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1576 mustmatch_p
, only_dir_p
, &func
);
1579 #endif /* HAVE_GTK_FILE_BOTH */
1581 xg_set_screen (w
, f
);
1582 gtk_widget_set_name (w
, "emacs-filedialog");
1583 gtk_window_set_transient_for (GTK_WINDOW (w
),
1584 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1585 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1586 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1588 g_signal_connect (G_OBJECT (w
),
1590 G_CALLBACK (xg_dialog_response_cb
),
1593 /* Don't destroy the widget if closed by the window manager close button. */
1594 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1596 gtk_widget_show (w
);
1598 record_unwind_protect (pop_down_dialog
, make_save_value (w
, 0));
1599 while (! filesel_done
)
1601 x_menu_wait_for_event (0);
1602 gtk_main_iteration ();
1605 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1606 sigunblock (sigmask (__SIGRTMIN
));
1609 if (filesel_done
== GTK_RESPONSE_OK
)
1612 unbind_to (count
, Qnil
);
1617 #ifdef HAVE_FREETYPE
1618 /* Pop up a GTK font selector and return the name of the font the user
1619 selects, as a C string. The returned font name follows GTK's own
1622 `FAMILY [VALUE1 VALUE2] SIZE'
1624 This can be parsed using font_parse_fcname in font.c.
1625 DEFAULT_NAME, if non-zero, is the default font name. */
1628 xg_get_font_name (f
, default_name
)
1633 int count
= SPECPDL_INDEX ();
1634 char *fontname
= NULL
;
1637 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1638 sigblock (sigmask (__SIGRTMIN
));
1639 #endif /* HAVE_GTK_AND_PTHREAD */
1641 w
= gtk_font_selection_dialog_new ("Pick a font");
1643 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1646 xg_set_screen (w
, f
);
1647 gtk_widget_set_name (w
, "emacs-fontdialog");
1648 gtk_window_set_transient_for (GTK_WINDOW (w
),
1649 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1650 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1651 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1653 g_signal_connect (G_OBJECT (w
), "response",
1654 G_CALLBACK (xg_dialog_response_cb
), &done
);
1656 /* Don't destroy the widget if closed by the window manager close button. */
1657 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1659 gtk_widget_show (w
);
1661 record_unwind_protect (pop_down_dialog
, make_save_value (w
, 0));
1664 x_menu_wait_for_event (0);
1665 gtk_main_iteration ();
1668 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1669 sigunblock (sigmask (__SIGRTMIN
));
1672 if (done
== GTK_RESPONSE_OK
)
1673 fontname
= gtk_font_selection_dialog_get_font_name
1674 ((GtkFontSelectionDialog
*) w
);
1676 unbind_to (count
, Qnil
);
1680 #endif /* HAVE_FREETYPE */
1684 /***********************************************************************
1686 ***********************************************************************/
1688 /* The name of menu items that can be used for customization. Since GTK
1689 RC files are very crude and primitive, we have to set this on all
1690 menu item names so a user can easily customize menu items. */
1692 #define MENU_ITEM_NAME "emacs-menuitem"
1695 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1696 during GC. The next member points to the items. */
1697 static xg_list_node xg_menu_cb_list
;
1699 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1700 during GC. The next member points to the items. */
1701 static xg_list_node xg_menu_item_cb_list
;
1703 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1704 F is the frame CL_DATA will be initialized for.
1705 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1707 The menu bar and all sub menus under the menu bar in a frame
1708 share the same structure, hence the reference count.
1710 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1711 allocated xg_menu_cb_data if CL_DATA is NULL. */
1713 static xg_menu_cb_data
*
1714 make_cl_data (cl_data
, f
, highlight_cb
)
1715 xg_menu_cb_data
*cl_data
;
1717 GCallback highlight_cb
;
1721 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1723 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1724 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1725 cl_data
->highlight_cb
= highlight_cb
;
1726 cl_data
->ref_count
= 0;
1728 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1731 cl_data
->ref_count
++;
1736 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1737 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1739 When the menu bar is updated, menu items may have been added and/or
1740 removed, so menu_bar_vector and menu_bar_items_used change. We must
1741 then update CL_DATA since it is used to determine which menu
1742 item that is invoked in the menu.
1743 HIGHLIGHT_CB could change, there is no check that the same
1744 function is given when modifying a menu bar as was given when
1745 creating the menu bar. */
1748 update_cl_data (cl_data
, f
, highlight_cb
)
1749 xg_menu_cb_data
*cl_data
;
1751 GCallback highlight_cb
;
1756 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1757 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1758 cl_data
->highlight_cb
= highlight_cb
;
1762 /* Decrease reference count for CL_DATA.
1763 If reference count is zero, free CL_DATA. */
1766 unref_cl_data (cl_data
)
1767 xg_menu_cb_data
*cl_data
;
1769 if (cl_data
&& cl_data
->ref_count
> 0)
1771 cl_data
->ref_count
--;
1772 if (cl_data
->ref_count
== 0)
1774 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1780 /* Function that marks all lisp data during GC. */
1787 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1788 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1790 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1792 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1794 if (! NILP (cb_data
->help
))
1795 mark_object (cb_data
->help
);
1800 /* Callback called when a menu item is destroyed. Used to free data.
1801 W is the widget that is being destroyed (not used).
1802 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1805 menuitem_destroy_callback (w
, client_data
)
1807 gpointer client_data
;
1811 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1812 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1817 /* Callback called when the pointer enters/leaves a menu item.
1818 W is the parent of the menu item.
1819 EVENT is either an enter event or leave event.
1820 CLIENT_DATA is not used.
1822 Returns FALSE to tell GTK to keep processing this event. */
1825 menuitem_highlight_callback (w
, event
, client_data
)
1827 GdkEventCrossing
*event
;
1828 gpointer client_data
;
1831 GtkWidget
*subwidget
;
1832 xg_menu_item_cb_data
*data
;
1834 ev
.crossing
= *event
;
1835 subwidget
= gtk_get_event_widget (&ev
);
1836 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
1840 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1842 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
1843 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1844 (*func
) (subwidget
, call_data
);
1851 /* Callback called when a menu is destroyed. Used to free data.
1852 W is the widget that is being destroyed (not used).
1853 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1856 menu_destroy_callback (w
, client_data
)
1858 gpointer client_data
;
1860 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1863 /* Callback called when a menu does a grab or ungrab. That means the
1864 menu has been activated or deactivated.
1865 Used to start a timer so the small timeout the menus in GTK uses before
1866 popping down a menu is seen by Emacs (see xg_process_timeouts above).
1867 W is the widget that does the grab (not used).
1868 UNGRAB_P is TRUE if this is an ungrab, FALSE if it is a grab.
1869 CLIENT_DATA is NULL (not used). */
1871 /* Keep track of total number of grabs. */
1872 static int menu_grab_callback_cnt
;
1875 menu_grab_callback (GtkWidget
*widget
,
1877 gpointer client_data
)
1879 if (ungrab_p
) menu_grab_callback_cnt
--;
1880 else menu_grab_callback_cnt
++;
1882 if (menu_grab_callback_cnt
> 0 && ! xg_timer
) xg_start_timer ();
1883 else if (menu_grab_callback_cnt
== 0 && xg_timer
) xg_stop_timer ();
1886 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1887 must be non-NULL) and can be inserted into a menu item.
1889 Returns the GtkHBox. */
1892 make_widget_for_menu_item (utf8_label
, utf8_key
)
1900 wbox
= gtk_hbox_new (FALSE
, 0);
1901 wlbl
= gtk_label_new (utf8_label
);
1902 wkey
= gtk_label_new (utf8_key
);
1904 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1905 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1907 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1908 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1910 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1911 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1912 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1917 /* Make and return a menu item widget with the key to the right.
1918 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1919 UTF8_KEY is the text representing the key binding.
1920 ITEM is the widget_value describing the menu item.
1922 GROUP is an in/out parameter. If the menu item to be created is not
1923 part of any radio menu group, *GROUP contains NULL on entry and exit.
1924 If the menu item to be created is part of a radio menu group, on entry
1925 *GROUP contains the group to use, or NULL if this is the first item
1926 in the group. On exit, *GROUP contains the radio item group.
1928 Unfortunately, keys don't line up as nicely as in Motif,
1929 but the MacOS X version doesn't either, so I guess that is OK. */
1932 make_menu_item (utf8_label
, utf8_key
, item
, group
)
1939 GtkWidget
*wtoadd
= 0;
1941 /* It has been observed that some menu items have a NULL name field.
1942 This will lead to this function being called with a NULL utf8_label.
1943 GTK crashes on that so we set a blank label. Why there is a NULL
1944 name remains to be investigated. */
1945 if (! utf8_label
) utf8_label
= " ";
1948 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1950 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1953 if (utf8_key
) w
= gtk_check_menu_item_new ();
1954 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1955 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1957 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1959 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1960 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1961 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1963 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1968 if (utf8_key
) w
= gtk_menu_item_new ();
1969 else w
= gtk_menu_item_new_with_label (utf8_label
);
1972 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1973 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1978 /* Return non-zero if LABEL specifies a separator (GTK only has one
1981 static char* separator_names
[] = {
1986 "single-dashed-line",
1987 "double-dashed-line",
1989 "shadow-etched-out",
1990 "shadow-etched-in-dash",
1991 "shadow-etched-out-dash",
1992 "shadow-double-etched-in",
1993 "shadow-double-etched-out",
1994 "shadow-double-etched-in-dash",
1995 "shadow-double-etched-out-dash",
2000 xg_separator_p (char *label
)
2002 if (! label
) return 0;
2003 else if (strlen (label
) > 3
2004 && strncmp (label
, "--", 2) == 0
2010 for (i
= 0; separator_names
[i
]; ++i
)
2011 if (strcmp (label
, separator_names
[i
]) == 0)
2016 /* Old-style separator, maybe. It's a separator if it contains
2018 while (*label
== '-')
2020 if (*label
== 0) return 1;
2026 static int xg_detached_menus
;
2028 /* Returns non-zero if there are detached menus. */
2031 xg_have_tear_offs ()
2033 return xg_detached_menus
> 0;
2036 /* Callback invoked when a detached menu window is removed. Here we
2037 decrease the xg_detached_menus count.
2038 WIDGET is the top level window that is removed (the parent of the menu).
2039 CLIENT_DATA is not used. */
2042 tearoff_remove (widget
, client_data
)
2044 gpointer client_data
;
2046 if (xg_detached_menus
> 0) --xg_detached_menus
;
2049 /* Callback invoked when a menu is detached. It increases the
2050 xg_detached_menus count.
2051 WIDGET is the GtkTearoffMenuItem.
2052 CLIENT_DATA is not used. */
2055 tearoff_activate (widget
, client_data
)
2057 gpointer client_data
;
2059 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2060 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2062 ++xg_detached_menus
;
2063 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2065 G_CALLBACK (tearoff_remove
), 0);
2070 /* Create a menu item widget, and connect the callbacks.
2071 ITEM decribes the menu item.
2072 F is the frame the created menu belongs to.
2073 SELECT_CB is the callback to use when a menu item is selected.
2074 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2075 CL_DATA points to the callback data to be used for this menu.
2076 GROUP is an in/out parameter. If the menu item to be created is not
2077 part of any radio menu group, *GROUP contains NULL on entry and exit.
2078 If the menu item to be created is part of a radio menu group, on entry
2079 *GROUP contains the group to use, or NULL if this is the first item
2080 in the group. On exit, *GROUP contains the radio item group.
2082 Returns the created GtkWidget. */
2085 xg_create_one_menuitem (item
, f
, select_cb
, highlight_cb
, cl_data
, group
)
2088 GCallback select_cb
;
2089 GCallback highlight_cb
;
2090 xg_menu_cb_data
*cl_data
;
2096 xg_menu_item_cb_data
*cb_data
;
2098 utf8_label
= get_utf8_string (item
->name
);
2099 utf8_key
= get_utf8_string (item
->key
);
2101 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2103 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2104 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
2106 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2108 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2110 cb_data
->select_id
= 0;
2111 cb_data
->help
= item
->help
;
2112 cb_data
->cl_data
= cl_data
;
2113 cb_data
->call_data
= item
->call_data
;
2115 g_signal_connect (G_OBJECT (w
),
2117 G_CALLBACK (menuitem_destroy_callback
),
2120 /* Put cb_data in widget, so we can get at it when modifying menubar */
2121 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2123 /* final item, not a submenu */
2124 if (item
->call_data
&& ! item
->contents
)
2128 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2134 static GtkWidget
*create_menus
P_ ((widget_value
*, FRAME_PTR
, GCallback
,
2135 GCallback
, GCallback
, int, int, int,
2136 GtkWidget
*, xg_menu_cb_data
*, char *));
2138 /* Create a full menu tree specified by DATA.
2139 F is the frame the created menu belongs to.
2140 SELECT_CB is the callback to use when a menu item is selected.
2141 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2142 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2143 POP_UP_P is non-zero if we shall create a popup menu.
2144 MENU_BAR_P is non-zero if we shall create a menu bar.
2145 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2146 if MENU_BAR_P is non-zero.
2147 TOPMENU is the topmost GtkWidget that others shall be placed under.
2148 It may be NULL, in that case we create the appropriate widget
2149 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2150 CL_DATA is the callback data we shall use for this menu, or NULL
2151 if we haven't set the first callback yet.
2152 NAME is the name to give to the top level menu if this function
2153 creates it. May be NULL to not set any name.
2155 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2158 This function calls itself to create submenus. */
2161 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2162 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
2165 GCallback select_cb
;
2166 GCallback deactivate_cb
;
2167 GCallback highlight_cb
;
2172 xg_menu_cb_data
*cl_data
;
2176 GtkWidget
*wmenu
= topmenu
;
2177 GSList
*group
= NULL
;
2183 wmenu
= gtk_menu_new ();
2184 xg_set_screen (wmenu
, f
);
2185 /* Connect this to the menu instead of items so we get enter/leave for
2186 disabled items also. TODO: Still does not get enter/leave for
2187 disabled items in detached menus. */
2188 g_signal_connect (G_OBJECT (wmenu
),
2189 "enter-notify-event",
2190 G_CALLBACK (menuitem_highlight_callback
),
2192 g_signal_connect (G_OBJECT (wmenu
),
2193 "leave-notify-event",
2194 G_CALLBACK (menuitem_highlight_callback
),
2197 else wmenu
= gtk_menu_bar_new ();
2199 /* Put cl_data on the top menu for easier access. */
2200 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2201 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2202 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2203 G_CALLBACK (menu_destroy_callback
), cl_data
);
2206 gtk_widget_set_name (wmenu
, name
);
2209 g_signal_connect (G_OBJECT (wmenu
),
2210 "selection-done", deactivate_cb
, 0);
2212 g_signal_connect (G_OBJECT (wmenu
),
2213 "grab-notify", G_CALLBACK (menu_grab_callback
), 0);
2216 if (! menu_bar_p
&& add_tearoff_p
)
2218 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2219 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2221 g_signal_connect (G_OBJECT (tearoff
), "activate",
2222 G_CALLBACK (tearoff_activate
), 0);
2225 for (item
= data
; item
; item
= item
->next
)
2229 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2230 && !xg_separator_p (item
->name
))
2233 /* A title for a popup. We do the same as GTK does when
2234 creating titles, but it does not look good. */
2236 utf8_label
= get_utf8_string (item
->name
);
2238 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2239 w
= gtk_menu_item_new_with_label (utf8_label
);
2240 gtk_widget_set_sensitive (w
, FALSE
);
2241 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2243 else if (xg_separator_p (item
->name
))
2246 /* GTK only have one separator type. */
2247 w
= gtk_separator_menu_item_new ();
2251 w
= xg_create_one_menuitem (item
,
2253 item
->contents
? 0 : select_cb
,
2258 /* Create a possibly empty submenu for menu bar items, since some
2259 themes don't highlight items correctly without it. */
2260 if (item
->contents
|| menu_bar_p
)
2262 GtkWidget
*submenu
= create_menus (item
->contents
,
2273 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2277 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2278 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2284 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2285 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2286 with some text and buttons.
2287 F is the frame the created item belongs to.
2288 NAME is the name to use for the top widget.
2289 VAL is a widget_value structure describing items to be created.
2290 SELECT_CB is the callback to use when a menu item is selected or
2291 a dialog button is pressed.
2292 DEACTIVATE_CB is the callback to use when an item is deactivated.
2293 For a menu, when a sub menu is not shown anymore, for a dialog it is
2294 called when the dialog is popped down.
2295 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2297 Returns the widget created. */
2300 xg_create_widget (type
, name
, f
, val
,
2301 select_cb
, deactivate_cb
, highlight_cb
)
2306 GCallback select_cb
;
2307 GCallback deactivate_cb
;
2308 GCallback highlight_cb
;
2311 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2312 int pop_up_p
= strcmp (type
, "popup") == 0;
2314 if (strcmp (type
, "dialog") == 0)
2316 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2317 xg_set_screen (w
, f
);
2318 gtk_window_set_transient_for (GTK_WINDOW (w
),
2319 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2320 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2321 gtk_widget_set_name (w
, "emacs-dialog");
2322 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2324 else if (menu_bar_p
|| pop_up_p
)
2326 w
= create_menus (val
->contents
,
2338 /* Set the cursor to an arrow for popup menus when they are mapped.
2339 This is done by default for menu bar menus. */
2342 /* Must realize so the GdkWindow inside the widget is created. */
2343 gtk_widget_realize (w
);
2344 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2349 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2356 /* Return the label for menu item WITEM. */
2359 xg_get_menu_item_label (witem
)
2362 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2363 return gtk_label_get_label (wlabel
);
2366 /* Return non-zero if the menu item WITEM has the text LABEL. */
2369 xg_item_label_same_p (witem
, label
)
2374 char *utf8_label
= get_utf8_string (label
);
2375 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2377 if (! old_label
&& ! utf8_label
)
2379 else if (old_label
&& utf8_label
)
2380 is_same
= strcmp (utf8_label
, old_label
) == 0;
2382 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2387 /* Destroy widgets in LIST. */
2390 xg_destroy_widgets (list
)
2395 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2397 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2399 /* Destroying the widget will remove it from the container it is in. */
2400 gtk_widget_destroy (w
);
2404 /* Update the top level names in MENUBAR (i.e. not submenus).
2405 F is the frame the menu bar belongs to.
2406 *LIST is a list with the current menu bar names (menu item widgets).
2407 ITER is the item within *LIST that shall be updated.
2408 POS is the numerical position, starting at 0, of ITER in *LIST.
2409 VAL describes what the menu bar shall look like after the update.
2410 SELECT_CB is the callback to use when a menu item is selected.
2411 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2412 CL_DATA points to the callback data to be used for this menu bar.
2414 This function calls itself to walk through the menu bar names. */
2417 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2418 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2425 GCallback select_cb
;
2426 GCallback deactivate_cb
;
2427 GCallback highlight_cb
;
2428 xg_menu_cb_data
*cl_data
;
2430 if (! iter
&& ! val
)
2432 else if (iter
&& ! val
)
2434 /* Item(s) have been removed. Remove all remaining items. */
2435 xg_destroy_widgets (iter
);
2441 else if (! iter
&& val
)
2443 /* Item(s) added. Add all new items in one call. */
2444 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2445 0, 1, 0, menubar
, cl_data
, 0);
2451 /* Below this neither iter or val is NULL */
2452 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2454 /* This item is still the same, check next item. */
2456 iter
= g_list_next (iter
);
2459 else /* This item is changed. */
2461 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2462 GtkMenuItem
*witem2
= 0;
2463 int val_in_menubar
= 0;
2464 int iter_in_new_menubar
= 0;
2468 /* See if the changed entry (val) is present later in the menu bar */
2470 iter2
&& ! val_in_menubar
;
2471 iter2
= g_list_next (iter2
))
2473 witem2
= GTK_MENU_ITEM (iter2
->data
);
2474 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2477 /* See if the current entry (iter) is present later in the
2478 specification for the new menu bar. */
2479 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2480 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2482 if (val_in_menubar
&& ! iter_in_new_menubar
)
2486 /* This corresponds to:
2491 gtk_widget_ref (GTK_WIDGET (witem
));
2492 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2493 gtk_widget_destroy (GTK_WIDGET (witem
));
2495 /* Must get new list since the old changed. */
2496 g_list_free (*list
);
2497 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2498 while (nr
-- > 0) iter
= g_list_next (iter
);
2500 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2502 /* This corresponds to:
2505 Rename B to X. This might seem to be a strange thing to do,
2506 since if there is a menu under B it will be totally wrong for X.
2507 But consider editing a C file. Then there is a C-mode menu
2508 (corresponds to B above).
2509 If then doing C-x C-f the minibuf menu (X above) replaces the
2510 C-mode menu. When returning from the minibuffer, we get
2511 back the C-mode menu. Thus we do:
2512 Rename B to X (C-mode to minibuf menu)
2513 Rename X to B (minibuf to C-mode menu).
2514 If the X menu hasn't been invoked, the menu under B
2515 is up to date when leaving the minibuffer. */
2516 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2517 char *utf8_label
= get_utf8_string (val
->name
);
2518 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2520 gtk_label_set_text (wlabel
, utf8_label
);
2522 /* If this item has a submenu that has been detached, change
2523 the title in the WM decorations also. */
2524 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2525 /* Set the title of the detached window. */
2526 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2528 iter
= g_list_next (iter
);
2532 else if (! val_in_menubar
&& iter_in_new_menubar
)
2534 /* This corresponds to:
2541 GtkWidget
*w
= xg_create_one_menuitem (val
,
2548 /* Create a possibly empty submenu for menu bar items, since some
2549 themes don't highlight items correctly without it. */
2550 GtkWidget
*submenu
= create_menus (NULL
, f
,
2551 select_cb
, deactivate_cb
,
2553 0, 0, 0, 0, cl_data
, 0);
2554 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2555 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2556 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2558 g_list_free (*list
);
2559 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2560 while (nr
-- > 0) iter
= g_list_next (iter
);
2561 iter
= g_list_next (iter
);
2565 else /* if (val_in_menubar && iter_in_new_menubar) */
2568 /* This corresponds to:
2573 gtk_widget_ref (GTK_WIDGET (witem2
));
2574 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2575 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2576 GTK_WIDGET (witem2
), pos
);
2577 gtk_widget_unref (GTK_WIDGET (witem2
));
2579 g_list_free (*list
);
2580 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2581 while (nr
-- > 0) iter
= g_list_next (iter
);
2582 if (iter
) iter
= g_list_next (iter
);
2588 /* Update the rest of the menu bar. */
2589 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2590 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2593 /* Update the menu item W so it corresponds to VAL.
2594 SELECT_CB is the callback to use when a menu item is selected.
2595 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2596 CL_DATA is the data to set in the widget for menu invokation. */
2599 xg_update_menu_item (val
, w
, select_cb
, highlight_cb
, cl_data
)
2602 GCallback select_cb
;
2603 GCallback highlight_cb
;
2604 xg_menu_cb_data
*cl_data
;
2611 const char *old_label
= 0;
2612 const char *old_key
= 0;
2613 xg_menu_item_cb_data
*cb_data
;
2615 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2616 utf8_label
= get_utf8_string (val
->name
);
2617 utf8_key
= get_utf8_string (val
->key
);
2619 /* See if W is a menu item with a key. See make_menu_item above. */
2620 if (GTK_IS_HBOX (wchild
))
2622 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2624 wlbl
= GTK_LABEL (list
->data
);
2625 wkey
= GTK_LABEL (list
->next
->data
);
2630 /* Remove the key and keep just the label. */
2631 gtk_widget_ref (GTK_WIDGET (wlbl
));
2632 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2633 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2638 else /* Just a label. */
2640 wlbl
= GTK_LABEL (wchild
);
2642 /* Check if there is now a key. */
2645 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2646 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2648 wlbl
= GTK_LABEL (list
->data
);
2649 wkey
= GTK_LABEL (list
->next
->data
);
2652 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2653 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2658 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2659 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2661 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2662 gtk_label_set_text (wkey
, utf8_key
);
2664 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2665 gtk_label_set_text (wlbl
, utf8_label
);
2667 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2668 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2670 if (! val
->enabled
&& GTK_WIDGET_SENSITIVE (w
))
2671 gtk_widget_set_sensitive (w
, FALSE
);
2672 else if (val
->enabled
&& ! GTK_WIDGET_SENSITIVE (w
))
2673 gtk_widget_set_sensitive (w
, TRUE
);
2675 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2679 cb_data
->call_data
= val
->call_data
;
2680 cb_data
->help
= val
->help
;
2681 cb_data
->cl_data
= cl_data
;
2683 /* We assume the callback functions don't change. */
2684 if (val
->call_data
&& ! val
->contents
)
2686 /* This item shall have a select callback. */
2687 if (! cb_data
->select_id
)
2689 = g_signal_connect (G_OBJECT (w
), "activate",
2690 select_cb
, cb_data
);
2692 else if (cb_data
->select_id
)
2694 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2695 cb_data
->select_id
= 0;
2700 /* Update the toggle menu item W so it corresponds to VAL. */
2703 xg_update_toggle_item (val
, w
)
2707 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2710 /* Update the radio menu item W so it corresponds to VAL. */
2713 xg_update_radio_item (val
, w
)
2717 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2720 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2721 SUBMENU may be NULL, in that case a new menu is created.
2722 F is the frame the menu bar belongs to.
2723 VAL describes the contents of the menu bar.
2724 SELECT_CB is the callback to use when a menu item is selected.
2725 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2726 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2727 CL_DATA is the call back data to use for any newly created items.
2729 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2733 xg_update_submenu (submenu
, f
, val
,
2734 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2738 GCallback select_cb
;
2739 GCallback deactivate_cb
;
2740 GCallback highlight_cb
;
2741 xg_menu_cb_data
*cl_data
;
2743 GtkWidget
*newsub
= submenu
;
2747 int has_tearoff_p
= 0;
2748 GList
*first_radio
= 0;
2751 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2753 for (cur
= val
, iter
= list
;
2755 iter
= g_list_next (iter
), cur
= cur
->next
)
2757 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2759 /* Skip tearoff items, they have no counterpart in val. */
2760 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2763 iter
= g_list_next (iter
);
2764 if (iter
) w
= GTK_WIDGET (iter
->data
);
2768 /* Remember first radio button in a group. If we get a mismatch in
2769 a radio group we must rebuild the whole group so that the connections
2770 in GTK becomes correct. */
2771 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2773 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2774 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2777 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2779 if (! xg_separator_p (cur
->name
))
2782 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2784 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2786 xg_update_toggle_item (cur
, w
);
2787 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2789 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2791 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2793 xg_update_radio_item (cur
, w
);
2794 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2796 else if (GTK_IS_MENU_ITEM (w
))
2798 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2801 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2802 xg_separator_p (cur
->name
))
2805 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2807 sub
= gtk_menu_item_get_submenu (witem
);
2808 if (sub
&& ! cur
->contents
)
2810 /* Not a submenu anymore. */
2811 gtk_widget_ref (sub
);
2812 gtk_menu_item_remove_submenu (witem
);
2813 gtk_widget_destroy (sub
);
2815 else if (cur
->contents
)
2819 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2820 select_cb
, deactivate_cb
,
2821 highlight_cb
, cl_data
);
2823 /* If this item just became a submenu, we must set it. */
2825 gtk_menu_item_set_submenu (witem
, nsub
);
2830 /* Structural difference. Remove everything from here and down
2836 /* Remove widgets from first structual change. */
2839 /* If we are adding new menu items below, we must remove from
2840 first radio button so that radio groups become correct. */
2841 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2842 else xg_destroy_widgets (iter
);
2847 /* More items added. Create them. */
2848 newsub
= create_menus (cur
,
2861 if (list
) g_list_free (list
);
2866 /* Update the MENUBAR.
2867 F is the frame the menu bar belongs to.
2868 VAL describes the contents of the menu bar.
2869 If DEEP_P is non-zero, rebuild all but the top level menu names in
2870 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2871 SELECT_CB is the callback to use when a menu item is selected.
2872 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2873 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2876 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2877 select_cb
, deactivate_cb
, highlight_cb
)
2882 GCallback select_cb
;
2883 GCallback deactivate_cb
;
2884 GCallback highlight_cb
;
2886 xg_menu_cb_data
*cl_data
;
2887 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2891 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2894 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2895 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2901 /* Update all sub menus.
2902 We must keep the submenus (GTK menu item widgets) since the
2903 X Window in the XEvent that activates the menu are those widgets. */
2905 /* Update cl_data, menu_item things in F may have changed. */
2906 update_cl_data (cl_data
, f
, highlight_cb
);
2908 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2915 /* Find sub menu that corresponds to val and update it. */
2916 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2918 witem
= GTK_MENU_ITEM (iter
->data
);
2919 if (xg_item_label_same_p (witem
, cur
->name
))
2921 sub
= gtk_menu_item_get_submenu (witem
);
2926 newsub
= xg_update_submenu (sub
,
2933 /* sub may still be NULL. If we just updated non deep and added
2934 a new menu bar item, it has no sub menu yet. So we set the
2935 newly created sub menu under witem. */
2938 xg_set_screen (newsub
, f
);
2939 gtk_menu_item_set_submenu (witem
, newsub
);
2945 gtk_widget_show_all (menubar
);
2948 /* Recompute all the widgets of frame F, when the menu bar has been
2949 changed. Value is non-zero if widgets were updated. */
2952 xg_update_frame_menubar (f
)
2955 struct x_output
*x
= f
->output_data
.x
;
2958 if (!x
->menubar_widget
|| GTK_WIDGET_MAPPED (x
->menubar_widget
))
2963 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2965 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2967 gtk_widget_show_all (x
->menubar_widget
);
2968 gtk_widget_size_request (x
->menubar_widget
, &req
);
2970 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2972 /* The height has changed, resize outer widget and set columns
2973 rows to what we had before adding the menu bar. */
2974 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2976 SET_FRAME_GARBAGED (f
);
2982 /* Get rid of the menu bar of frame F, and free its storage.
2983 This is used when deleting a frame, and when turning off the menu bar. */
2986 free_frame_menubar (f
)
2989 struct x_output
*x
= f
->output_data
.x
;
2991 if (x
->menubar_widget
)
2995 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2996 /* The menubar and its children shall be deleted when removed from
2998 x
->menubar_widget
= 0;
2999 FRAME_MENUBAR_HEIGHT (f
) = 0;
3001 /* The height has changed, resize outer widget and set columns
3002 rows to what we had before removing the menu bar. */
3003 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3005 SET_FRAME_GARBAGED (f
);
3012 /***********************************************************************
3013 Scroll bar functions
3014 ***********************************************************************/
3017 /* Setting scroll bar values invokes the callback. Use this variable
3018 to indicate that callback should do nothing. */
3020 int xg_ignore_gtk_scrollbar
;
3022 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3023 may be larger than 32 bits. Keep a mapping from integer index to widget
3024 pointers to get around the 32 bit limitation. */
3028 GtkWidget
**widgets
;
3033 /* Grow this much every time we need to allocate more */
3035 #define ID_TO_WIDGET_INCR 32
3037 /* Store the widget pointer W in id_to_widget and return the integer index. */
3040 xg_store_widget_in_map (w
)
3045 if (id_to_widget
.max_size
== id_to_widget
.used
)
3047 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3049 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
3050 sizeof (GtkWidget
*)*new_size
);
3052 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3053 id_to_widget
.widgets
[i
] = 0;
3054 id_to_widget
.max_size
= new_size
;
3057 /* Just loop over the array and find a free place. After all,
3058 how many scroll bars are we creating? Should be a small number.
3059 The check above guarantees we will find a free place. */
3060 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3062 if (! id_to_widget
.widgets
[i
])
3064 id_to_widget
.widgets
[i
] = w
;
3065 ++id_to_widget
.used
;
3071 /* Should never end up here */
3075 /* Remove pointer at IDX from id_to_widget.
3076 Called when scroll bar is destroyed. */
3079 xg_remove_widget_from_map (idx
)
3082 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3084 id_to_widget
.widgets
[idx
] = 0;
3085 --id_to_widget
.used
;
3089 /* Get the widget pointer at IDX from id_to_widget. */
3092 xg_get_widget_from_map (idx
)
3095 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3096 return id_to_widget
.widgets
[idx
];
3101 /* Return the scrollbar id for X Window WID on display DPY.
3102 Return -1 if WID not in id_to_widget. */
3105 xg_get_scroll_id_for_window (dpy
, wid
)
3112 w
= xg_win_to_widget (dpy
, wid
);
3116 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3117 if (id_to_widget
.widgets
[idx
] == w
)
3124 /* Callback invoked when scroll bar WIDGET is destroyed.
3125 DATA is the index into id_to_widget for WIDGET.
3126 We free pointer to last scroll bar values here and remove the index. */
3129 xg_gtk_scroll_destroy (widget
, data
)
3134 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
3136 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
3138 xg_remove_widget_from_map (id
);
3141 /* Callback for button press/release events. Used to start timer so that
3142 the scroll bar repetition timer in GTK gets handeled.
3143 Also, sets bar->dragging to Qnil when dragging (button release) is done.
3144 WIDGET is the scroll bar widget the event is for (not used).
3145 EVENT contains the event.
3146 USER_DATA points to the struct scrollbar structure.
3148 Returns FALSE to tell GTK that it shall continue propagate the event
3152 scroll_bar_button_cb (widget
, event
, user_data
)
3154 GdkEventButton
*event
;
3157 if (event
->type
== GDK_BUTTON_PRESS
&& ! xg_timer
)
3159 else if (event
->type
== GDK_BUTTON_RELEASE
)
3161 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
3162 if (xg_timer
) xg_stop_timer ();
3163 bar
->dragging
= Qnil
;
3169 /* Create a scroll bar widget for frame F. Store the scroll bar
3171 SCROLL_CALLBACK is the callback to invoke when the value of the
3173 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3174 to set resources for the widget. */
3177 xg_create_scroll_bar (f
, bar
, scroll_callback
, scroll_bar_name
)
3179 struct scroll_bar
*bar
;
3180 GCallback scroll_callback
;
3181 char *scroll_bar_name
;
3188 /* Page, step increment values are not so important here, they
3189 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3190 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3193 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3194 webox
= gtk_event_box_new ();
3195 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3196 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3198 scroll_id
= xg_store_widget_in_map (wscroll
);
3200 g_signal_connect (G_OBJECT (wscroll
),
3204 /* The EMACS_INT cast avoids a warning. */
3205 g_signal_connect (G_OBJECT (wscroll
),
3207 G_CALLBACK (xg_gtk_scroll_destroy
),
3208 (gpointer
) (EMACS_INT
) scroll_id
);
3210 /* Connect to button press and button release to detect if any scroll bar
3212 g_signal_connect (G_OBJECT (wscroll
),
3213 "button-press-event",
3214 G_CALLBACK (scroll_bar_button_cb
),
3216 g_signal_connect (G_OBJECT (wscroll
),
3217 "button-release-event",
3218 G_CALLBACK (scroll_bar_button_cb
),
3221 /* The scroll bar widget does not draw on a window of its own. Instead
3222 it draws on the parent window, in this case the edit widget. So
3223 whenever the edit widget is cleared, the scroll bar needs to redraw
3224 also, which causes flicker. Put an event box between the edit widget
3225 and the scroll bar, so the scroll bar instead draws itself on the
3226 event box window. */
3227 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3228 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3231 /* Set the cursor to an arrow. */
3232 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3234 bar
->x_window
= scroll_id
;
3237 /* Make the scroll bar represented by SCROLLBAR_ID visible. */
3240 xg_show_scroll_bar (scrollbar_id
)
3243 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3245 gtk_widget_show_all (gtk_widget_get_parent (w
));
3248 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3251 xg_remove_scroll_bar (f
, scrollbar_id
)
3255 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3258 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3259 gtk_widget_destroy (w
);
3260 gtk_widget_destroy (wparent
);
3261 SET_FRAME_GARBAGED (f
);
3265 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3267 TOP/LEFT are the new pixel positions where the bar shall appear.
3268 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3271 xg_update_scrollbar_pos (f
, scrollbar_id
, top
, left
, width
, height
)
3280 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3284 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3285 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3287 /* Move and resize to new values. */
3288 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3289 gtk_widget_set_size_request (wscroll
, width
, height
);
3290 gtk_widget_queue_draw (wparent
);
3291 gdk_window_process_all_updates ();
3292 /* GTK does not redraw until the main loop is entered again, but
3293 if there are no X events pending we will not enter it. So we sync
3294 here to get some events. */
3296 SET_FRAME_GARBAGED (f
);
3297 cancel_mouse_face (f
);
3301 /* Set the thumb size and position of scroll bar BAR. We are currently
3302 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3305 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
3306 struct scroll_bar
*bar
;
3307 int portion
, position
, whole
;
3309 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3311 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3313 if (wscroll
&& NILP (bar
->dragging
))
3322 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3324 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3325 rather than the real portion value. This makes the thumb less likely
3326 to resize and that looks better. */
3327 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3328 /* When the thumb is at the bottom, position == whole.
3329 So we need to increase `whole' to make space for the thumb. */
3336 top
= (gdouble
) position
/ whole
;
3337 shown
= (gdouble
) portion
/ whole
;
3340 size
= shown
* XG_SB_RANGE
;
3341 size
= min (size
, XG_SB_RANGE
);
3342 size
= max (size
, 1);
3344 value
= top
* XG_SB_RANGE
;
3345 value
= min (value
, XG_SB_MAX
- size
);
3346 value
= max (value
, XG_SB_MIN
);
3348 /* Assume all lines are of equal size. */
3349 new_step
= size
/ max (1, FRAME_LINES (f
));
3351 if ((int) adj
->page_size
!= size
3352 || (int) adj
->step_increment
!= new_step
)
3354 adj
->page_size
= size
;
3355 adj
->step_increment
= new_step
;
3356 /* Assume a page increment is about 95% of the page size */
3357 adj
->page_increment
= (int) (0.95*adj
->page_size
);
3361 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3363 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3367 /* gtk_range_set_value invokes the callback. Set
3368 ignore_gtk_scrollbar to make the callback do nothing */
3369 xg_ignore_gtk_scrollbar
= 1;
3371 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3372 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3374 gtk_adjustment_changed (adj
);
3376 xg_ignore_gtk_scrollbar
= 0;
3384 /***********************************************************************
3386 ***********************************************************************/
3387 /* The key for the data we put in the GtkImage widgets. The data is
3388 the image used by Emacs. We use this to see if we need to update
3389 the GtkImage with a new image. */
3390 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3392 /* The key for storing the latest modifiers so the activate callback can
3394 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3396 /* The key for storing the button widget in its proxy menu item. */
3397 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3399 /* The key for the data we put in the GtkImage widgets. The data is
3400 the stock name used by Emacs. We use this to see if we need to update
3401 the GtkImage with a new image. */
3402 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3404 /* As above, but this is used for named theme widgets, as opposed to
3406 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3408 /* Callback function invoked when a tool bar item is pressed.
3409 W is the button widget in the tool bar that got pressed,
3410 CLIENT_DATA is an integer that is the index of the button in the
3411 tool bar. 0 is the first button. */
3414 xg_tool_bar_button_cb (widget
, event
, user_data
)
3416 GdkEventButton
*event
;
3419 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3420 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3421 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3426 /* Callback function invoked when a tool bar item is pressed.
3427 W is the button widget in the tool bar that got pressed,
3428 CLIENT_DATA is an integer that is the index of the button in the
3429 tool bar. 0 is the first button. */
3432 xg_tool_bar_callback (w
, client_data
)
3434 gpointer client_data
;
3436 /* The EMACS_INT cast avoids a warning. */
3437 int idx
= (int) (EMACS_INT
) client_data
;
3438 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3439 XG_TOOL_BAR_LAST_MODIFIER
);
3441 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3442 Lisp_Object key
, frame
;
3443 struct input_event event
;
3446 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3449 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3451 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3452 XSETFRAME (frame
, f
);
3454 /* We generate two events here. The first one is to set the prefix
3455 to `(tool_bar)', see keyboard.c. */
3456 event
.kind
= TOOL_BAR_EVENT
;
3457 event
.frame_or_window
= frame
;
3459 kbd_buffer_store_event (&event
);
3461 event
.kind
= TOOL_BAR_EVENT
;
3462 event
.frame_or_window
= frame
;
3464 /* Convert between the modifier bits GDK uses and the modifier bits
3465 Emacs uses. This assumes GDK an X masks are the same, which they are when
3467 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3468 kbd_buffer_store_event (&event
);
3471 /* Callback function invoked when a tool bar item is pressed in a detached
3472 tool bar or the overflow drop down menu.
3473 We just call xg_tool_bar_callback.
3474 W is the menu item widget that got pressed,
3475 CLIENT_DATA is an integer that is the index of the button in the
3476 tool bar. 0 is the first button. */
3479 xg_tool_bar_proxy_callback (w
, client_data
)
3481 gpointer client_data
;
3483 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3484 XG_TOOL_BAR_PROXY_BUTTON
));
3485 xg_tool_bar_callback (wbutton
, client_data
);
3488 /* This callback is called when a tool item should create a proxy item,
3489 such as for the overflow menu. Also called when the tool bar is detached.
3490 If we don't create a proxy menu item, the detached tool bar will be
3494 xg_tool_bar_menu_proxy (toolitem
, user_data
)
3495 GtkToolItem
*toolitem
;
3498 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (toolitem
));
3499 GtkButton
*wbutton
= GTK_BUTTON (gtk_bin_get_child (GTK_BIN (weventbox
)));
3500 GtkWidget
*wmenuitem
= gtk_image_menu_item_new ();
3501 GtkWidget
*wmenuimage
;
3503 if (gtk_button_get_use_stock (wbutton
))
3504 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3505 GTK_ICON_SIZE_MENU
);
3508 GtkImage
*wimage
= GTK_IMAGE (gtk_bin_get_child (GTK_BIN (wbutton
)));
3509 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3510 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3512 if (store_type
== GTK_IMAGE_STOCK
)
3515 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3516 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3518 else if (store_type
== GTK_IMAGE_ICON_SET
)
3520 GtkIconSet
*icon_set
;
3521 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3522 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3523 GTK_ICON_SIZE_MENU
);
3525 else if (store_type
== GTK_IMAGE_PIXBUF
)
3530 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3533 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3535 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3536 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3537 GDK_INTERP_BILINEAR
);
3539 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3543 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3547 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3549 const gchar
*icon_name
;
3550 GtkIconSize icon_size
;
3552 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3553 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3554 GTK_ICON_SIZE_MENU
);
3558 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3563 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3565 g_signal_connect (G_OBJECT (wmenuitem
),
3567 GTK_SIGNAL_FUNC (xg_tool_bar_proxy_callback
),
3570 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3571 (gpointer
) wbutton
);
3572 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3577 /* This callback is called when a tool bar is detached. We must set
3578 the height of the tool bar to zero when this happens so frame sizes
3579 are correctly calculated.
3580 WBOX is the handle box widget that enables detach/attach of the tool bar.
3581 W is the tool bar widget.
3582 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3585 xg_tool_bar_detach_callback (wbox
, w
, client_data
)
3588 gpointer client_data
;
3590 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3591 extern int x_gtk_whole_detached_tool_bar
;
3593 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3598 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3600 /* When detaching a tool bar, not everything dissapear. There are
3601 a few pixels left that are used to drop the tool bar back into
3603 FRAME_TOOLBAR_HEIGHT (f
) = 2;
3605 /* The height has changed, resize outer widget and set columns
3606 rows to what we had before detaching the tool bar. */
3607 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3611 /* This callback is called when a tool bar is reattached. We must set
3612 the height of the tool bar when this happens so frame sizes
3613 are correctly calculated.
3614 WBOX is the handle box widget that enables detach/attach of the tool bar.
3615 W is the tool bar widget.
3616 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3619 xg_tool_bar_attach_callback (wbox
, w
, client_data
)
3622 gpointer client_data
;
3624 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3625 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3631 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3633 gtk_widget_size_request (w
, &req
);
3634 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3636 /* The height has changed, resize outer widget and set columns
3637 rows to what we had before attaching the tool bar. */
3638 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3642 /* This callback is called when the mouse enters or leaves a tool bar item.
3643 It is used for displaying and hiding the help text.
3644 W is the tool bar item, a button.
3645 EVENT is either an enter event or leave event.
3646 CLIENT_DATA is an integer that is the index of the button in the
3647 tool bar. 0 is the first button.
3649 Returns FALSE to tell GTK to keep processing this event. */
3652 xg_tool_bar_help_callback (w
, event
, client_data
)
3654 GdkEventCrossing
*event
;
3655 gpointer client_data
;
3657 /* The EMACS_INT cast avoids a warning. */
3658 int idx
= (int) (EMACS_INT
) client_data
;
3659 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3660 Lisp_Object help
, frame
;
3662 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3665 if (event
->type
== GDK_ENTER_NOTIFY
)
3667 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3668 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3671 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3676 XSETFRAME (frame
, f
);
3677 kbd_buffer_store_help_event (frame
, help
);
3683 /* This callback is called when a tool bar item shall be redrawn.
3684 It modifies the expose event so that the GtkImage widget redraws the
3685 whole image. This to overcome a bug that makes GtkImage draw the image
3686 in the wrong place when it tries to redraw just a part of the image.
3687 W is the GtkImage to be redrawn.
3688 EVENT is the expose event for W.
3689 CLIENT_DATA is unused.
3691 Returns FALSE to tell GTK to keep processing this event. */
3694 xg_tool_bar_item_expose_callback (w
, event
, client_data
)
3696 GdkEventExpose
*event
;
3697 gpointer client_data
;
3701 gdk_drawable_get_size (event
->window
, &width
, &height
);
3703 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3704 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3706 event
->area
.x
= max (0, event
->area
.x
);
3707 event
->area
.y
= max (0, event
->area
.y
);
3709 event
->area
.width
= max (width
, event
->area
.width
);
3710 event
->area
.height
= max (height
, event
->area
.height
);
3715 /* Attach a tool bar to frame F. */
3718 xg_pack_tool_bar (f
)
3721 struct x_output
*x
= f
->output_data
.x
;
3722 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3724 x
->handlebox_widget
= gtk_handle_box_new ();
3725 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3726 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3727 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3728 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3730 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3733 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3736 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3738 gtk_widget_show_all (x
->handlebox_widget
);
3741 /* Create a tool bar for frame F. */
3744 xg_create_tool_bar (f
)
3747 struct x_output
*x
= f
->output_data
.x
;
3750 x
->toolbar_widget
= gtk_toolbar_new ();
3751 x
->toolbar_detached
= 0;
3753 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3755 /* We only have icons, so override any user setting. We could
3756 use the caption property of the toolbar item (see update_frame_tool_bar
3757 below), but some of those strings are long, making the toolbar so
3758 long it does not fit on the screen. The GtkToolbar widget makes every
3759 item equal size, so the longest caption determine the size of every
3760 tool bar item. I think the creators of the GtkToolbar widget
3761 counted on 4 or 5 character long strings. */
3762 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3763 gtk_toolbar_set_orientation (GTK_TOOLBAR (x
->toolbar_widget
),
3764 GTK_ORIENTATION_HORIZONTAL
);
3768 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3770 /* Find the right-to-left image named by RTL in the tool bar images for F.
3771 Returns IMAGE if RTL is not found. */
3774 find_rtl_image (f
, image
, rtl
)
3780 Lisp_Object file
, rtl_name
;
3781 struct gcpro gcpro1
, gcpro2
;
3782 GCPRO2 (file
, rtl_name
);
3784 rtl_name
= Ffile_name_nondirectory (rtl
);
3786 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3788 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3789 if (!NILP (file
= file_for_image (rtl_image
)))
3791 file
= call1 (intern ("file-name-sans-extension"),
3792 Ffile_name_nondirectory (file
));
3793 if (EQ (Fequal (file
, rtl_name
), Qt
))
3804 /* Update the tool bar for frame F. Add new buttons and remove old. */
3807 update_frame_tool_bar (f
)
3811 GtkRequisition old_req
, new_req
;
3812 struct x_output
*x
= f
->output_data
.x
;
3813 int hmargin
= 0, vmargin
= 0;
3814 GtkToolbar
*wtoolbar
;
3816 GtkTextDirection dir
;
3817 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
3819 if (! FRAME_GTK_WIDGET (f
))
3824 if (INTEGERP (Vtool_bar_button_margin
)
3825 && XINT (Vtool_bar_button_margin
) > 0)
3827 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3828 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3830 else if (CONSP (Vtool_bar_button_margin
))
3832 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3833 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3834 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3836 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3837 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3838 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3841 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3842 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3843 i.e. zero. This means that margins less than
3844 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3845 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3846 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3848 if (! x
->toolbar_widget
)
3849 xg_create_tool_bar (f
);
3851 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
3852 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &old_req
);
3853 dir
= gtk_widget_get_direction (x
->toolbar_widget
);
3855 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3858 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3859 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3863 struct image
*img
= NULL
;
3866 GtkStockItem stock_item
;
3867 char *stock_name
= NULL
;
3868 char *icon_name
= NULL
;
3870 GtkWidget
*wbutton
= NULL
;
3871 GtkWidget
*weventbox
;
3872 Lisp_Object func
= intern ("x-gtk-map-stock");
3873 Lisp_Object specified_file
;
3875 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (x
->toolbar_widget
), i
);
3879 weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3880 wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3883 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3885 /* Ignore invalid image specifications. */
3886 if (!valid_image_p (image
))
3888 if (wbutton
) gtk_widget_hide (wbutton
);
3892 specified_file
= file_for_image (image
);
3893 if (!NILP (specified_file
) && EQ (Qt
, Ffboundp (func
)))
3894 stock
= call1 (func
, specified_file
);
3896 if (! NILP (stock
) && STRINGP (stock
))
3898 stock_name
= SSDATA (stock
);
3899 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
3901 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
3902 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
3904 icon_name
= stock_name
+ 2;
3908 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
3911 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3913 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
3914 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3922 if (stock_name
== NULL
&& icon_name
== NULL
)
3924 /* No stock image, or stock item not known. Try regular image. */
3926 /* If image is a vector, choose the image according to the
3928 if (dir
== GTK_TEXT_DIR_RTL
3929 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
3932 image
= find_rtl_image (f
, image
, rtl
);
3935 if (VECTORP (image
))
3939 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3940 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3943 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3944 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3946 xassert (ASIZE (image
) >= idx
);
3947 image
= AREF (image
, idx
);
3952 img_id
= lookup_image (f
, image
);
3953 img
= IMAGE_FROM_ID (f
, img_id
);
3954 prepare_image_for_display (f
, img
);
3956 if (img
->load_failed_p
|| img
->pixmap
== None
)
3959 gtk_widget_hide_all (GTK_WIDGET (ti
));
3962 /* Insert an empty (non-image) button */
3963 weventbox
= gtk_event_box_new ();
3964 wbutton
= gtk_button_new ();
3965 gtk_button_set_focus_on_click (GTK_BUTTON (wbutton
), FALSE
);
3966 gtk_button_set_relief (GTK_BUTTON (wbutton
),
3968 gtk_container_add (GTK_CONTAINER (weventbox
), wbutton
);
3969 ti
= gtk_tool_item_new ();
3970 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
3971 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
), ti
, -1);
3982 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
3983 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
3984 (gpointer
) xstrdup (stock_name
),
3985 (GDestroyNotify
) xfree
);
3989 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
3990 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
3991 (gpointer
) xstrdup (icon_name
),
3992 (GDestroyNotify
) xfree
);
3996 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
3997 /* Save the image so we can see if an update is needed when
3998 this function is called again. */
3999 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4000 (gpointer
)img
->pixmap
);
4003 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4004 wbutton
= gtk_button_new ();
4005 gtk_button_set_focus_on_click (GTK_BUTTON (wbutton
), FALSE
);
4006 gtk_button_set_relief (GTK_BUTTON (wbutton
), GTK_RELIEF_NONE
);
4007 gtk_container_add (GTK_CONTAINER (wbutton
), w
);
4008 weventbox
= gtk_event_box_new ();
4009 gtk_container_add (GTK_CONTAINER (weventbox
), wbutton
);
4010 ti
= gtk_tool_item_new ();
4011 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4012 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
), ti
, -1);
4015 /* The EMACS_INT cast avoids a warning. */
4016 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4017 GTK_SIGNAL_FUNC (xg_tool_bar_menu_proxy
),
4018 (gpointer
) (EMACS_INT
) i
);
4020 g_signal_connect (G_OBJECT (wbutton
), "clicked",
4021 GTK_SIGNAL_FUNC (xg_tool_bar_callback
),
4022 (gpointer
) (EMACS_INT
) i
);
4024 gtk_widget_show_all (GTK_WIDGET (ti
));
4027 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4029 /* Catch expose events to overcome an annoying redraw bug, see
4030 comment for xg_tool_bar_item_expose_callback. */
4031 g_signal_connect (G_OBJECT (ti
),
4033 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4036 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4037 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4039 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
4040 no distinction based on modifiers in the activate callback,
4041 so we have to do it ourselves. */
4042 g_signal_connect (wbutton
, "button-release-event",
4043 GTK_SIGNAL_FUNC (xg_tool_bar_button_cb
),
4046 g_object_set_data (G_OBJECT (wbutton
), XG_FRAME_DATA
, (gpointer
)f
);
4048 /* Use enter/leave notify to show help. We use the events
4049 rather than the GtkButton specific signals "enter" and
4050 "leave", so we can have only one callback. The event
4051 will tell us what kind of event it is. */
4052 /* The EMACS_INT cast avoids a warning. */
4053 g_signal_connect (G_OBJECT (weventbox
),
4054 "enter-notify-event",
4055 G_CALLBACK (xg_tool_bar_help_callback
),
4056 (gpointer
) (EMACS_INT
) i
);
4057 g_signal_connect (G_OBJECT (weventbox
),
4058 "leave-notify-event",
4059 G_CALLBACK (xg_tool_bar_help_callback
),
4060 (gpointer
) (EMACS_INT
) i
);
4064 GtkWidget
*wimage
= gtk_bin_get_child (GTK_BIN (wbutton
));
4065 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
4066 XG_TOOL_BAR_IMAGE_DATA
);
4067 gpointer old_stock_name
= g_object_get_data (G_OBJECT (wimage
),
4068 XG_TOOL_BAR_STOCK_NAME
);
4069 gpointer old_icon_name
= g_object_get_data (G_OBJECT (wimage
),
4070 XG_TOOL_BAR_ICON_NAME
);
4072 (! old_stock_name
|| strcmp (old_stock_name
, stock_name
) != 0))
4074 gtk_image_set_from_stock (GTK_IMAGE (wimage
),
4075 stock_name
, icon_size
);
4076 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4077 (gpointer
) xstrdup (stock_name
),
4078 (GDestroyNotify
) xfree
);
4079 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4081 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
, NULL
);
4083 else if (icon_name
&&
4084 (! old_icon_name
|| strcmp (old_icon_name
, icon_name
) != 0))
4086 gtk_image_set_from_icon_name (GTK_IMAGE (wimage
),
4087 icon_name
, icon_size
);
4088 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4089 (gpointer
) xstrdup (icon_name
),
4090 (GDestroyNotify
) xfree
);
4091 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4093 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4096 else if (img
&& old_img
!= img
->pixmap
)
4098 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
4099 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4100 (gpointer
)img
->pixmap
);
4102 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4104 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
, NULL
);
4107 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
4109 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4110 gtk_widget_show_all (GTK_WIDGET (ti
));
4116 /* Remove buttons not longer needed. We just hide them so they
4117 can be reused later on. */
4120 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (x
->toolbar_widget
), i
++);
4121 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
4122 } while (ti
!= NULL
);
4125 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &new_req
);
4127 if (pack_tool_bar
&& f
->n_tool_bar_items
!= 0)
4128 xg_pack_tool_bar (f
);
4130 if (new_req
.height
!= 0
4131 && f
->n_tool_bar_items
!= 0
4132 && old_req
.height
!= new_req
.height
4133 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
4135 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
4136 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
4142 /* Deallocate all resources for the tool bar on frame F.
4143 Remove the tool bar. */
4146 free_frame_tool_bar (f
)
4149 struct x_output
*x
= f
->output_data
.x
;
4151 if (x
->toolbar_widget
)
4153 int is_packed
= x
->handlebox_widget
!= 0;
4155 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4156 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4158 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4159 x
->handlebox_widget
);
4161 gtk_widget_destroy (x
->toolbar_widget
);
4163 x
->toolbar_widget
= 0;
4164 x
->handlebox_widget
= 0;
4165 FRAME_TOOLBAR_HEIGHT (f
) = 0;
4167 /* The height has changed, resize outer widget and set columns
4168 rows to what we had before removing the tool bar. */
4169 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
4176 /***********************************************************************
4178 ***********************************************************************/
4182 GtkBindingSet
*binding_set
;
4185 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4186 we keep it permanently linked in. */
4191 xg_ignore_gtk_scrollbar
= 0;
4192 xg_detached_menus
= 0;
4193 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4194 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4196 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4197 id_to_widget
.widgets
= 0;
4199 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4200 bindings. It doesn't seem to be any way to remove properties,
4201 so we set it to VoidSymbol which in X means "no key". */
4202 gtk_settings_set_string_property (gtk_settings_get_default (),
4203 "gtk-menu-bar-accel",
4207 /* Make GTK text input widgets use Emacs style keybindings. This is
4209 gtk_settings_set_string_property (gtk_settings_get_default (),
4210 "gtk-key-theme-name",
4214 /* Make dialogs close on C-g. Since file dialog inherits from
4215 dialog, this works for them also. */
4216 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_DIALOG
));
4217 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4220 /* Make menus close on C-g. */
4221 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_MENU_SHELL
));
4222 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4226 #endif /* USE_GTK */
4228 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
4229 (do not change this comment) */