1 /* Functions for creating and updating GTK widgets.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
29 #include "blockinput.h"
30 #include "syssignal.h"
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 /* When the GTK widget W is to be created on a display for F that
62 is not the default display, set the display for W.
63 W can be a GtkMenu or a GtkWindow widget. */
70 if (FRAME_X_DISPLAY (f
) != GDK_DISPLAY ())
72 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
73 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
76 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
78 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
83 #else /* not HAVE_GTK_MULTIDISPLAY */
85 /* Make some defines so we can use the GTK 2.2 functions when
86 compiling with GTK 2.0. */
88 #define xg_set_screen(w, f)
89 #define gdk_xid_table_lookup_for_display(dpy, w) gdk_xid_table_lookup (w)
90 #define gdk_pixmap_foreign_new_for_display(dpy, p) gdk_pixmap_foreign_new (p)
91 #define gdk_cursor_new_for_display(dpy, c) gdk_cursor_new (c)
92 #define gdk_x11_lookup_xdisplay(dpy) 0
93 #define GdkDisplay void
95 #endif /* not HAVE_GTK_MULTIDISPLAY */
97 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
98 *DPY is set to NULL if the display can't be opened.
100 Returns non-zero if display could be opened, zero if display could not
101 be opened, and less than zero if the GTK version doesn't support
105 xg_display_open (display_name
, dpy
)
109 #ifdef HAVE_GTK_MULTIDISPLAY
112 gdpy
= gdk_display_open (display_name
);
113 if (!gdpy_def
&& gdpy
)
116 gdk_display_manager_set_default_display (gdk_display_manager_get (),
120 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
123 #else /* not HAVE_GTK_MULTIDISPLAY */
126 #endif /* not HAVE_GTK_MULTIDISPLAY */
130 /* Close display DPY. */
133 xg_display_close (Display
*dpy
)
135 #ifdef HAVE_GTK_MULTIDISPLAY
136 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
138 /* If this is the default display, try to change it before closing.
139 If there is no other display to use, gdpy_def is set to NULL, and
140 the next call to xg_display_open resets the default display. */
141 if (gdk_display_get_default () == gdpy
)
143 struct x_display_info
*dpyinfo
;
144 GdkDisplay
*gdpy_new
= NULL
;
146 /* Find another display. */
147 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
148 if (dpyinfo
->display
!= dpy
)
150 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
151 gdk_display_manager_set_default_display (gdk_display_manager_get (),
158 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
159 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
160 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
161 can continue running, but there will be memory leaks. */
162 g_object_run_dispose (G_OBJECT (gdpy
));
164 /* This seems to be fixed in GTK 2.10. */
165 gdk_display_close (gdpy
);
167 #endif /* HAVE_GTK_MULTIDISPLAY */
171 /***********************************************************************
173 ***********************************************************************/
174 /* The next two variables and functions are taken from lwlib. */
175 static widget_value
*widget_value_free_list
;
176 static int malloc_cpt
;
178 /* Allocate a widget_value structure, either by taking one from the
179 widget_value_free_list or by malloc:ing a new one.
181 Return a pointer to the allocated structure. */
184 malloc_widget_value ()
187 if (widget_value_free_list
)
189 wv
= widget_value_free_list
;
190 widget_value_free_list
= wv
->free_list
;
195 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
198 memset (wv
, 0, sizeof (widget_value
));
202 /* This is analogous to free. It frees only what was allocated
203 by malloc_widget_value, and no substructures. */
206 free_widget_value (wv
)
214 /* When the number of already allocated cells is too big,
221 wv
->free_list
= widget_value_free_list
;
222 widget_value_free_list
= wv
;
227 /* Create and return the cursor to be used for popup menus and
228 scroll bars on display DPY. */
231 xg_create_default_cursor (dpy
)
234 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
235 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
238 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
241 xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
)
247 GdkPixbuf
*icon_buf
, *tmp_buf
;
249 gdk_drawable_get_size (gpix
, &width
, &height
);
250 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
251 0, 0, 0, 0, width
, height
);
252 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
253 g_object_unref (G_OBJECT (tmp_buf
));
257 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
262 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
263 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
264 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
265 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
268 for (y
= 0; y
< height
; ++y
)
270 guchar
*iconptr
, *maskptr
;
273 iconptr
= pixels
+ y
* rowstride
;
274 maskptr
= mask_pixels
+ y
* mask_rowstride
;
276 for (x
= 0; x
< width
; ++x
)
278 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
279 just R is sufficient. */
281 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
283 iconptr
+= rowstride
/width
;
284 maskptr
+= mask_rowstride
/width
;
288 g_object_unref (G_OBJECT (mask_buf
));
295 file_for_image (image
)
298 Lisp_Object specified_file
= Qnil
;
300 extern Lisp_Object QCfile
;
302 for (tail
= XCDR (image
);
303 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
304 tail
= XCDR (XCDR (tail
)))
305 if (EQ (XCAR (tail
), QCfile
))
306 specified_file
= XCAR (XCDR (tail
));
308 return specified_file
;
311 /* For the image defined in IMG, make and return a GtkImage. For displays with
312 8 planes or less we must make a GdkPixbuf and apply the mask manually.
313 Otherwise the highlightning and dimming the tool bar code in GTK does
314 will look bad. For display with more than 8 planes we just use the
315 pixmap and mask directly. For monochrome displays, GTK doesn't seem
316 able to use external pixmaps, it looks bad whatever we do.
317 The image is defined on the display where frame F is.
318 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
319 If OLD_WIDGET is NULL, a new widget is constructed and returned.
320 If OLD_WIDGET is not NULL, that widget is modified. */
323 xg_get_image_for_pixmap (f
, img
, widget
, old_widget
)
327 GtkImage
*old_widget
;
335 /* If we have a file, let GTK do all the image handling.
336 This seems to be the only way to make insensitive and activated icons
337 look good in all cases. */
338 Lisp_Object specified_file
= file_for_image (img
->spec
);
341 /* We already loaded the image once before calling this
342 function, so this only fails if the image file has been removed.
343 In that case, use the pixmap already loaded. */
345 if (STRINGP (specified_file
)
346 && STRINGP (file
= x_find_image_file (specified_file
)))
349 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
351 gtk_image_set_from_file (old_widget
, SSDATA (file
));
353 return GTK_WIDGET (old_widget
);
356 /* No file, do the image handling ourselves. This will look very bad
357 on a monochrome display, and sometimes bad on all displays with
360 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
361 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
362 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
364 /* This is a workaround to make icons look good on pseudo color
365 displays. Apparently GTK expects the images to have an alpha
366 channel. If they don't, insensitive and activated icons will
367 look bad. This workaround does not work on monochrome displays,
368 and is strictly not needed on true color/static color displays (i.e.
369 16 bits and higher). But we do it anyway so we get a pixbuf that is
370 not associated with the img->pixmap. The img->pixmap may be removed
371 by clearing the image cache and then the tool bar redraw fails, since
372 Gtk+ assumes the pixmap is always there. */
373 cmap
= gtk_widget_get_colormap (widget
);
374 icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
377 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
379 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
381 g_object_unref (G_OBJECT (icon_buf
));
383 g_object_unref (G_OBJECT (gpix
));
384 if (gmask
) g_object_unref (G_OBJECT (gmask
));
386 return GTK_WIDGET (old_widget
);
390 /* Set CURSOR on W and all widgets W contain. We must do like this
391 for scroll bars and menu because they create widgets internally,
392 and it is those widgets that are visible. */
395 xg_set_cursor (w
, cursor
)
399 GList
*children
= gdk_window_peek_children (w
->window
);
401 gdk_window_set_cursor (w
->window
, cursor
);
403 /* The scroll bar widget has more than one GDK window (had to look at
404 the source to figure this out), and there is no way to set cursor
405 on widgets in GTK. So we must set the cursor for all GDK windows.
408 for ( ; children
; children
= g_list_next (children
))
409 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
412 /* Insert NODE into linked LIST. */
415 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
417 xg_list_node
*list_start
= list
->next
;
419 if (list_start
) list_start
->prev
= node
;
420 node
->next
= list_start
;
425 /* Remove NODE from linked LIST. */
428 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
430 xg_list_node
*list_start
= list
->next
;
431 if (node
== list_start
)
433 list
->next
= node
->next
;
434 if (list
->next
) list
->next
->prev
= 0;
438 node
->prev
->next
= node
->next
;
439 if (node
->next
) node
->next
->prev
= node
->prev
;
443 /* Allocate and return a utf8 version of STR. If STR is already
444 utf8 or NULL, just return STR.
445 If not, a new string is allocated and the caller must free the result
449 get_utf8_string (str
)
452 char *utf8_str
= str
;
454 if (!str
) return NULL
;
456 /* If not UTF-8, try current locale. */
457 if (!g_utf8_validate (str
, -1, NULL
))
458 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
462 /* Probably some control characters in str. Escape them. */
466 unsigned char *p
= (unsigned char *)str
;
468 GError
*error
= NULL
;
470 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
471 &bytes_written
, &error
))
472 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
475 p
+= bytes_written
+1;
476 g_error_free (error
);
482 g_error_free (error
);
487 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
488 p
= (unsigned char *)str
;
490 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
491 &bytes_written
, &error
))
492 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
494 strncpy (up
, (char *)p
, bytes_written
);
495 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
496 up
[bytes_written
+4] = '\0';
497 up
+= bytes_written
+4;
498 p
+= bytes_written
+1;
499 g_error_free (error
);
505 strcat (utf8_str
, cp
);
510 g_error_free (error
);
519 /***********************************************************************
520 General functions for creating widgets, resizing, events, e.t.c.
521 ***********************************************************************/
523 /* Make a geometry string and pass that to GTK. It seems this is the
524 only way to get geometry position right if the user explicitly
525 asked for a position when starting Emacs.
526 F is the frame we shall set geometry for. */
532 if (f
->size_hint_flags
& (USPosition
| PPosition
))
534 int left
= f
->left_pos
;
535 int xneg
= f
->size_hint_flags
& XNegative
;
536 int top
= f
->top_pos
;
537 int yneg
= f
->size_hint_flags
& YNegative
;
545 sprintf (geom_str
, "%c%d%c%d",
546 (xneg
? '-' : '+'), left
,
547 (yneg
? '-' : '+'), top
);
549 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
551 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
555 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
556 and use a GtkFixed widget, this doesn't happen automatically. */
559 xg_clear_under_internal_border (f
)
562 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
564 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
565 gtk_widget_queue_draw (wfixed
);
566 gdk_window_process_all_updates ();
567 x_clear_area (FRAME_X_DISPLAY (f
),
570 FRAME_PIXEL_WIDTH (f
),
571 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
572 x_clear_area (FRAME_X_DISPLAY (f
),
575 FRAME_INTERNAL_BORDER_WIDTH (f
),
576 FRAME_PIXEL_HEIGHT (f
), 0);
577 x_clear_area (FRAME_X_DISPLAY (f
),
579 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
580 FRAME_PIXEL_WIDTH (f
),
581 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
582 x_clear_area (FRAME_X_DISPLAY (f
),
584 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
586 FRAME_INTERNAL_BORDER_WIDTH (f
),
587 FRAME_PIXEL_HEIGHT (f
), 0);
591 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
592 and a Gtk+ menu bar, we get resize events for the edit part of the
593 frame only. We let Gtk+ deal with the Gtk+ parts.
594 F is the frame to resize.
595 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
598 xg_frame_resized (f
, pixelwidth
, pixelheight
)
600 int pixelwidth
, pixelheight
;
604 if (pixelwidth
== -1 && pixelheight
== -1)
606 if (FRAME_GTK_WIDGET (f
) && GTK_WIDGET_MAPPED (FRAME_GTK_WIDGET (f
)))
607 gdk_window_get_geometry (FRAME_GTK_WIDGET (f
)->window
, 0, 0,
608 &pixelwidth
, &pixelheight
, 0);
613 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
614 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
616 if (columns
!= FRAME_COLS (f
)
617 || rows
!= FRAME_LINES (f
)
618 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
619 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
621 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
622 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
624 xg_clear_under_internal_border (f
);
625 change_frame_size (f
, rows
, columns
, 0, 1, 0);
626 SET_FRAME_GARBAGED (f
);
627 cancel_mouse_face (f
);
631 /* Resize the outer window of frame F after chainging the height.
632 COLUMNS/ROWS is the size the edit area shall have after the resize. */
635 xg_frame_set_char_size (f
, cols
, rows
)
640 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
641 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
644 if (FRAME_PIXEL_HEIGHT (f
) == 0)
647 /* Take into account the size of the scroll bar. Always use the
648 number of columns occupied by the scroll bar here otherwise we
649 might end up with a frame width that is not a multiple of the
650 frame's character width which is bad for vertically split
652 f
->scroll_bar_actual_width
653 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
655 compute_fringe_widths (f
, 0);
657 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
658 after calculating that value. */
659 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
662 /* Do this before resize, as we don't know yet if we will be resized. */
663 xg_clear_under_internal_border (f
);
665 /* Must resize our top level widget. Font size may have changed,
666 but not rows/cols. */
667 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
668 pixelwidth
, pixelheight
);
669 x_wm_set_size_hint (f
, 0, 0);
671 SET_FRAME_GARBAGED (f
);
672 cancel_mouse_face (f
);
674 /* We can not call change_frame_size for a mapped frame,
675 we can not set pixel width/height either. The window manager may
676 override our resize request, XMonad does this all the time.
677 The best we can do is try to sync, so lisp code sees the updated
678 size as fast as possible.
679 For unmapped windows, we can set rows/cols. When
680 the frame is mapped again we will (hopefully) get the correct size. */
681 if (f
->async_visible
)
683 /* Must call this to flush out events */
684 (void)gtk_events_pending ();
686 x_wait_for_event (f
, ConfigureNotify
);
690 change_frame_size (f
, rows
, cols
, 0, 1, 0);
691 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
692 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
696 /* Handle height changes (i.e. add/remove menu/toolbar).
697 The policy is to keep the number of editable lines. */
700 xg_height_changed (f
)
703 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
704 FRAME_PIXEL_WIDTH (f
), FRAME_TOTAL_PIXEL_HEIGHT (f
));
705 f
->output_data
.x
->hint_flags
= 0;
706 x_wm_set_size_hint (f
, 0, 0);
709 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
710 Must be done like this, because GtkWidget:s can have "hidden"
711 X Window that aren't accessible.
713 Return 0 if no widget match WDESC. */
716 xg_win_to_widget (dpy
, wdesc
)
721 GtkWidget
*gwdesc
= 0;
725 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
730 event
.any
.window
= gdkwin
;
731 gwdesc
= gtk_get_event_widget (&event
);
738 /* Fill in the GdkColor C so that it represents PIXEL.
739 W is the widget that color will be used for. Used to find colormap. */
742 xg_pix_to_gcolor (w
, pixel
, c
)
747 GdkColormap
*map
= gtk_widget_get_colormap (w
);
748 gdk_colormap_query_color (map
, pixel
, c
);
751 /* Create and set up the GTK widgets for frame F.
752 Return 0 if creation failed, non-zero otherwise. */
755 xg_create_frame_widgets (f
)
767 if (FRAME_X_EMBEDDED_P (f
))
768 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
770 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
772 xg_set_screen (wtop
, f
);
774 wvbox
= gtk_vbox_new (FALSE
, 0);
775 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
777 if (! wtop
|| ! wvbox
|| ! wfixed
)
779 if (wtop
) gtk_widget_destroy (wtop
);
780 if (wvbox
) gtk_widget_destroy (wvbox
);
781 if (wfixed
) gtk_widget_destroy (wfixed
);
787 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
788 gtk_widget_set_name (wtop
, EMACS_CLASS
);
789 gtk_widget_set_name (wvbox
, "pane");
790 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
792 /* If this frame has a title or name, set it in the title bar. */
793 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
794 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
796 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
798 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
799 FRAME_GTK_WIDGET (f
) = wfixed
;
800 f
->output_data
.x
->vbox_widget
= wvbox
;
802 gtk_fixed_set_has_window (GTK_FIXED (wfixed
), TRUE
);
804 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
805 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
807 if (FRAME_EXTERNAL_TOOL_BAR (f
))
808 update_frame_tool_bar (f
);
810 /* We don't want this widget double buffered, because we draw on it
811 with regular X drawing primitives, so from a GTK/GDK point of
812 view, the widget is totally blank. When an expose comes, this
813 will make the widget blank, and then Emacs redraws it. This flickers
814 a lot, so we turn off double buffering. */
815 gtk_widget_set_double_buffered (wfixed
, FALSE
);
817 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
818 SSDATA (Vx_resource_name
),
819 SSDATA (Vx_resource_class
));
821 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
822 GTK is to destroy the widget. We want Emacs to do that instead. */
823 g_signal_connect (G_OBJECT (wtop
), "delete-event",
824 G_CALLBACK (gtk_true
), 0);
826 /* Convert our geometry parameters into a geometry string
828 GTK will itself handle calculating the real position this way. */
831 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
833 gtk_widget_add_events (wfixed
,
834 GDK_POINTER_MOTION_MASK
836 | GDK_BUTTON_PRESS_MASK
837 | GDK_BUTTON_RELEASE_MASK
839 | GDK_ENTER_NOTIFY_MASK
840 | GDK_LEAVE_NOTIFY_MASK
841 | GDK_FOCUS_CHANGE_MASK
843 | GDK_VISIBILITY_NOTIFY_MASK
);
845 /* Must realize the windows so the X window gets created. It is used
846 by callers of this function. */
847 gtk_widget_realize (wfixed
);
848 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
850 /* Since GTK clears its window by filling with the background color,
851 we must keep X and GTK background in sync. */
852 xg_pix_to_gcolor (wfixed
, FRAME_BACKGROUND_PIXEL (f
), &bg
);
853 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
855 /* Also, do not let any background pixmap to be set, this looks very
856 bad as Emacs overwrites the background pixmap with its own idea
857 of background color. */
858 style
= gtk_widget_get_modifier_style (wfixed
);
860 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
861 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
862 gtk_widget_modify_style (wfixed
, style
);
864 /* GTK does not set any border, and they look bad with GTK. */
865 /* That they look bad is no excuse for imposing this here. --Stef
866 It should be done by providing the proper default in Fx_create_Frame.
868 f->internal_border_width = 0; */
875 /* Set the normal size hints for the window manager, for frame F.
876 FLAGS is the flags word to use--or 0 meaning preserve the flags
877 that the window now has.
878 If USER_POSITION is nonzero, we set the User Position
879 flag (this is useful when FLAGS is 0). */
882 x_wm_set_size_hint (f
, flags
, user_position
)
887 /* Must use GTK routines here, otherwise GTK resets the size hints
888 to its own defaults. */
889 GdkGeometry size_hints
;
891 int base_width
, base_height
;
892 int min_rows
= 0, min_cols
= 0;
893 int win_gravity
= f
->win_gravity
;
895 /* Don't set size hints during initialization; that apparently leads
896 to a race condition. See the thread at
897 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
898 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
903 memset (&size_hints
, 0, sizeof (size_hints
));
904 f
->output_data
.x
->size_hints
= size_hints
;
905 f
->output_data
.x
->hint_flags
= hint_flags
;
908 flags
= f
->size_hint_flags
;
910 size_hints
= f
->output_data
.x
->size_hints
;
911 hint_flags
= f
->output_data
.x
->hint_flags
;
913 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
914 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
915 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
917 hint_flags
|= GDK_HINT_BASE_SIZE
;
918 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
919 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
920 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
922 check_frame_size (f
, &min_rows
, &min_cols
);
924 size_hints
.base_width
= base_width
;
925 size_hints
.base_height
= base_height
;
926 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
927 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
929 /* These currently have a one to one mapping with the X values, but I
930 don't think we should rely on that. */
931 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
932 size_hints
.win_gravity
= 0;
933 if (win_gravity
== NorthWestGravity
)
934 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
935 else if (win_gravity
== NorthGravity
)
936 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
937 else if (win_gravity
== NorthEastGravity
)
938 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
939 else if (win_gravity
== WestGravity
)
940 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
941 else if (win_gravity
== CenterGravity
)
942 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
943 else if (win_gravity
== EastGravity
)
944 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
945 else if (win_gravity
== SouthWestGravity
)
946 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
947 else if (win_gravity
== SouthGravity
)
948 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
949 else if (win_gravity
== SouthEastGravity
)
950 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
951 else if (win_gravity
== StaticGravity
)
952 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
954 if (hint_flags
!= f
->output_data
.x
->hint_flags
955 || memcmp (&size_hints
,
956 &f
->output_data
.x
->size_hints
,
957 sizeof (size_hints
)) != 0)
960 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
961 NULL
, &size_hints
, hint_flags
);
962 f
->output_data
.x
->size_hints
= size_hints
;
963 f
->output_data
.x
->hint_flags
= hint_flags
;
968 /* Change background color of a frame.
969 Since GTK uses the background color to clear the window, we must
970 keep the GTK and X colors in sync.
971 F is the frame to change,
972 BG is the pixel value to change to. */
975 xg_set_background_color (f
, bg
)
979 if (FRAME_GTK_WIDGET (f
))
984 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
985 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
991 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
992 functions so GTK does not overwrite the icon. */
995 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
)
1000 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1001 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
1002 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
1003 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
1005 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1010 /***********************************************************************
1012 ***********************************************************************/
1013 /* Return the dialog title to use for a dialog of type KEY.
1014 This is the encoding used by lwlib. We use the same for GTK. */
1017 get_dialog_title (char key
)
1027 title
= "Information";
1046 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1047 the dialog, but return TRUE so the event does not propagate further
1048 in GTK. This prevents GTK from destroying the dialog widget automatically
1049 and we can always destrou the widget manually, regardles of how
1050 it was popped down (button press or WM_DELETE_WINDOW).
1051 W is the dialog widget.
1052 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1053 user_data is NULL (not used).
1055 Returns TRUE to end propagation of event. */
1058 dialog_delete_callback (w
, event
, user_data
)
1063 gtk_widget_unmap (w
);
1067 /* Create a popup dialog window. See also xg_create_widget below.
1068 WV is a widget_value describing the dialog.
1069 SELECT_CB is the callback to use when a button has been pressed.
1070 DEACTIVATE_CB is the callback to use when the dialog pops down.
1072 Returns the GTK dialog widget. */
1075 create_dialog (wv
, select_cb
, deactivate_cb
)
1077 GCallback select_cb
;
1078 GCallback deactivate_cb
;
1080 char *title
= get_dialog_title (wv
->name
[0]);
1081 int total_buttons
= wv
->name
[1] - '0';
1082 int right_buttons
= wv
->name
[4] - '0';
1085 int button_spacing
= 10;
1086 GtkWidget
*wdialog
= gtk_dialog_new ();
1090 GtkWidget
*whbox_up
;
1091 GtkWidget
*whbox_down
;
1093 /* If the number of buttons is greater than 4, make two rows of buttons
1094 instead. This looks better. */
1095 int make_two_rows
= total_buttons
> 4;
1097 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1098 left_buttons
= total_buttons
- right_buttons
;
1100 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1101 gtk_widget_set_name (wdialog
, "emacs-dialog");
1103 cur_box
= GTK_BOX (GTK_DIALOG (wdialog
)->action_area
);
1107 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1108 whbox_up
= gtk_hbox_new (FALSE
, 0);
1109 whbox_down
= gtk_hbox_new (FALSE
, 0);
1111 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1112 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1113 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1115 cur_box
= GTK_BOX (whbox_up
);
1118 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1119 G_CALLBACK (dialog_delete_callback
), 0);
1123 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1124 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1127 for (item
= wv
->contents
; item
; item
= item
->next
)
1129 char *utf8_label
= get_utf8_string (item
->value
);
1133 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1135 /* This is the text part of the dialog. */
1136 w
= gtk_label_new (utf8_label
);
1137 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1140 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
), w
,
1142 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1144 /* Try to make dialog look better. Must realize first so
1145 the widget can calculate the size it needs. */
1146 gtk_widget_realize (w
);
1147 gtk_widget_size_request (w
, &req
);
1148 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1150 if (item
->value
&& strlen (item
->value
) > 0)
1151 button_spacing
= 2*req
.width
/strlen (item
->value
);
1155 /* This is one button to add to the dialog. */
1156 w
= gtk_button_new_with_label (utf8_label
);
1157 if (! item
->enabled
)
1158 gtk_widget_set_sensitive (w
, FALSE
);
1160 g_signal_connect (G_OBJECT (w
), "clicked",
1161 select_cb
, item
->call_data
);
1163 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1164 if (++button_nr
== left_buttons
)
1167 cur_box
= GTK_BOX (whbox_down
);
1169 gtk_box_pack_start (cur_box
,
1176 if (utf8_label
&& utf8_label
!= item
->value
)
1177 g_free (utf8_label
);
1183 struct xg_dialog_data
1191 /* Function that is called when the file or font dialogs pop down.
1192 W is the dialog widget, RESPONSE is the response code.
1193 USER_DATA is what we passed in to g_signal_connect. */
1196 xg_dialog_response_cb (w
,
1203 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1204 dd
->response
= response
;
1205 g_main_loop_quit (dd
->loop
);
1209 /* Destroy the dialog. This makes it pop down. */
1212 pop_down_dialog (arg
)
1215 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1216 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1219 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1220 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1222 g_main_loop_quit (dd
->loop
);
1223 g_main_loop_unref (dd
->loop
);
1230 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1231 We pass in DATA as gpointer* so we can use this as a callback. */
1234 xg_maybe_add_timer (data
)
1237 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1238 EMACS_TIME next_time
= timer_check (1);
1239 long secs
= EMACS_SECS (next_time
);
1240 long usecs
= EMACS_USECS (next_time
);
1244 if (secs
>= 0 && usecs
>= 0 && secs
< ((guint
)-1)/1000)
1246 dd
->timerid
= g_timeout_add (secs
* 1000 + usecs
/1000,
1254 /* Pops up a modal dialog W and waits for response.
1255 We don't use gtk_dialog_run because we want to process emacs timers.
1256 The dialog W is not destroyed when this function returns. */
1259 xg_dialog_run (f
, w
)
1264 int count
= SPECPDL_INDEX ();
1265 struct xg_dialog_data dd
;
1267 xg_set_screen (w
, f
);
1268 gtk_window_set_transient_for (GTK_WINDOW (w
),
1269 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1270 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1271 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1273 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1274 dd
.response
= GTK_RESPONSE_CANCEL
;
1278 g_signal_connect (G_OBJECT (w
),
1280 G_CALLBACK (xg_dialog_response_cb
),
1282 /* Don't destroy the widget if closed by the window manager close button. */
1283 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1284 gtk_widget_show (w
);
1286 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1288 (void) xg_maybe_add_timer (&dd
);
1289 g_main_loop_run (dd
.loop
);
1292 unbind_to (count
, Qnil
);
1298 /***********************************************************************
1299 File dialog functions
1300 ***********************************************************************/
1301 /* Return non-zero if the old file selection dialog is being used.
1302 Return zero if not. */
1305 xg_uses_old_file_dialog ()
1307 #ifdef HAVE_GTK_FILE_BOTH
1308 extern int x_gtk_use_old_file_dialog
;
1309 return x_gtk_use_old_file_dialog
;
1310 #else /* ! HAVE_GTK_FILE_BOTH */
1312 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1318 #endif /* ! HAVE_GTK_FILE_BOTH */
1322 typedef char * (*xg_get_file_func
) P_ ((GtkWidget
*));
1324 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1326 /* Return the selected file for file chooser dialog W.
1327 The returned string must be free:d. */
1330 xg_get_file_name_from_chooser (w
)
1333 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1336 /* Callback called when the "Show hidden files" toggle is pressed.
1337 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1340 xg_toggle_visibility_cb (widget
, data
)
1344 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1346 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1347 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1351 /* Callback called when a property changes in a file chooser.
1352 GOBJECT is the file chooser dialog, ARG1 describes the property.
1353 USER_DATA is the toggle widget in the file chooser dialog.
1354 We use this to update the "Show hidden files" toggle when the user
1355 changes that property by right clicking in the file list. */
1358 xg_toggle_notify_cb (gobject
, arg1
, user_data
)
1363 extern int x_gtk_show_hidden_files
;
1365 if (strcmp (arg1
->name
, "show-hidden") == 0)
1367 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1368 gboolean visible
, toggle_on
;
1370 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1371 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1373 if (!!visible
!= !!toggle_on
)
1375 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1376 G_CALLBACK (xg_toggle_visibility_cb
),
1378 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1379 g_signal_handlers_unblock_by_func
1380 (G_OBJECT (wtoggle
),
1381 G_CALLBACK (xg_toggle_visibility_cb
),
1384 x_gtk_show_hidden_files
= visible
;
1388 /* Read a file name from the user using a file chooser dialog.
1389 F is the current frame.
1390 PROMPT is a prompt to show to the user. May not be NULL.
1391 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1392 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1393 file. *FUNC is set to a function that can be used to retrieve the
1394 selected file name from the returned widget.
1396 Returns the created widget. */
1399 xg_get_file_with_chooser (f
, prompt
, default_filename
,
1400 mustmatch_p
, only_dir_p
, func
)
1403 char *default_filename
;
1404 int mustmatch_p
, only_dir_p
;
1405 xg_get_file_func
*func
;
1409 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1410 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1411 GtkFileChooserAction action
= (mustmatch_p
?
1412 GTK_FILE_CHOOSER_ACTION_OPEN
:
1413 GTK_FILE_CHOOSER_ACTION_SAVE
);
1414 extern int x_gtk_show_hidden_files
;
1415 extern int x_gtk_file_dialog_help_text
;
1419 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1421 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1422 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1423 (mustmatch_p
|| only_dir_p
?
1424 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1427 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1429 wbox
= gtk_vbox_new (FALSE
, 0);
1430 gtk_widget_show (wbox
);
1431 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1433 if (x_gtk_show_hidden_files
)
1435 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1436 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1438 gtk_widget_show (wtoggle
);
1439 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1440 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1441 g_signal_connect (G_OBJECT (filewin
), "notify",
1442 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1444 if (x_gtk_file_dialog_help_text
)
1447 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1448 Show the C-l help text only for versions < 2.10. */
1449 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1450 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1451 strcat (message
, "\nIf you don't like this file selector, use the "
1452 "corresponding\nkey binding or customize "
1453 "use-file-dialog to turn it off.");
1455 wmessage
= gtk_label_new (message
);
1456 gtk_widget_show (wmessage
);
1459 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1460 if (x_gtk_file_dialog_help_text
)
1461 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1462 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1464 if (default_filename
)
1467 struct gcpro gcpro1
;
1468 char *utf8_filename
;
1471 file
= build_string (default_filename
);
1473 /* File chooser does not understand ~/... in the file name. It must be
1474 an absolute name starting with /. */
1475 if (default_filename
[0] != '/')
1476 file
= Fexpand_file_name (file
, Qnil
);
1478 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1479 if (! NILP (Ffile_directory_p (file
)))
1480 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1484 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1486 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1488 char *cp
= strrchr (utf8_filename
, '/');
1490 else cp
= utf8_filename
;
1491 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1498 *func
= xg_get_file_name_from_chooser
;
1501 #endif /* HAVE_GTK_FILE_CHOOSER_DIALOG_NEW */
1503 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1505 /* Return the selected file for file selector dialog W.
1506 The returned string must be free:d. */
1509 xg_get_file_name_from_selector (w
)
1512 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1513 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1516 /* Create a file selection dialog.
1517 F is the current frame.
1518 PROMPT is a prompt to show to the user. May not be NULL.
1519 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1520 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1521 file. *FUNC is set to a function that can be used to retrieve the
1522 selected file name from the returned widget.
1524 Returns the created widget. */
1527 xg_get_file_with_selection (f
, prompt
, default_filename
,
1528 mustmatch_p
, only_dir_p
, func
)
1531 char *default_filename
;
1532 int mustmatch_p
, only_dir_p
;
1533 xg_get_file_func
*func
;
1536 GtkFileSelection
*filesel
;
1538 filewin
= gtk_file_selection_new (prompt
);
1539 filesel
= GTK_FILE_SELECTION (filewin
);
1541 if (default_filename
)
1542 gtk_file_selection_set_filename (filesel
, default_filename
);
1546 /* The selection_entry part of filesel is not documented. */
1547 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1548 gtk_file_selection_hide_fileop_buttons (filesel
);
1551 *func
= xg_get_file_name_from_selector
;
1555 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1557 /* Read a file name from the user using a file dialog, either the old
1558 file selection dialog, or the new file chooser dialog. Which to use
1559 depends on what the GTK version used has, and what the value of
1560 gtk-use-old-file-dialog.
1561 F is the current frame.
1562 PROMPT is a prompt to show to the user. May not be NULL.
1563 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1564 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1567 Returns a file name or NULL if no file was selected.
1568 The returned string must be freed by the caller. */
1571 xg_get_file_name (f
, prompt
, default_filename
, mustmatch_p
, only_dir_p
)
1574 char *default_filename
;
1575 int mustmatch_p
, only_dir_p
;
1579 int filesel_done
= 0;
1580 xg_get_file_func func
;
1582 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1583 /* I really don't know why this is needed, but without this the GLIBC add on
1584 library linuxthreads hangs when the Gnome file chooser backend creates
1586 sigblock (sigmask (__SIGRTMIN
));
1587 #endif /* HAVE_GTK_AND_PTHREAD */
1589 #ifdef HAVE_GTK_FILE_BOTH
1591 if (xg_uses_old_file_dialog ())
1592 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1593 mustmatch_p
, only_dir_p
, &func
);
1595 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1596 mustmatch_p
, only_dir_p
, &func
);
1598 #else /* not HAVE_GTK_FILE_BOTH */
1600 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1601 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1602 mustmatch_p
, only_dir_p
, &func
);
1604 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1605 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1606 mustmatch_p
, only_dir_p
, &func
);
1609 #endif /* HAVE_GTK_FILE_BOTH */
1611 gtk_widget_set_name (w
, "emacs-filedialog");
1613 filesel_done
= xg_dialog_run (f
, w
);
1615 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1616 sigunblock (sigmask (__SIGRTMIN
));
1619 if (filesel_done
== GTK_RESPONSE_OK
)
1622 gtk_widget_destroy (w
);
1626 #ifdef HAVE_FREETYPE
1627 /* Pop up a GTK font selector and return the name of the font the user
1628 selects, as a C string. The returned font name follows GTK's own
1631 `FAMILY [VALUE1 VALUE2] SIZE'
1633 This can be parsed using font_parse_fcname in font.c.
1634 DEFAULT_NAME, if non-zero, is the default font name. */
1637 xg_get_font_name (f
, default_name
)
1642 char *fontname
= NULL
;
1645 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1646 sigblock (sigmask (__SIGRTMIN
));
1647 #endif /* HAVE_GTK_AND_PTHREAD */
1649 w
= gtk_font_selection_dialog_new ("Pick a font");
1651 default_name
= "Monospace 10";
1652 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1655 gtk_widget_set_name (w
, "emacs-fontdialog");
1657 done
= xg_dialog_run (f
, w
);
1659 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1660 sigunblock (sigmask (__SIGRTMIN
));
1663 if (done
== GTK_RESPONSE_OK
)
1664 fontname
= gtk_font_selection_dialog_get_font_name
1665 (GTK_FONT_SELECTION_DIALOG (w
));
1667 gtk_widget_destroy (w
);
1670 #endif /* HAVE_FREETYPE */
1674 /***********************************************************************
1676 ***********************************************************************/
1678 /* The name of menu items that can be used for customization. Since GTK
1679 RC files are very crude and primitive, we have to set this on all
1680 menu item names so a user can easily customize menu items. */
1682 #define MENU_ITEM_NAME "emacs-menuitem"
1685 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1686 during GC. The next member points to the items. */
1687 static xg_list_node xg_menu_cb_list
;
1689 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1690 during GC. The next member points to the items. */
1691 static xg_list_node xg_menu_item_cb_list
;
1693 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1694 F is the frame CL_DATA will be initialized for.
1695 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1697 The menu bar and all sub menus under the menu bar in a frame
1698 share the same structure, hence the reference count.
1700 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1701 allocated xg_menu_cb_data if CL_DATA is NULL. */
1703 static xg_menu_cb_data
*
1704 make_cl_data (cl_data
, f
, highlight_cb
)
1705 xg_menu_cb_data
*cl_data
;
1707 GCallback highlight_cb
;
1711 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1713 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1714 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1715 cl_data
->highlight_cb
= highlight_cb
;
1716 cl_data
->ref_count
= 0;
1718 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1721 cl_data
->ref_count
++;
1726 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1727 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1729 When the menu bar is updated, menu items may have been added and/or
1730 removed, so menu_bar_vector and menu_bar_items_used change. We must
1731 then update CL_DATA since it is used to determine which menu
1732 item that is invoked in the menu.
1733 HIGHLIGHT_CB could change, there is no check that the same
1734 function is given when modifying a menu bar as was given when
1735 creating the menu bar. */
1738 update_cl_data (cl_data
, f
, highlight_cb
)
1739 xg_menu_cb_data
*cl_data
;
1741 GCallback highlight_cb
;
1746 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1747 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1748 cl_data
->highlight_cb
= highlight_cb
;
1752 /* Decrease reference count for CL_DATA.
1753 If reference count is zero, free CL_DATA. */
1756 unref_cl_data (cl_data
)
1757 xg_menu_cb_data
*cl_data
;
1759 if (cl_data
&& cl_data
->ref_count
> 0)
1761 cl_data
->ref_count
--;
1762 if (cl_data
->ref_count
== 0)
1764 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1770 /* Function that marks all lisp data during GC. */
1777 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1778 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1780 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1782 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1784 if (! NILP (cb_data
->help
))
1785 mark_object (cb_data
->help
);
1790 /* Callback called when a menu item is destroyed. Used to free data.
1791 W is the widget that is being destroyed (not used).
1792 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1795 menuitem_destroy_callback (w
, client_data
)
1797 gpointer client_data
;
1801 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1802 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1807 /* Callback called when the pointer enters/leaves a menu item.
1808 W is the parent of the menu item.
1809 EVENT is either an enter event or leave event.
1810 CLIENT_DATA is not used.
1812 Returns FALSE to tell GTK to keep processing this event. */
1815 menuitem_highlight_callback (w
, event
, client_data
)
1817 GdkEventCrossing
*event
;
1818 gpointer client_data
;
1821 GtkWidget
*subwidget
;
1822 xg_menu_item_cb_data
*data
;
1824 ev
.crossing
= *event
;
1825 subwidget
= gtk_get_event_widget (&ev
);
1826 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
1830 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1832 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
1833 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1834 (*func
) (subwidget
, call_data
);
1841 /* Callback called when a menu is destroyed. Used to free data.
1842 W is the widget that is being destroyed (not used).
1843 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1846 menu_destroy_callback (w
, client_data
)
1848 gpointer client_data
;
1850 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1853 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1854 must be non-NULL) and can be inserted into a menu item.
1856 Returns the GtkHBox. */
1859 make_widget_for_menu_item (utf8_label
, utf8_key
)
1867 wbox
= gtk_hbox_new (FALSE
, 0);
1868 wlbl
= gtk_label_new (utf8_label
);
1869 wkey
= gtk_label_new (utf8_key
);
1871 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1872 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1874 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1875 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1877 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1878 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1879 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1884 /* Make and return a menu item widget with the key to the right.
1885 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1886 UTF8_KEY is the text representing the key binding.
1887 ITEM is the widget_value describing the menu item.
1889 GROUP is an in/out parameter. If the menu item to be created is not
1890 part of any radio menu group, *GROUP contains NULL on entry and exit.
1891 If the menu item to be created is part of a radio menu group, on entry
1892 *GROUP contains the group to use, or NULL if this is the first item
1893 in the group. On exit, *GROUP contains the radio item group.
1895 Unfortunately, keys don't line up as nicely as in Motif,
1896 but the MacOS X version doesn't either, so I guess that is OK. */
1899 make_menu_item (utf8_label
, utf8_key
, item
, group
)
1906 GtkWidget
*wtoadd
= 0;
1908 /* It has been observed that some menu items have a NULL name field.
1909 This will lead to this function being called with a NULL utf8_label.
1910 GTK crashes on that so we set a blank label. Why there is a NULL
1911 name remains to be investigated. */
1912 if (! utf8_label
) utf8_label
= " ";
1915 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1917 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1920 if (utf8_key
) w
= gtk_check_menu_item_new ();
1921 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1922 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1924 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1926 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1927 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1928 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1930 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1935 if (utf8_key
) w
= gtk_menu_item_new ();
1936 else w
= gtk_menu_item_new_with_label (utf8_label
);
1939 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1940 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1945 /* Return non-zero if LABEL specifies a separator (GTK only has one
1948 static const char* separator_names
[] = {
1953 "single-dashed-line",
1954 "double-dashed-line",
1956 "shadow-etched-out",
1957 "shadow-etched-in-dash",
1958 "shadow-etched-out-dash",
1959 "shadow-double-etched-in",
1960 "shadow-double-etched-out",
1961 "shadow-double-etched-in-dash",
1962 "shadow-double-etched-out-dash",
1967 xg_separator_p (char *label
)
1969 if (! label
) return 0;
1970 else if (strlen (label
) > 3
1971 && strncmp (label
, "--", 2) == 0
1977 for (i
= 0; separator_names
[i
]; ++i
)
1978 if (strcmp (label
, separator_names
[i
]) == 0)
1983 /* Old-style separator, maybe. It's a separator if it contains
1985 while (*label
== '-')
1987 if (*label
== 0) return 1;
1993 static int xg_detached_menus
;
1995 /* Returns non-zero if there are detached menus. */
1998 xg_have_tear_offs ()
2000 return xg_detached_menus
> 0;
2003 /* Callback invoked when a detached menu window is removed. Here we
2004 decrease the xg_detached_menus count.
2005 WIDGET is the top level window that is removed (the parent of the menu).
2006 CLIENT_DATA is not used. */
2009 tearoff_remove (widget
, client_data
)
2011 gpointer client_data
;
2013 if (xg_detached_menus
> 0) --xg_detached_menus
;
2016 /* Callback invoked when a menu is detached. It increases the
2017 xg_detached_menus count.
2018 WIDGET is the GtkTearoffMenuItem.
2019 CLIENT_DATA is not used. */
2022 tearoff_activate (widget
, client_data
)
2024 gpointer client_data
;
2026 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2027 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2029 ++xg_detached_menus
;
2030 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2032 G_CALLBACK (tearoff_remove
), 0);
2037 /* Create a menu item widget, and connect the callbacks.
2038 ITEM decribes the menu item.
2039 F is the frame the created menu belongs to.
2040 SELECT_CB is the callback to use when a menu item is selected.
2041 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2042 CL_DATA points to the callback data to be used for this menu.
2043 GROUP is an in/out parameter. If the menu item to be created is not
2044 part of any radio menu group, *GROUP contains NULL on entry and exit.
2045 If the menu item to be created is part of a radio menu group, on entry
2046 *GROUP contains the group to use, or NULL if this is the first item
2047 in the group. On exit, *GROUP contains the radio item group.
2049 Returns the created GtkWidget. */
2052 xg_create_one_menuitem (item
, f
, select_cb
, highlight_cb
, cl_data
, group
)
2055 GCallback select_cb
;
2056 GCallback highlight_cb
;
2057 xg_menu_cb_data
*cl_data
;
2063 xg_menu_item_cb_data
*cb_data
;
2065 utf8_label
= get_utf8_string (item
->name
);
2066 utf8_key
= get_utf8_string (item
->key
);
2068 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2070 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2071 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
2073 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2075 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2077 cb_data
->select_id
= 0;
2078 cb_data
->help
= item
->help
;
2079 cb_data
->cl_data
= cl_data
;
2080 cb_data
->call_data
= item
->call_data
;
2082 g_signal_connect (G_OBJECT (w
),
2084 G_CALLBACK (menuitem_destroy_callback
),
2087 /* Put cb_data in widget, so we can get at it when modifying menubar */
2088 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2090 /* final item, not a submenu */
2091 if (item
->call_data
&& ! item
->contents
)
2095 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2101 static GtkWidget
*create_menus
P_ ((widget_value
*, FRAME_PTR
, GCallback
,
2102 GCallback
, GCallback
, int, int, int,
2103 GtkWidget
*, xg_menu_cb_data
*, char *));
2105 /* Create a full menu tree specified by DATA.
2106 F is the frame the created menu belongs to.
2107 SELECT_CB is the callback to use when a menu item is selected.
2108 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2109 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2110 POP_UP_P is non-zero if we shall create a popup menu.
2111 MENU_BAR_P is non-zero if we shall create a menu bar.
2112 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2113 if MENU_BAR_P is non-zero.
2114 TOPMENU is the topmost GtkWidget that others shall be placed under.
2115 It may be NULL, in that case we create the appropriate widget
2116 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2117 CL_DATA is the callback data we shall use for this menu, or NULL
2118 if we haven't set the first callback yet.
2119 NAME is the name to give to the top level menu if this function
2120 creates it. May be NULL to not set any name.
2122 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2125 This function calls itself to create submenus. */
2128 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2129 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
2132 GCallback select_cb
;
2133 GCallback deactivate_cb
;
2134 GCallback highlight_cb
;
2139 xg_menu_cb_data
*cl_data
;
2143 GtkWidget
*wmenu
= topmenu
;
2144 GSList
*group
= NULL
;
2150 wmenu
= gtk_menu_new ();
2151 xg_set_screen (wmenu
, f
);
2152 /* Connect this to the menu instead of items so we get enter/leave for
2153 disabled items also. TODO: Still does not get enter/leave for
2154 disabled items in detached menus. */
2155 g_signal_connect (G_OBJECT (wmenu
),
2156 "enter-notify-event",
2157 G_CALLBACK (menuitem_highlight_callback
),
2159 g_signal_connect (G_OBJECT (wmenu
),
2160 "leave-notify-event",
2161 G_CALLBACK (menuitem_highlight_callback
),
2166 wmenu
= gtk_menu_bar_new ();
2167 /* Set width of menu bar to a small value so it doesn't enlarge
2168 a small initial frame size. The width will be set to the
2169 width of the frame later on when it is added to a container.
2170 height -1: Natural height. */
2171 gtk_widget_set_size_request (wmenu
, 1, -1);
2174 /* Put cl_data on the top menu for easier access. */
2175 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2176 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2177 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2178 G_CALLBACK (menu_destroy_callback
), cl_data
);
2181 gtk_widget_set_name (wmenu
, name
);
2184 g_signal_connect (G_OBJECT (wmenu
),
2185 "selection-done", deactivate_cb
, 0);
2188 if (! menu_bar_p
&& add_tearoff_p
)
2190 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2191 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2193 g_signal_connect (G_OBJECT (tearoff
), "activate",
2194 G_CALLBACK (tearoff_activate
), 0);
2197 for (item
= data
; item
; item
= item
->next
)
2201 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2202 && !xg_separator_p (item
->name
))
2205 /* A title for a popup. We do the same as GTK does when
2206 creating titles, but it does not look good. */
2208 utf8_label
= get_utf8_string (item
->name
);
2210 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2211 w
= gtk_menu_item_new_with_label (utf8_label
);
2212 gtk_widget_set_sensitive (w
, FALSE
);
2213 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2215 else if (xg_separator_p (item
->name
))
2218 /* GTK only have one separator type. */
2219 w
= gtk_separator_menu_item_new ();
2223 w
= xg_create_one_menuitem (item
,
2225 item
->contents
? 0 : select_cb
,
2230 /* Create a possibly empty submenu for menu bar items, since some
2231 themes don't highlight items correctly without it. */
2232 if (item
->contents
|| menu_bar_p
)
2234 GtkWidget
*submenu
= create_menus (item
->contents
,
2245 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2249 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2250 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2256 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2257 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2258 with some text and buttons.
2259 F is the frame the created item belongs to.
2260 NAME is the name to use for the top widget.
2261 VAL is a widget_value structure describing items to be created.
2262 SELECT_CB is the callback to use when a menu item is selected or
2263 a dialog button is pressed.
2264 DEACTIVATE_CB is the callback to use when an item is deactivated.
2265 For a menu, when a sub menu is not shown anymore, for a dialog it is
2266 called when the dialog is popped down.
2267 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2269 Returns the widget created. */
2272 xg_create_widget (type
, name
, f
, val
,
2273 select_cb
, deactivate_cb
, highlight_cb
)
2278 GCallback select_cb
;
2279 GCallback deactivate_cb
;
2280 GCallback highlight_cb
;
2283 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2284 int pop_up_p
= strcmp (type
, "popup") == 0;
2286 if (strcmp (type
, "dialog") == 0)
2288 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2289 xg_set_screen (w
, f
);
2290 gtk_window_set_transient_for (GTK_WINDOW (w
),
2291 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2292 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2293 gtk_widget_set_name (w
, "emacs-dialog");
2294 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2296 else if (menu_bar_p
|| pop_up_p
)
2298 w
= create_menus (val
->contents
,
2310 /* Set the cursor to an arrow for popup menus when they are mapped.
2311 This is done by default for menu bar menus. */
2314 /* Must realize so the GdkWindow inside the widget is created. */
2315 gtk_widget_realize (w
);
2316 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2321 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2328 /* Return the label for menu item WITEM. */
2331 xg_get_menu_item_label (witem
)
2334 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2335 return gtk_label_get_label (wlabel
);
2338 /* Return non-zero if the menu item WITEM has the text LABEL. */
2341 xg_item_label_same_p (witem
, label
)
2346 char *utf8_label
= get_utf8_string (label
);
2347 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2349 if (! old_label
&& ! utf8_label
)
2351 else if (old_label
&& utf8_label
)
2352 is_same
= strcmp (utf8_label
, old_label
) == 0;
2354 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2359 /* Destroy widgets in LIST. */
2362 xg_destroy_widgets (list
)
2367 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2369 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2371 /* Destroying the widget will remove it from the container it is in. */
2372 gtk_widget_destroy (w
);
2376 /* Update the top level names in MENUBAR (i.e. not submenus).
2377 F is the frame the menu bar belongs to.
2378 *LIST is a list with the current menu bar names (menu item widgets).
2379 ITER is the item within *LIST that shall be updated.
2380 POS is the numerical position, starting at 0, of ITER in *LIST.
2381 VAL describes what the menu bar shall look like after the update.
2382 SELECT_CB is the callback to use when a menu item is selected.
2383 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2384 CL_DATA points to the callback data to be used for this menu bar.
2386 This function calls itself to walk through the menu bar names. */
2389 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2390 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2397 GCallback select_cb
;
2398 GCallback deactivate_cb
;
2399 GCallback highlight_cb
;
2400 xg_menu_cb_data
*cl_data
;
2402 if (! iter
&& ! val
)
2404 else if (iter
&& ! val
)
2406 /* Item(s) have been removed. Remove all remaining items. */
2407 xg_destroy_widgets (iter
);
2409 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2410 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2411 gtk_menu_item_new_with_label (""),
2417 else if (! iter
&& val
)
2419 /* Item(s) added. Add all new items in one call. */
2420 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2421 0, 1, 0, menubar
, cl_data
, 0);
2427 /* Below this neither iter or val is NULL */
2428 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2430 /* This item is still the same, check next item. */
2432 iter
= g_list_next (iter
);
2435 else /* This item is changed. */
2437 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2438 GtkMenuItem
*witem2
= 0;
2439 int val_in_menubar
= 0;
2440 int iter_in_new_menubar
= 0;
2444 /* See if the changed entry (val) is present later in the menu bar */
2446 iter2
&& ! val_in_menubar
;
2447 iter2
= g_list_next (iter2
))
2449 witem2
= GTK_MENU_ITEM (iter2
->data
);
2450 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2453 /* See if the current entry (iter) is present later in the
2454 specification for the new menu bar. */
2455 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2456 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2458 if (val_in_menubar
&& ! iter_in_new_menubar
)
2462 /* This corresponds to:
2467 gtk_widget_ref (GTK_WIDGET (witem
));
2468 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2469 gtk_widget_destroy (GTK_WIDGET (witem
));
2471 /* Must get new list since the old changed. */
2472 g_list_free (*list
);
2473 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2474 while (nr
-- > 0) iter
= g_list_next (iter
);
2476 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2478 /* This corresponds to:
2481 Rename B to X. This might seem to be a strange thing to do,
2482 since if there is a menu under B it will be totally wrong for X.
2483 But consider editing a C file. Then there is a C-mode menu
2484 (corresponds to B above).
2485 If then doing C-x C-f the minibuf menu (X above) replaces the
2486 C-mode menu. When returning from the minibuffer, we get
2487 back the C-mode menu. Thus we do:
2488 Rename B to X (C-mode to minibuf menu)
2489 Rename X to B (minibuf to C-mode menu).
2490 If the X menu hasn't been invoked, the menu under B
2491 is up to date when leaving the minibuffer. */
2492 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2493 char *utf8_label
= get_utf8_string (val
->name
);
2494 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2496 gtk_label_set_text (wlabel
, utf8_label
);
2498 /* If this item has a submenu that has been detached, change
2499 the title in the WM decorations also. */
2500 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2501 /* Set the title of the detached window. */
2502 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2504 iter
= g_list_next (iter
);
2508 else if (! val_in_menubar
&& iter_in_new_menubar
)
2510 /* This corresponds to:
2517 GtkWidget
*w
= xg_create_one_menuitem (val
,
2524 /* Create a possibly empty submenu for menu bar items, since some
2525 themes don't highlight items correctly without it. */
2526 GtkWidget
*submenu
= create_menus (NULL
, f
,
2527 select_cb
, deactivate_cb
,
2529 0, 0, 0, 0, cl_data
, 0);
2530 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2531 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2532 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2534 g_list_free (*list
);
2535 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2536 while (nr
-- > 0) iter
= g_list_next (iter
);
2537 iter
= g_list_next (iter
);
2541 else /* if (val_in_menubar && iter_in_new_menubar) */
2544 /* This corresponds to:
2549 gtk_widget_ref (GTK_WIDGET (witem2
));
2550 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2551 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2552 GTK_WIDGET (witem2
), pos
);
2553 gtk_widget_unref (GTK_WIDGET (witem2
));
2555 g_list_free (*list
);
2556 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2557 while (nr
-- > 0) iter
= g_list_next (iter
);
2558 if (iter
) iter
= g_list_next (iter
);
2564 /* Update the rest of the menu bar. */
2565 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2566 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2569 /* Update the menu item W so it corresponds to VAL.
2570 SELECT_CB is the callback to use when a menu item is selected.
2571 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2572 CL_DATA is the data to set in the widget for menu invocation. */
2575 xg_update_menu_item (val
, w
, select_cb
, highlight_cb
, cl_data
)
2578 GCallback select_cb
;
2579 GCallback highlight_cb
;
2580 xg_menu_cb_data
*cl_data
;
2587 const char *old_label
= 0;
2588 const char *old_key
= 0;
2589 xg_menu_item_cb_data
*cb_data
;
2591 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2592 utf8_label
= get_utf8_string (val
->name
);
2593 utf8_key
= get_utf8_string (val
->key
);
2595 /* See if W is a menu item with a key. See make_menu_item above. */
2596 if (GTK_IS_HBOX (wchild
))
2598 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2600 wlbl
= GTK_LABEL (list
->data
);
2601 wkey
= GTK_LABEL (list
->next
->data
);
2606 /* Remove the key and keep just the label. */
2607 gtk_widget_ref (GTK_WIDGET (wlbl
));
2608 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2609 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2614 else /* Just a label. */
2616 wlbl
= GTK_LABEL (wchild
);
2618 /* Check if there is now a key. */
2621 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2622 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2624 wlbl
= GTK_LABEL (list
->data
);
2625 wkey
= GTK_LABEL (list
->next
->data
);
2628 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2629 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2634 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2635 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2637 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2638 gtk_label_set_text (wkey
, utf8_key
);
2640 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2641 gtk_label_set_text (wlbl
, utf8_label
);
2643 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2644 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2646 if (! val
->enabled
&& GTK_WIDGET_SENSITIVE (w
))
2647 gtk_widget_set_sensitive (w
, FALSE
);
2648 else if (val
->enabled
&& ! GTK_WIDGET_SENSITIVE (w
))
2649 gtk_widget_set_sensitive (w
, TRUE
);
2651 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2655 cb_data
->call_data
= val
->call_data
;
2656 cb_data
->help
= val
->help
;
2657 cb_data
->cl_data
= cl_data
;
2659 /* We assume the callback functions don't change. */
2660 if (val
->call_data
&& ! val
->contents
)
2662 /* This item shall have a select callback. */
2663 if (! cb_data
->select_id
)
2665 = g_signal_connect (G_OBJECT (w
), "activate",
2666 select_cb
, cb_data
);
2668 else if (cb_data
->select_id
)
2670 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2671 cb_data
->select_id
= 0;
2676 /* Update the toggle menu item W so it corresponds to VAL. */
2679 xg_update_toggle_item (val
, w
)
2683 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2686 /* Update the radio menu item W so it corresponds to VAL. */
2689 xg_update_radio_item (val
, w
)
2693 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2696 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2697 SUBMENU may be NULL, in that case a new menu is created.
2698 F is the frame the menu bar belongs to.
2699 VAL describes the contents of the menu bar.
2700 SELECT_CB is the callback to use when a menu item is selected.
2701 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2702 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2703 CL_DATA is the call back data to use for any newly created items.
2705 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2709 xg_update_submenu (submenu
, f
, val
,
2710 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2714 GCallback select_cb
;
2715 GCallback deactivate_cb
;
2716 GCallback highlight_cb
;
2717 xg_menu_cb_data
*cl_data
;
2719 GtkWidget
*newsub
= submenu
;
2723 int has_tearoff_p
= 0;
2724 GList
*first_radio
= 0;
2727 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2729 for (cur
= val
, iter
= list
;
2731 iter
= g_list_next (iter
), cur
= cur
->next
)
2733 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2735 /* Skip tearoff items, they have no counterpart in val. */
2736 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2739 iter
= g_list_next (iter
);
2740 if (iter
) w
= GTK_WIDGET (iter
->data
);
2744 /* Remember first radio button in a group. If we get a mismatch in
2745 a radio group we must rebuild the whole group so that the connections
2746 in GTK becomes correct. */
2747 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2749 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2750 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2753 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2755 if (! xg_separator_p (cur
->name
))
2758 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2760 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2762 xg_update_toggle_item (cur
, w
);
2763 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2765 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2767 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2769 xg_update_radio_item (cur
, w
);
2770 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2772 else if (GTK_IS_MENU_ITEM (w
))
2774 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2777 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2778 xg_separator_p (cur
->name
))
2781 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2783 sub
= gtk_menu_item_get_submenu (witem
);
2784 if (sub
&& ! cur
->contents
)
2786 /* Not a submenu anymore. */
2787 gtk_widget_ref (sub
);
2788 gtk_menu_item_remove_submenu (witem
);
2789 gtk_widget_destroy (sub
);
2791 else if (cur
->contents
)
2795 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2796 select_cb
, deactivate_cb
,
2797 highlight_cb
, cl_data
);
2799 /* If this item just became a submenu, we must set it. */
2801 gtk_menu_item_set_submenu (witem
, nsub
);
2806 /* Structural difference. Remove everything from here and down
2812 /* Remove widgets from first structual change. */
2815 /* If we are adding new menu items below, we must remove from
2816 first radio button so that radio groups become correct. */
2817 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2818 else xg_destroy_widgets (iter
);
2823 /* More items added. Create them. */
2824 newsub
= create_menus (cur
,
2837 if (list
) g_list_free (list
);
2842 /* Update the MENUBAR.
2843 F is the frame the menu bar belongs to.
2844 VAL describes the contents of the menu bar.
2845 If DEEP_P is non-zero, rebuild all but the top level menu names in
2846 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2847 SELECT_CB is the callback to use when a menu item is selected.
2848 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2849 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2852 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2853 select_cb
, deactivate_cb
, highlight_cb
)
2858 GCallback select_cb
;
2859 GCallback deactivate_cb
;
2860 GCallback highlight_cb
;
2862 xg_menu_cb_data
*cl_data
;
2863 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2867 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2870 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2871 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2877 /* Update all sub menus.
2878 We must keep the submenus (GTK menu item widgets) since the
2879 X Window in the XEvent that activates the menu are those widgets. */
2881 /* Update cl_data, menu_item things in F may have changed. */
2882 update_cl_data (cl_data
, f
, highlight_cb
);
2884 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2891 /* Find sub menu that corresponds to val and update it. */
2892 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2894 witem
= GTK_MENU_ITEM (iter
->data
);
2895 if (xg_item_label_same_p (witem
, cur
->name
))
2897 sub
= gtk_menu_item_get_submenu (witem
);
2902 newsub
= xg_update_submenu (sub
,
2909 /* sub may still be NULL. If we just updated non deep and added
2910 a new menu bar item, it has no sub menu yet. So we set the
2911 newly created sub menu under witem. */
2914 xg_set_screen (newsub
, f
);
2915 gtk_menu_item_set_submenu (witem
, newsub
);
2921 gtk_widget_show_all (menubar
);
2924 /* Recompute all the widgets of frame F, when the menu bar has been
2925 changed. Value is non-zero if widgets were updated. */
2928 xg_update_frame_menubar (f
)
2931 struct x_output
*x
= f
->output_data
.x
;
2934 if (!x
->menubar_widget
|| GTK_WIDGET_MAPPED (x
->menubar_widget
))
2937 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
2938 return 0; /* Already done this, happens for frames created invisible. */
2942 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2944 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2946 gtk_widget_show_all (x
->menubar_widget
);
2947 gtk_widget_size_request (x
->menubar_widget
, &req
);
2948 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2949 xg_height_changed (f
);
2955 /* Get rid of the menu bar of frame F, and free its storage.
2956 This is used when deleting a frame, and when turning off the menu bar. */
2959 free_frame_menubar (f
)
2962 struct x_output
*x
= f
->output_data
.x
;
2964 if (x
->menubar_widget
)
2968 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2969 /* The menubar and its children shall be deleted when removed from
2971 x
->menubar_widget
= 0;
2972 FRAME_MENUBAR_HEIGHT (f
) = 0;
2973 xg_height_changed (f
);
2980 /***********************************************************************
2981 Scroll bar functions
2982 ***********************************************************************/
2985 /* Setting scroll bar values invokes the callback. Use this variable
2986 to indicate that callback should do nothing. */
2988 int xg_ignore_gtk_scrollbar
;
2990 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
2991 may be larger than 32 bits. Keep a mapping from integer index to widget
2992 pointers to get around the 32 bit limitation. */
2996 GtkWidget
**widgets
;
3001 /* Grow this much every time we need to allocate more */
3003 #define ID_TO_WIDGET_INCR 32
3005 /* Store the widget pointer W in id_to_widget and return the integer index. */
3008 xg_store_widget_in_map (w
)
3013 if (id_to_widget
.max_size
== id_to_widget
.used
)
3015 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3017 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
3018 sizeof (GtkWidget
*)*new_size
);
3020 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3021 id_to_widget
.widgets
[i
] = 0;
3022 id_to_widget
.max_size
= new_size
;
3025 /* Just loop over the array and find a free place. After all,
3026 how many scroll bars are we creating? Should be a small number.
3027 The check above guarantees we will find a free place. */
3028 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3030 if (! id_to_widget
.widgets
[i
])
3032 id_to_widget
.widgets
[i
] = w
;
3033 ++id_to_widget
.used
;
3039 /* Should never end up here */
3043 /* Remove pointer at IDX from id_to_widget.
3044 Called when scroll bar is destroyed. */
3047 xg_remove_widget_from_map (idx
)
3050 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3052 id_to_widget
.widgets
[idx
] = 0;
3053 --id_to_widget
.used
;
3057 /* Get the widget pointer at IDX from id_to_widget. */
3060 xg_get_widget_from_map (idx
)
3063 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3064 return id_to_widget
.widgets
[idx
];
3069 /* Return the scrollbar id for X Window WID on display DPY.
3070 Return -1 if WID not in id_to_widget. */
3073 xg_get_scroll_id_for_window (dpy
, wid
)
3080 w
= xg_win_to_widget (dpy
, wid
);
3084 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3085 if (id_to_widget
.widgets
[idx
] == w
)
3092 /* Callback invoked when scroll bar WIDGET is destroyed.
3093 DATA is the index into id_to_widget for WIDGET.
3094 We free pointer to last scroll bar values here and remove the index. */
3097 xg_gtk_scroll_destroy (widget
, data
)
3101 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
3102 xg_remove_widget_from_map (id
);
3105 /* Create a scroll bar widget for frame F. Store the scroll bar
3107 SCROLL_CALLBACK is the callback to invoke when the value of the
3109 END_CALLBACK is the callback to invoke when scrolling ends.
3110 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3111 to set resources for the widget. */
3114 xg_create_scroll_bar (f
, bar
, scroll_callback
, end_callback
, scroll_bar_name
)
3116 struct scroll_bar
*bar
;
3117 GCallback scroll_callback
, end_callback
;
3118 char *scroll_bar_name
;
3125 /* Page, step increment values are not so important here, they
3126 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3127 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3130 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3131 webox
= gtk_event_box_new ();
3132 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3133 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3134 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3136 scroll_id
= xg_store_widget_in_map (wscroll
);
3138 /* The EMACS_INT cast avoids a warning. */
3139 g_signal_connect (G_OBJECT (wscroll
),
3141 G_CALLBACK (xg_gtk_scroll_destroy
),
3142 (gpointer
) (EMACS_INT
) scroll_id
);
3143 g_signal_connect (G_OBJECT (wscroll
),
3147 g_signal_connect (G_OBJECT (wscroll
),
3148 "button-release-event",
3152 /* The scroll bar widget does not draw on a window of its own. Instead
3153 it draws on the parent window, in this case the edit widget. So
3154 whenever the edit widget is cleared, the scroll bar needs to redraw
3155 also, which causes flicker. Put an event box between the edit widget
3156 and the scroll bar, so the scroll bar instead draws itself on the
3157 event box window. */
3158 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3159 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3162 /* Set the cursor to an arrow. */
3163 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3165 bar
->x_window
= scroll_id
;
3168 /* Make the scroll bar represented by SCROLLBAR_ID visible. */
3171 xg_show_scroll_bar (scrollbar_id
)
3174 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3176 gtk_widget_show_all (gtk_widget_get_parent (w
));
3179 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3182 xg_remove_scroll_bar (f
, scrollbar_id
)
3186 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3189 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3190 gtk_widget_destroy (w
);
3191 gtk_widget_destroy (wparent
);
3192 SET_FRAME_GARBAGED (f
);
3196 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3198 TOP/LEFT are the new pixel positions where the bar shall appear.
3199 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3202 xg_update_scrollbar_pos (f
, scrollbar_id
, top
, left
, width
, height
)
3211 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3215 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3216 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3217 GtkFixed
*wf
= GTK_FIXED (wfixed
);
3219 /* Clear out old position. */
3221 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3222 for (iter
= wf
->children
; iter
; iter
= iter
->next
)
3223 if (((GtkFixedChild
*)iter
->data
)->widget
== wparent
)
3225 GtkFixedChild
*ch
= (GtkFixedChild
*)iter
->data
;
3226 if (ch
->x
!= left
|| ch
->y
!= top
)
3230 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3235 /* Move and resize to new values. */
3236 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3237 gtk_widget_set_size_request (wscroll
, width
, height
);
3238 gtk_widget_queue_draw (wfixed
);
3239 gdk_window_process_all_updates ();
3242 /* Clear under old scroll bar position. This must be done after
3243 the gtk_widget_queue_draw and gdk_window_process_all_updates
3245 x_clear_area (FRAME_X_DISPLAY (f
),
3247 oldx
, oldy
, oldw
, oldh
, 0);
3250 /* GTK does not redraw until the main loop is entered again, but
3251 if there are no X events pending we will not enter it. So we sync
3252 here to get some events. */
3255 SET_FRAME_GARBAGED (f
);
3256 cancel_mouse_face (f
);
3260 /* Set the thumb size and position of scroll bar BAR. We are currently
3261 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3264 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
3265 struct scroll_bar
*bar
;
3266 int portion
, position
, whole
;
3268 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3270 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3272 if (wscroll
&& NILP (bar
->dragging
))
3281 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3283 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3284 rather than the real portion value. This makes the thumb less likely
3285 to resize and that looks better. */
3286 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3287 /* When the thumb is at the bottom, position == whole.
3288 So we need to increase `whole' to make space for the thumb. */
3295 top
= (gdouble
) position
/ whole
;
3296 shown
= (gdouble
) portion
/ whole
;
3299 size
= shown
* XG_SB_RANGE
;
3300 size
= min (size
, XG_SB_RANGE
);
3301 size
= max (size
, 1);
3303 value
= top
* XG_SB_RANGE
;
3304 value
= min (value
, XG_SB_MAX
- size
);
3305 value
= max (value
, XG_SB_MIN
);
3307 /* Assume all lines are of equal size. */
3308 new_step
= size
/ max (1, FRAME_LINES (f
));
3310 if ((int) adj
->page_size
!= size
3311 || (int) adj
->step_increment
!= new_step
)
3313 adj
->page_size
= size
;
3314 adj
->step_increment
= new_step
;
3315 /* Assume a page increment is about 95% of the page size */
3316 adj
->page_increment
= (int) (0.95*adj
->page_size
);
3320 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3324 /* gtk_range_set_value invokes the callback. Set
3325 ignore_gtk_scrollbar to make the callback do nothing */
3326 xg_ignore_gtk_scrollbar
= 1;
3328 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3329 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3331 gtk_adjustment_changed (adj
);
3333 xg_ignore_gtk_scrollbar
= 0;
3340 /* Return non-zero if EVENT is for a scroll bar in frame F.
3341 When the same X window is used for several Gtk+ widgets, we cannot
3342 say for sure based on the X window alone if an event is for the
3343 frame. This function does additional checks.
3345 Return non-zero if the event is for a scroll bar, zero otherwise. */
3348 xg_event_is_for_scrollbar (f
, event
)
3354 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3356 /* Check if press occurred outside the edit widget. */
3357 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3358 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3359 != f
->output_data
.x
->edit_widget
->window
;
3362 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3363 || event
->type
== MotionNotify
))
3365 /* If we are releasing or moving the scroll bar, it has the grab. */
3366 retval
= gtk_grab_get_current () != 0
3367 && gtk_grab_get_current () != f
->output_data
.x
->edit_widget
;
3375 /***********************************************************************
3377 ***********************************************************************/
3378 /* The key for the data we put in the GtkImage widgets. The data is
3379 the image used by Emacs. We use this to see if we need to update
3380 the GtkImage with a new image. */
3381 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3383 /* The key for storing the latest modifiers so the activate callback can
3385 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3387 /* The key for storing the button widget in its proxy menu item. */
3388 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3390 /* The key for the data we put in the GtkImage widgets. The data is
3391 the stock name used by Emacs. We use this to see if we need to update
3392 the GtkImage with a new image. */
3393 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3395 /* As above, but this is used for named theme widgets, as opposed to
3397 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3399 /* Callback function invoked when a tool bar item is pressed.
3400 W is the button widget in the tool bar that got pressed,
3401 CLIENT_DATA is an integer that is the index of the button in the
3402 tool bar. 0 is the first button. */
3405 xg_tool_bar_button_cb (widget
, event
, user_data
)
3407 GdkEventButton
*event
;
3410 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3411 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3412 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3417 /* Callback function invoked when a tool bar item is pressed.
3418 W is the button widget in the tool bar that got pressed,
3419 CLIENT_DATA is an integer that is the index of the button in the
3420 tool bar. 0 is the first button. */
3423 xg_tool_bar_callback (w
, client_data
)
3425 gpointer client_data
;
3427 /* The EMACS_INT cast avoids a warning. */
3428 int idx
= (int) (EMACS_INT
) client_data
;
3429 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3430 XG_TOOL_BAR_LAST_MODIFIER
);
3432 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3433 Lisp_Object key
, frame
;
3434 struct input_event event
;
3437 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3440 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3442 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3443 XSETFRAME (frame
, f
);
3445 /* We generate two events here. The first one is to set the prefix
3446 to `(tool_bar)', see keyboard.c. */
3447 event
.kind
= TOOL_BAR_EVENT
;
3448 event
.frame_or_window
= frame
;
3450 kbd_buffer_store_event (&event
);
3452 event
.kind
= TOOL_BAR_EVENT
;
3453 event
.frame_or_window
= frame
;
3455 /* Convert between the modifier bits GDK uses and the modifier bits
3456 Emacs uses. This assumes GDK and X masks are the same, which they are when
3458 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3459 kbd_buffer_store_event (&event
);
3461 /* Return focus to the frame after we have clicked on a detached
3463 Fx_focus_frame (frame
);
3466 /* Callback function invoked when a tool bar item is pressed in a detached
3467 tool bar or the overflow drop down menu.
3468 We just call xg_tool_bar_callback.
3469 W is the menu item widget that got pressed,
3470 CLIENT_DATA is an integer that is the index of the button in the
3471 tool bar. 0 is the first button. */
3474 xg_tool_bar_proxy_callback (w
, client_data
)
3476 gpointer client_data
;
3478 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3479 XG_TOOL_BAR_PROXY_BUTTON
));
3480 xg_tool_bar_callback (wbutton
, client_data
);
3485 xg_tool_bar_help_callback
P_ ((GtkWidget
*w
,
3486 GdkEventCrossing
*event
,
3487 gpointer client_data
));
3489 /* This callback is called when a help is to be shown for an item in
3490 the detached tool bar when the detached tool bar it is not expanded. */
3493 xg_tool_bar_proxy_help_callback (w
, event
, client_data
)
3495 GdkEventCrossing
*event
;
3496 gpointer client_data
;
3498 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3499 XG_TOOL_BAR_PROXY_BUTTON
));
3501 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3505 /* This callback is called when a tool item should create a proxy item,
3506 such as for the overflow menu. Also called when the tool bar is detached.
3507 If we don't create a proxy menu item, the detached tool bar will be
3511 xg_tool_bar_menu_proxy (toolitem
, user_data
)
3512 GtkToolItem
*toolitem
;
3515 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (toolitem
));
3516 GtkButton
*wbutton
= GTK_BUTTON (gtk_bin_get_child (GTK_BIN (weventbox
)));
3517 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label ("");
3518 GtkWidget
*wmenuimage
;
3520 if (gtk_button_get_use_stock (wbutton
))
3521 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3522 GTK_ICON_SIZE_MENU
);
3525 GtkImage
*wimage
= GTK_IMAGE (gtk_bin_get_child (GTK_BIN (wbutton
)));
3526 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3527 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3529 if (store_type
== GTK_IMAGE_STOCK
)
3532 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3533 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3535 else if (store_type
== GTK_IMAGE_ICON_SET
)
3537 GtkIconSet
*icon_set
;
3538 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3539 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3540 GTK_ICON_SIZE_MENU
);
3542 else if (store_type
== GTK_IMAGE_PIXBUF
)
3547 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3550 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3552 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3553 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3554 GDK_INTERP_BILINEAR
);
3556 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3560 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3564 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3566 const gchar
*icon_name
;
3567 GtkIconSize icon_size
;
3569 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3570 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3571 GTK_ICON_SIZE_MENU
);
3575 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3580 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3582 g_signal_connect (G_OBJECT (wmenuitem
),
3584 G_CALLBACK (xg_tool_bar_proxy_callback
),
3588 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3589 (gpointer
) wbutton
);
3590 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3591 gtk_widget_set_sensitive (wmenuitem
, GTK_WIDGET_SENSITIVE (wbutton
));
3593 /* Use enter/leave notify to show help. We use the events
3594 rather than the GtkButton specific signals "enter" and
3595 "leave", so we can have only one callback. The event
3596 will tell us what kind of event it is. */
3597 g_signal_connect (G_OBJECT (wmenuitem
),
3598 "enter-notify-event",
3599 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3601 g_signal_connect (G_OBJECT (wmenuitem
),
3602 "leave-notify-event",
3603 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3609 /* This callback is called when a tool bar is detached. We must set
3610 the height of the tool bar to zero when this happens so frame sizes
3611 are correctly calculated.
3612 WBOX is the handle box widget that enables detach/attach of the tool bar.
3613 W is the tool bar widget.
3614 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3617 xg_tool_bar_detach_callback (wbox
, w
, client_data
)
3620 gpointer client_data
;
3622 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3623 extern int x_gtk_whole_detached_tool_bar
;
3625 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3630 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3632 /* When detaching a tool bar, not everything dissapear. There are
3633 a few pixels left that are used to drop the tool bar back into
3635 FRAME_TOOLBAR_HEIGHT (f
) = 4;
3636 xg_height_changed (f
);
3640 /* This callback is called when a tool bar is reattached. We must set
3641 the height of the tool bar when this happens so frame sizes
3642 are correctly calculated.
3643 WBOX is the handle box widget that enables detach/attach of the tool bar.
3644 W is the tool bar widget.
3645 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3648 xg_tool_bar_attach_callback (wbox
, w
, client_data
)
3651 gpointer client_data
;
3653 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3654 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3660 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3662 gtk_widget_size_request (w
, &req
);
3663 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3664 xg_height_changed (f
);
3668 /* This callback is called when the mouse enters or leaves a tool bar item.
3669 It is used for displaying and hiding the help text.
3670 W is the tool bar item, a button.
3671 EVENT is either an enter event or leave event.
3672 CLIENT_DATA is an integer that is the index of the button in the
3673 tool bar. 0 is the first button.
3675 Returns FALSE to tell GTK to keep processing this event. */
3678 xg_tool_bar_help_callback (w
, event
, client_data
)
3680 GdkEventCrossing
*event
;
3681 gpointer client_data
;
3683 /* The EMACS_INT cast avoids a warning. */
3684 int idx
= (int) (EMACS_INT
) client_data
;
3685 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3686 Lisp_Object help
, frame
;
3688 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3691 if (event
->type
== GDK_ENTER_NOTIFY
)
3693 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3694 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3697 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3702 XSETFRAME (frame
, f
);
3703 kbd_buffer_store_help_event (frame
, help
);
3709 /* This callback is called when a tool bar item shall be redrawn.
3710 It modifies the expose event so that the GtkImage widget redraws the
3711 whole image. This to overcome a bug that makes GtkImage draw the image
3712 in the wrong place when it tries to redraw just a part of the image.
3713 W is the GtkImage to be redrawn.
3714 EVENT is the expose event for W.
3715 CLIENT_DATA is unused.
3717 Returns FALSE to tell GTK to keep processing this event. */
3720 xg_tool_bar_item_expose_callback (w
, event
, client_data
)
3722 GdkEventExpose
*event
;
3723 gpointer client_data
;
3727 gdk_drawable_get_size (event
->window
, &width
, &height
);
3729 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3730 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3732 event
->area
.x
= max (0, event
->area
.x
);
3733 event
->area
.y
= max (0, event
->area
.y
);
3735 event
->area
.width
= max (width
, event
->area
.width
);
3736 event
->area
.height
= max (height
, event
->area
.height
);
3741 /* Attach a tool bar to frame F. */
3744 xg_pack_tool_bar (f
)
3747 struct x_output
*x
= f
->output_data
.x
;
3748 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3750 x
->handlebox_widget
= gtk_handle_box_new ();
3751 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3752 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3753 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3754 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3756 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3759 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3762 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3764 gtk_widget_show_all (x
->handlebox_widget
);
3767 /* Create a tool bar for frame F. */
3770 xg_create_tool_bar (f
)
3773 struct x_output
*x
= f
->output_data
.x
;
3775 x
->toolbar_widget
= gtk_toolbar_new ();
3776 x
->toolbar_detached
= 0;
3778 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3780 /* We only have icons, so override any user setting. We could
3781 use the caption property of the toolbar item (see update_frame_tool_bar
3782 below), but some of those strings are long, making the toolbar so
3783 long it does not fit on the screen. The GtkToolbar widget makes every
3784 item equal size, so the longest caption determine the size of every
3785 tool bar item. I think the creators of the GtkToolbar widget
3786 counted on 4 or 5 character long strings. */
3787 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3788 gtk_toolbar_set_orientation (GTK_TOOLBAR (x
->toolbar_widget
),
3789 GTK_ORIENTATION_HORIZONTAL
);
3793 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3795 /* Find the right-to-left image named by RTL in the tool bar images for F.
3796 Returns IMAGE if RTL is not found. */
3799 find_rtl_image (f
, image
, rtl
)
3805 Lisp_Object file
, rtl_name
;
3806 struct gcpro gcpro1
, gcpro2
;
3807 GCPRO2 (file
, rtl_name
);
3809 rtl_name
= Ffile_name_nondirectory (rtl
);
3811 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3813 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3814 if (!NILP (file
= file_for_image (rtl_image
)))
3816 file
= call1 (intern ("file-name-sans-extension"),
3817 Ffile_name_nondirectory (file
));
3818 if (EQ (Fequal (file
, rtl_name
), Qt
))
3829 /* Update the tool bar for frame F. Add new buttons and remove old. */
3831 extern Lisp_Object Qx_gtk_map_stock
;
3834 update_frame_tool_bar (f
)
3838 GtkRequisition old_req
, new_req
;
3839 struct x_output
*x
= f
->output_data
.x
;
3840 int hmargin
= 0, vmargin
= 0;
3841 GtkToolbar
*wtoolbar
;
3843 GtkTextDirection dir
;
3844 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
3846 if (! FRAME_GTK_WIDGET (f
))
3851 if (INTEGERP (Vtool_bar_button_margin
)
3852 && XINT (Vtool_bar_button_margin
) > 0)
3854 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3855 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3857 else if (CONSP (Vtool_bar_button_margin
))
3859 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3860 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3861 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3863 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3864 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3865 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3868 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3869 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3870 i.e. zero. This means that margins less than
3871 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3872 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3873 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3875 if (! x
->toolbar_widget
)
3876 xg_create_tool_bar (f
);
3878 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
3879 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &old_req
);
3880 dir
= gtk_widget_get_direction (x
->toolbar_widget
);
3882 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3884 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3885 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3889 struct image
*img
= NULL
;
3891 Lisp_Object stock
= Qnil
;
3892 GtkStockItem stock_item
;
3893 char *stock_name
= NULL
;
3894 char *icon_name
= NULL
;
3896 GtkWidget
*wbutton
= NULL
;
3897 GtkWidget
*weventbox
;
3898 Lisp_Object specified_file
;
3900 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (x
->toolbar_widget
), i
);
3904 weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3905 wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3908 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3910 /* Ignore invalid image specifications. */
3911 if (!valid_image_p (image
))
3913 if (wbutton
) gtk_widget_hide (wbutton
);
3917 specified_file
= file_for_image (image
);
3918 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
3919 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
3921 if (STRINGP (stock
))
3923 stock_name
= SSDATA (stock
);
3924 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
3926 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
3927 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
3929 icon_name
= stock_name
+ 2;
3933 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
3936 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3938 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
3939 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3947 if (stock_name
== NULL
&& icon_name
== NULL
)
3949 /* No stock image, or stock item not known. Try regular image. */
3951 /* If image is a vector, choose the image according to the
3953 if (dir
== GTK_TEXT_DIR_RTL
3954 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
3957 image
= find_rtl_image (f
, image
, rtl
);
3960 if (VECTORP (image
))
3964 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3965 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3968 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3969 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3971 xassert (ASIZE (image
) >= idx
);
3972 image
= AREF (image
, idx
);
3977 img_id
= lookup_image (f
, image
);
3978 img
= IMAGE_FROM_ID (f
, img_id
);
3979 prepare_image_for_display (f
, img
);
3981 if (img
->load_failed_p
|| img
->pixmap
== None
)
3984 gtk_widget_hide_all (GTK_WIDGET (ti
));
3987 /* Insert an empty (non-image) button */
3988 weventbox
= gtk_event_box_new ();
3989 wbutton
= gtk_button_new ();
3990 gtk_button_set_focus_on_click (GTK_BUTTON (wbutton
), FALSE
);
3991 gtk_button_set_relief (GTK_BUTTON (wbutton
),
3993 gtk_container_add (GTK_CONTAINER (weventbox
), wbutton
);
3994 ti
= gtk_tool_item_new ();
3995 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
3996 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
), ti
, -1);
4007 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4008 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4009 (gpointer
) xstrdup (stock_name
),
4010 (GDestroyNotify
) xfree
);
4014 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4015 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4016 (gpointer
) xstrdup (icon_name
),
4017 (GDestroyNotify
) xfree
);
4021 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4022 /* Save the image so we can see if an update is needed when
4023 this function is called again. */
4024 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4025 (gpointer
)img
->pixmap
);
4028 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4029 wbutton
= gtk_button_new ();
4030 gtk_button_set_focus_on_click (GTK_BUTTON (wbutton
), FALSE
);
4031 gtk_button_set_relief (GTK_BUTTON (wbutton
), GTK_RELIEF_NONE
);
4032 gtk_container_add (GTK_CONTAINER (wbutton
), w
);
4033 weventbox
= gtk_event_box_new ();
4034 gtk_container_add (GTK_CONTAINER (weventbox
), wbutton
);
4035 ti
= gtk_tool_item_new ();
4036 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4037 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
), ti
, -1);
4040 /* The EMACS_INT cast avoids a warning. */
4041 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4042 G_CALLBACK (xg_tool_bar_menu_proxy
),
4043 (gpointer
) (EMACS_INT
) i
);
4045 g_signal_connect (G_OBJECT (wbutton
), "clicked",
4046 G_CALLBACK (xg_tool_bar_callback
),
4047 (gpointer
) (EMACS_INT
) i
);
4049 gtk_widget_show_all (GTK_WIDGET (ti
));
4052 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4054 /* Catch expose events to overcome an annoying redraw bug, see
4055 comment for xg_tool_bar_item_expose_callback. */
4056 g_signal_connect (G_OBJECT (ti
),
4058 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4061 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4062 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4064 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
4065 no distinction based on modifiers in the activate callback,
4066 so we have to do it ourselves. */
4067 g_signal_connect (wbutton
, "button-release-event",
4068 G_CALLBACK (xg_tool_bar_button_cb
),
4071 g_object_set_data (G_OBJECT (wbutton
), XG_FRAME_DATA
, (gpointer
)f
);
4073 /* Use enter/leave notify to show help. We use the events
4074 rather than the GtkButton specific signals "enter" and
4075 "leave", so we can have only one callback. The event
4076 will tell us what kind of event it is. */
4077 /* The EMACS_INT cast avoids a warning. */
4078 g_signal_connect (G_OBJECT (weventbox
),
4079 "enter-notify-event",
4080 G_CALLBACK (xg_tool_bar_help_callback
),
4081 (gpointer
) (EMACS_INT
) i
);
4082 g_signal_connect (G_OBJECT (weventbox
),
4083 "leave-notify-event",
4084 G_CALLBACK (xg_tool_bar_help_callback
),
4085 (gpointer
) (EMACS_INT
) i
);
4089 GtkWidget
*wimage
= gtk_bin_get_child (GTK_BIN (wbutton
));
4090 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
4091 XG_TOOL_BAR_IMAGE_DATA
);
4092 gpointer old_stock_name
= g_object_get_data (G_OBJECT (wimage
),
4093 XG_TOOL_BAR_STOCK_NAME
);
4094 gpointer old_icon_name
= g_object_get_data (G_OBJECT (wimage
),
4095 XG_TOOL_BAR_ICON_NAME
);
4097 (! old_stock_name
|| strcmp (old_stock_name
, stock_name
) != 0))
4099 gtk_image_set_from_stock (GTK_IMAGE (wimage
),
4100 stock_name
, icon_size
);
4101 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4102 (gpointer
) xstrdup (stock_name
),
4103 (GDestroyNotify
) xfree
);
4104 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4106 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
, NULL
);
4108 else if (icon_name
&&
4109 (! old_icon_name
|| strcmp (old_icon_name
, icon_name
) != 0))
4111 gtk_image_set_from_icon_name (GTK_IMAGE (wimage
),
4112 icon_name
, icon_size
);
4113 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4114 (gpointer
) xstrdup (icon_name
),
4115 (GDestroyNotify
) xfree
);
4116 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4118 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4121 else if (img
&& old_img
!= img
->pixmap
)
4123 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
4124 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4125 (gpointer
)img
->pixmap
);
4127 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4129 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
, NULL
);
4132 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
4134 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4135 gtk_widget_show_all (GTK_WIDGET (ti
));
4141 /* Remove buttons not longer needed. We just hide them so they
4142 can be reused later on. */
4145 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (x
->toolbar_widget
), i
++);
4146 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
4147 } while (ti
!= NULL
);
4150 if (pack_tool_bar
&& f
->n_tool_bar_items
!= 0)
4151 xg_pack_tool_bar (f
);
4154 gtk_widget_size_request (GTK_WIDGET (x
->toolbar_widget
), &new_req
);
4155 if (old_req
.height
!= new_req
.height
4156 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
4158 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
4159 xg_height_changed (f
);
4164 /* Deallocate all resources for the tool bar on frame F.
4165 Remove the tool bar. */
4168 free_frame_tool_bar (f
)
4171 struct x_output
*x
= f
->output_data
.x
;
4173 if (x
->toolbar_widget
)
4175 int is_packed
= x
->handlebox_widget
!= 0;
4177 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4178 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4180 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4181 x
->handlebox_widget
);
4183 gtk_widget_destroy (x
->toolbar_widget
);
4185 x
->toolbar_widget
= 0;
4186 x
->handlebox_widget
= 0;
4187 FRAME_TOOLBAR_HEIGHT (f
) = 0;
4188 xg_height_changed (f
);
4196 /***********************************************************************
4198 ***********************************************************************/
4202 GtkBindingSet
*binding_set
;
4205 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4206 we keep it permanently linked in. */
4211 xg_ignore_gtk_scrollbar
= 0;
4212 xg_detached_menus
= 0;
4213 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4214 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4216 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4217 id_to_widget
.widgets
= 0;
4219 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4220 bindings. It doesn't seem to be any way to remove properties,
4221 so we set it to VoidSymbol which in X means "no key". */
4222 gtk_settings_set_string_property (gtk_settings_get_default (),
4223 "gtk-menu-bar-accel",
4227 /* Make GTK text input widgets use Emacs style keybindings. This is
4229 gtk_settings_set_string_property (gtk_settings_get_default (),
4230 "gtk-key-theme-name",
4234 /* Make dialogs close on C-g. Since file dialog inherits from
4235 dialog, this works for them also. */
4236 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4237 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4240 /* Make menus close on C-g. */
4241 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4242 (GTK_TYPE_MENU_SHELL
));
4243 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4247 #endif /* USE_GTK */
4249 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
4250 (do not change this comment) */