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>
38 #include "xsettings.h"
41 #include <X11/Xft/Xft.h>
44 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
45 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
47 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
48 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
50 /* Avoid "differ in sign" warnings */
51 #define SSDATA(x) ((char *) SDATA (x))
53 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
54 #define gtk_widget_set_has_window(w, b) \
55 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
57 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
58 #define gtk_dialog_get_action_area(w) ((w)->action_area)
59 #define gtk_dialog_get_content_area(w) ((w)->vbox)
61 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
62 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
64 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
65 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
66 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
67 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
68 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
70 #if GTK_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 11
71 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
73 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
77 /***********************************************************************
78 Display handling functions
79 ***********************************************************************/
81 /* Keep track of the default display, or NULL if there is none. Emacs
82 may close all its displays. */
84 static GdkDisplay
*gdpy_def
;
86 /* When the GTK widget W is to be created on a display for F that
87 is not the default display, set the display for W.
88 W can be a GtkMenu or a GtkWindow widget. */
91 xg_set_screen (GtkWidget
*w
, FRAME_PTR f
)
93 if (FRAME_X_DISPLAY (f
) != GDK_DISPLAY ())
95 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
96 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
99 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
101 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
106 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
107 *DPY is set to NULL if the display can't be opened.
109 Returns non-zero if display could be opened, zero if display could not
110 be opened, and less than zero if the GTK version doesn't support
114 xg_display_open (char *display_name
, Display
**dpy
)
118 gdpy
= gdk_display_open (display_name
);
119 if (!gdpy_def
&& gdpy
)
122 gdk_display_manager_set_default_display (gdk_display_manager_get (),
126 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
130 /* Close display DPY. */
133 xg_display_close (Display
*dpy
)
135 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
137 /* If this is the default display, try to change it before closing.
138 If there is no other display to use, gdpy_def is set to NULL, and
139 the next call to xg_display_open resets the default display. */
140 if (gdk_display_get_default () == gdpy
)
142 struct x_display_info
*dpyinfo
;
143 GdkDisplay
*gdpy_new
= NULL
;
145 /* Find another display. */
146 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
147 if (dpyinfo
->display
!= dpy
)
149 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
150 gdk_display_manager_set_default_display (gdk_display_manager_get (),
157 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
158 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
159 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
160 can continue running, but there will be memory leaks. */
161 g_object_run_dispose (G_OBJECT (gdpy
));
163 /* This seems to be fixed in GTK 2.10. */
164 gdk_display_close (gdpy
);
169 /***********************************************************************
171 ***********************************************************************/
172 /* The next two variables and functions are taken from lwlib. */
173 static widget_value
*widget_value_free_list
;
174 static int malloc_cpt
;
176 /* Allocate a widget_value structure, either by taking one from the
177 widget_value_free_list or by malloc:ing a new one.
179 Return a pointer to the allocated structure. */
182 malloc_widget_value (void)
185 if (widget_value_free_list
)
187 wv
= widget_value_free_list
;
188 widget_value_free_list
= wv
->free_list
;
193 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
196 memset (wv
, 0, sizeof (widget_value
));
200 /* This is analogous to free. It frees only what was allocated
201 by malloc_widget_value, and no substructures. */
204 free_widget_value (widget_value
*wv
)
211 /* When the number of already allocated cells is too big,
218 wv
->free_list
= widget_value_free_list
;
219 widget_value_free_list
= wv
;
224 /* Create and return the cursor to be used for popup menus and
225 scroll bars on display DPY. */
228 xg_create_default_cursor (Display
*dpy
)
230 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
231 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
234 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
237 xg_get_pixbuf_from_pix_and_mask (GdkPixmap
*gpix
,
242 GdkPixbuf
*icon_buf
, *tmp_buf
;
244 gdk_drawable_get_size (gpix
, &width
, &height
);
245 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
246 0, 0, 0, 0, width
, height
);
247 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
248 g_object_unref (G_OBJECT (tmp_buf
));
252 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
257 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
258 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
259 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
260 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
263 for (y
= 0; y
< height
; ++y
)
265 guchar
*iconptr
, *maskptr
;
268 iconptr
= pixels
+ y
* rowstride
;
269 maskptr
= mask_pixels
+ y
* mask_rowstride
;
271 for (x
= 0; x
< width
; ++x
)
273 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
274 just R is sufficient. */
276 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
278 iconptr
+= rowstride
/width
;
279 maskptr
+= mask_rowstride
/width
;
283 g_object_unref (G_OBJECT (mask_buf
));
290 file_for_image (Lisp_Object image
)
292 Lisp_Object specified_file
= Qnil
;
294 extern Lisp_Object QCfile
;
296 for (tail
= XCDR (image
);
297 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
298 tail
= XCDR (XCDR (tail
)))
299 if (EQ (XCAR (tail
), QCfile
))
300 specified_file
= XCAR (XCDR (tail
));
302 return specified_file
;
305 /* For the image defined in IMG, make and return a GtkImage. For displays with
306 8 planes or less we must make a GdkPixbuf and apply the mask manually.
307 Otherwise the highlightning and dimming the tool bar code in GTK does
308 will look bad. For display with more than 8 planes we just use the
309 pixmap and mask directly. For monochrome displays, GTK doesn't seem
310 able to use external pixmaps, it looks bad whatever we do.
311 The image is defined on the display where frame F is.
312 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
313 If OLD_WIDGET is NULL, a new widget is constructed and returned.
314 If OLD_WIDGET is not NULL, that widget is modified. */
317 xg_get_image_for_pixmap (FRAME_PTR f
,
320 GtkImage
*old_widget
)
328 /* If we have a file, let GTK do all the image handling.
329 This seems to be the only way to make insensitive and activated icons
330 look good in all cases. */
331 Lisp_Object specified_file
= file_for_image (img
->spec
);
334 /* We already loaded the image once before calling this
335 function, so this only fails if the image file has been removed.
336 In that case, use the pixmap already loaded. */
338 if (STRINGP (specified_file
)
339 && STRINGP (file
= x_find_image_file (specified_file
)))
342 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
344 gtk_image_set_from_file (old_widget
, SSDATA (file
));
346 return GTK_WIDGET (old_widget
);
349 /* No file, do the image handling ourselves. This will look very bad
350 on a monochrome display, and sometimes bad on all displays with
353 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
354 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
355 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
357 /* This is a workaround to make icons look good on pseudo color
358 displays. Apparently GTK expects the images to have an alpha
359 channel. If they don't, insensitive and activated icons will
360 look bad. This workaround does not work on monochrome displays,
361 and is strictly not needed on true color/static color displays (i.e.
362 16 bits and higher). But we do it anyway so we get a pixbuf that is
363 not associated with the img->pixmap. The img->pixmap may be removed
364 by clearing the image cache and then the tool bar redraw fails, since
365 Gtk+ assumes the pixmap is always there. */
366 cmap
= gtk_widget_get_colormap (widget
);
367 icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
370 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
372 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
374 g_object_unref (G_OBJECT (icon_buf
));
376 g_object_unref (G_OBJECT (gpix
));
377 if (gmask
) g_object_unref (G_OBJECT (gmask
));
379 return GTK_WIDGET (old_widget
);
383 /* Set CURSOR on W and all widgets W contain. We must do like this
384 for scroll bars and menu because they create widgets internally,
385 and it is those widgets that are visible. */
388 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
390 GdkWindow
*window
= gtk_widget_get_window(w
);
391 GList
*children
= gdk_window_peek_children (window
);
393 gdk_window_set_cursor (window
, cursor
);
395 /* The scroll bar widget has more than one GDK window (had to look at
396 the source to figure this out), and there is no way to set cursor
397 on widgets in GTK. So we must set the cursor for all GDK windows.
400 for ( ; children
; children
= g_list_next (children
))
401 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
404 /* Insert NODE into linked LIST. */
407 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
409 xg_list_node
*list_start
= list
->next
;
411 if (list_start
) list_start
->prev
= node
;
412 node
->next
= list_start
;
417 /* Remove NODE from linked LIST. */
420 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
422 xg_list_node
*list_start
= list
->next
;
423 if (node
== list_start
)
425 list
->next
= node
->next
;
426 if (list
->next
) list
->next
->prev
= 0;
430 node
->prev
->next
= node
->next
;
431 if (node
->next
) node
->next
->prev
= node
->prev
;
435 /* Allocate and return a utf8 version of STR. If STR is already
436 utf8 or NULL, just return STR.
437 If not, a new string is allocated and the caller must free the result
441 get_utf8_string (char *str
)
443 char *utf8_str
= str
;
445 if (!str
) return NULL
;
447 /* If not UTF-8, try current locale. */
448 if (!g_utf8_validate (str
, -1, NULL
))
449 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
453 /* Probably some control characters in str. Escape them. */
457 unsigned char *p
= (unsigned char *)str
;
459 GError
*error
= NULL
;
461 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
462 &bytes_written
, &error
))
463 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
466 p
+= bytes_written
+1;
467 g_error_free (error
);
473 g_error_free (error
);
478 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
479 p
= (unsigned char *)str
;
481 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
482 &bytes_written
, &error
))
483 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
485 strncpy (up
, (char *)p
, bytes_written
);
486 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
487 up
[bytes_written
+4] = '\0';
488 up
+= bytes_written
+4;
489 p
+= bytes_written
+1;
490 g_error_free (error
);
496 strcat (utf8_str
, cp
);
501 g_error_free (error
);
510 /***********************************************************************
512 ***********************************************************************/
513 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
514 We use that to pop down the tooltip. This happens if Gtk+ for some
515 reason wants to change or hide the tooltip. */
517 #ifdef USE_GTK_TOOLTIP
520 hierarchy_ch_cb (GtkWidget
*widget
,
521 GtkWidget
*previous_toplevel
,
524 FRAME_PTR f
= (FRAME_PTR
) user_data
;
525 struct x_output
*x
= f
->output_data
.x
;
526 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
528 if (! top
|| ! GTK_IS_WINDOW (top
))
529 gtk_widget_hide (previous_toplevel
);
532 /* Callback called when Gtk+ thinks a tooltip should be displayed.
533 We use it to get the tooltip window and the tooltip widget so
534 we can manipulate the ourselves.
536 Return FALSE ensures that the tooltip is not shown. */
539 qttip_cb (GtkWidget
*widget
,
542 gboolean keyboard_mode
,
546 FRAME_PTR f
= (FRAME_PTR
) user_data
;
547 struct x_output
*x
= f
->output_data
.x
;
548 if (x
->ttip_widget
== NULL
)
550 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
551 x
->ttip_widget
= tooltip
;
552 g_object_ref (G_OBJECT (tooltip
));
553 x
->ttip_lbl
= gtk_label_new ("");
554 g_object_ref (G_OBJECT (x
->ttip_lbl
));
555 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
556 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
557 /* Realize so we can safely get screen later on. */
558 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
559 gtk_widget_realize (x
->ttip_lbl
);
561 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
562 G_CALLBACK (hierarchy_ch_cb
), f
);
567 #endif /* USE_GTK_TOOLTIP */
569 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
570 Return zero if no system tooltip available, non-zero otherwise. */
573 xg_prepare_tooltip (FRAME_PTR f
,
578 #ifndef USE_GTK_TOOLTIP
581 struct x_output
*x
= f
->output_data
.x
;
585 GtkSettings
*settings
;
586 gboolean tt_enabled
= TRUE
;
588 Lisp_Object encoded_string
;
590 if (!x
->ttip_lbl
) return 0;
593 encoded_string
= ENCODE_UTF_8 (string
);
594 widget
= GTK_WIDGET (x
->ttip_lbl
);
595 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
596 screen
= gdk_drawable_get_screen (gwin
);
597 settings
= gtk_settings_get_for_screen (screen
);
598 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
601 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
602 /* Record that we disabled it so it can be enabled again. */
603 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
607 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
608 g_object_set_data (G_OBJECT
609 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
610 "gdk-display-current-tooltip", NULL
);
612 /* Put out dummy widget in so we can get callbacks for unrealize and
613 hierarchy-changed. */
614 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
616 gtk_tooltip_set_text (x
->ttip_widget
, SDATA (encoded_string
));
617 gtk_widget_size_request (GTK_WIDGET (x
->ttip_window
), &req
);
618 if (width
) *width
= req
.width
;
619 if (height
) *height
= req
.height
;
624 #endif /* USE_GTK_TOOLTIP */
627 /* Show the tooltip at ROOT_X and ROOT_Y.
628 xg_prepare_tooltip must have been called before this function. */
631 xg_show_tooltip (FRAME_PTR f
, int root_x
, int root_y
)
633 #ifdef USE_GTK_TOOLTIP
634 struct x_output
*x
= f
->output_data
.x
;
638 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
639 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
645 /* Hide tooltip if shown. Do nothing if not shown.
646 Return non-zero if tip was hidden, non-ero if not (i.e. not using
650 xg_hide_tooltip (FRAME_PTR f
)
653 #ifdef USE_GTK_TOOLTIP
654 if (f
->output_data
.x
->ttip_window
)
656 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
658 gtk_widget_hide (GTK_WIDGET (win
));
660 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
662 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
663 GdkScreen
*screen
= gdk_drawable_get_screen (gwin
);
664 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
665 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
676 /***********************************************************************
677 General functions for creating widgets, resizing, events, e.t.c.
678 ***********************************************************************/
680 /* Make a geometry string and pass that to GTK. It seems this is the
681 only way to get geometry position right if the user explicitly
682 asked for a position when starting Emacs.
683 F is the frame we shall set geometry for. */
686 xg_set_geometry (FRAME_PTR f
)
688 if (f
->size_hint_flags
& (USPosition
| PPosition
))
690 int left
= f
->left_pos
;
691 int xneg
= f
->size_hint_flags
& XNegative
;
692 int top
= f
->top_pos
;
693 int yneg
= f
->size_hint_flags
& YNegative
;
701 sprintf (geom_str
, "=%dx%d%c%d%c%d",
702 FRAME_PIXEL_WIDTH (f
),
703 FRAME_PIXEL_HEIGHT (f
),
704 (xneg
? '-' : '+'), left
,
705 (yneg
? '-' : '+'), top
);
707 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
709 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
713 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
714 and use a GtkFixed widget, this doesn't happen automatically. */
717 xg_clear_under_internal_border (FRAME_PTR f
)
719 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
721 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
722 gtk_widget_queue_draw (wfixed
);
723 gdk_window_process_all_updates ();
724 x_clear_area (FRAME_X_DISPLAY (f
),
727 FRAME_PIXEL_WIDTH (f
),
728 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
729 x_clear_area (FRAME_X_DISPLAY (f
),
732 FRAME_INTERNAL_BORDER_WIDTH (f
),
733 FRAME_PIXEL_HEIGHT (f
), 0);
734 x_clear_area (FRAME_X_DISPLAY (f
),
736 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
737 FRAME_PIXEL_WIDTH (f
),
738 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
739 x_clear_area (FRAME_X_DISPLAY (f
),
741 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
743 FRAME_INTERNAL_BORDER_WIDTH (f
),
744 FRAME_PIXEL_HEIGHT (f
), 0);
748 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
749 and a Gtk+ menu bar, we get resize events for the edit part of the
750 frame only. We let Gtk+ deal with the Gtk+ parts.
751 F is the frame to resize.
752 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
755 xg_frame_resized (FRAME_PTR f
, int pixelwidth
, int pixelheight
)
759 if (pixelwidth
== -1 && pixelheight
== -1)
761 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
762 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
764 &pixelwidth
, &pixelheight
, 0);
769 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
770 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
772 if (columns
!= FRAME_COLS (f
)
773 || rows
!= FRAME_LINES (f
)
774 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
775 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
777 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
778 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
780 xg_clear_under_internal_border (f
);
781 change_frame_size (f
, rows
, columns
, 0, 1, 0);
782 SET_FRAME_GARBAGED (f
);
783 cancel_mouse_face (f
);
787 /* Resize the outer window of frame F after chainging the height.
788 COLUMNS/ROWS is the size the edit area shall have after the resize. */
791 xg_frame_set_char_size (FRAME_PTR f
, int cols
, int rows
)
793 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
794 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
797 if (FRAME_PIXEL_HEIGHT (f
) == 0)
800 /* Take into account the size of the scroll bar. Always use the
801 number of columns occupied by the scroll bar here otherwise we
802 might end up with a frame width that is not a multiple of the
803 frame's character width which is bad for vertically split
805 f
->scroll_bar_actual_width
806 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
808 compute_fringe_widths (f
, 0);
810 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
811 after calculating that value. */
812 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
813 + FRAME_TOOLBAR_WIDTH (f
);
816 /* Do this before resize, as we don't know yet if we will be resized. */
817 xg_clear_under_internal_border (f
);
819 /* Must resize our top level widget. Font size may have changed,
820 but not rows/cols. */
821 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
822 pixelwidth
, pixelheight
);
823 x_wm_set_size_hint (f
, 0, 0);
825 SET_FRAME_GARBAGED (f
);
826 cancel_mouse_face (f
);
828 /* We can not call change_frame_size for a mapped frame,
829 we can not set pixel width/height either. The window manager may
830 override our resize request, XMonad does this all the time.
831 The best we can do is try to sync, so lisp code sees the updated
832 size as fast as possible.
833 For unmapped windows, we can set rows/cols. When
834 the frame is mapped again we will (hopefully) get the correct size. */
835 if (f
->async_visible
)
837 /* Must call this to flush out events */
838 (void)gtk_events_pending ();
840 x_wait_for_event (f
, ConfigureNotify
);
844 change_frame_size (f
, rows
, cols
, 0, 1, 0);
845 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
846 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
850 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
851 The policy is to keep the number of editable lines. */
854 xg_height_or_width_changed (FRAME_PTR f
)
856 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
857 FRAME_TOTAL_PIXEL_WIDTH (f
),
858 FRAME_TOTAL_PIXEL_HEIGHT (f
));
859 f
->output_data
.x
->hint_flags
= 0;
860 x_wm_set_size_hint (f
, 0, 0);
863 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
864 Must be done like this, because GtkWidget:s can have "hidden"
865 X Window that aren't accessible.
867 Return 0 if no widget match WDESC. */
870 xg_win_to_widget (Display
*dpy
, Window wdesc
)
873 GtkWidget
*gwdesc
= 0;
877 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
882 event
.any
.window
= gdkwin
;
883 gwdesc
= gtk_get_event_widget (&event
);
890 /* Fill in the GdkColor C so that it represents PIXEL.
891 W is the widget that color will be used for. Used to find colormap. */
894 xg_pix_to_gcolor (GtkWidget
*w
, long unsigned int pixel
, GdkColor
*c
)
896 GdkColormap
*map
= gtk_widget_get_colormap (w
);
897 gdk_colormap_query_color (map
, pixel
, c
);
900 /* Create and set up the GTK widgets for frame F.
901 Return 0 if creation failed, non-zero otherwise. */
904 xg_create_frame_widgets (FRAME_PTR f
)
907 GtkWidget
*wvbox
, *whbox
;
915 if (FRAME_X_EMBEDDED_P (f
))
916 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
918 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
920 xg_set_screen (wtop
, f
);
922 wvbox
= gtk_vbox_new (FALSE
, 0);
923 whbox
= gtk_hbox_new (FALSE
, 0);
924 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
926 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
928 if (wtop
) gtk_widget_destroy (wtop
);
929 if (wvbox
) gtk_widget_destroy (wvbox
);
930 if (whbox
) gtk_widget_destroy (whbox
);
931 if (wfixed
) gtk_widget_destroy (wfixed
);
937 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
938 gtk_widget_set_name (wtop
, EMACS_CLASS
);
939 gtk_widget_set_name (wvbox
, "pane");
940 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
942 /* If this frame has a title or name, set it in the title bar. */
943 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
944 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
946 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
948 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
949 FRAME_GTK_WIDGET (f
) = wfixed
;
950 f
->output_data
.x
->vbox_widget
= wvbox
;
951 f
->output_data
.x
->hbox_widget
= whbox
;
953 gtk_widget_set_has_window (wfixed
, TRUE
);
955 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
956 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
957 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
959 if (FRAME_EXTERNAL_TOOL_BAR (f
))
960 update_frame_tool_bar (f
);
962 /* We don't want this widget double buffered, because we draw on it
963 with regular X drawing primitives, so from a GTK/GDK point of
964 view, the widget is totally blank. When an expose comes, this
965 will make the widget blank, and then Emacs redraws it. This flickers
966 a lot, so we turn off double buffering. */
967 gtk_widget_set_double_buffered (wfixed
, FALSE
);
969 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
970 SSDATA (Vx_resource_name
),
971 SSDATA (Vx_resource_class
));
973 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
974 GTK is to destroy the widget. We want Emacs to do that instead. */
975 g_signal_connect (G_OBJECT (wtop
), "delete-event",
976 G_CALLBACK (gtk_true
), 0);
978 /* Convert our geometry parameters into a geometry string
980 GTK will itself handle calculating the real position this way. */
983 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
985 gtk_widget_add_events (wfixed
,
986 GDK_POINTER_MOTION_MASK
988 | GDK_BUTTON_PRESS_MASK
989 | GDK_BUTTON_RELEASE_MASK
991 | GDK_ENTER_NOTIFY_MASK
992 | GDK_LEAVE_NOTIFY_MASK
993 | GDK_FOCUS_CHANGE_MASK
995 | GDK_VISIBILITY_NOTIFY_MASK
);
997 /* Must realize the windows so the X window gets created. It is used
998 by callers of this function. */
999 gtk_widget_realize (wfixed
);
1000 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1002 /* Since GTK clears its window by filling with the background color,
1003 we must keep X and GTK background in sync. */
1004 xg_pix_to_gcolor (wfixed
, FRAME_BACKGROUND_PIXEL (f
), &bg
);
1005 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
1007 /* Also, do not let any background pixmap to be set, this looks very
1008 bad as Emacs overwrites the background pixmap with its own idea
1009 of background color. */
1010 style
= gtk_widget_get_modifier_style (wfixed
);
1012 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1013 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1014 gtk_widget_modify_style (wfixed
, style
);
1016 #ifdef USE_GTK_TOOLTIP
1017 /* Steal a tool tip window we can move ourselves. */
1018 f
->output_data
.x
->ttip_widget
= 0;
1019 f
->output_data
.x
->ttip_lbl
= 0;
1020 f
->output_data
.x
->ttip_window
= 0;
1021 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1022 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1031 xg_free_frame_widgets (FRAME_PTR f
)
1033 if (FRAME_GTK_OUTER_WIDGET (f
))
1035 struct x_output
*x
= f
->output_data
.x
;
1036 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1037 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1038 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1039 #ifdef USE_GTK_TOOLTIP
1041 gtk_widget_destroy (x
->ttip_lbl
);
1043 g_object_unref (G_OBJECT (x
->ttip_widget
));
1048 /* Set the normal size hints for the window manager, for frame F.
1049 FLAGS is the flags word to use--or 0 meaning preserve the flags
1050 that the window now has.
1051 If USER_POSITION is nonzero, we set the User Position
1052 flag (this is useful when FLAGS is 0). */
1055 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
1057 /* Must use GTK routines here, otherwise GTK resets the size hints
1058 to its own defaults. */
1059 GdkGeometry size_hints
;
1060 gint hint_flags
= 0;
1061 int base_width
, base_height
;
1062 int min_rows
= 0, min_cols
= 0;
1063 int win_gravity
= f
->win_gravity
;
1065 /* Don't set size hints during initialization; that apparently leads
1066 to a race condition. See the thread at
1067 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1068 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1073 memset (&size_hints
, 0, sizeof (size_hints
));
1074 f
->output_data
.x
->size_hints
= size_hints
;
1075 f
->output_data
.x
->hint_flags
= hint_flags
;
1078 flags
= f
->size_hint_flags
;
1080 size_hints
= f
->output_data
.x
->size_hints
;
1081 hint_flags
= f
->output_data
.x
->hint_flags
;
1083 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1084 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1085 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1087 hint_flags
|= GDK_HINT_BASE_SIZE
;
1088 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0) + FRAME_TOOLBAR_WIDTH (f
);
1089 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
1090 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1092 check_frame_size (f
, &min_rows
, &min_cols
);
1094 size_hints
.base_width
= base_width
;
1095 size_hints
.base_height
= base_height
;
1096 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1097 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1099 /* These currently have a one to one mapping with the X values, but I
1100 don't think we should rely on that. */
1101 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1102 size_hints
.win_gravity
= 0;
1103 if (win_gravity
== NorthWestGravity
)
1104 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1105 else if (win_gravity
== NorthGravity
)
1106 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1107 else if (win_gravity
== NorthEastGravity
)
1108 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1109 else if (win_gravity
== WestGravity
)
1110 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1111 else if (win_gravity
== CenterGravity
)
1112 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1113 else if (win_gravity
== EastGravity
)
1114 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1115 else if (win_gravity
== SouthWestGravity
)
1116 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1117 else if (win_gravity
== SouthGravity
)
1118 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1119 else if (win_gravity
== SouthEastGravity
)
1120 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1121 else if (win_gravity
== StaticGravity
)
1122 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1126 hint_flags
&= ~GDK_HINT_POS
;
1127 hint_flags
|= GDK_HINT_USER_POS
;
1130 if (hint_flags
!= f
->output_data
.x
->hint_flags
1131 || memcmp (&size_hints
,
1132 &f
->output_data
.x
->size_hints
,
1133 sizeof (size_hints
)) != 0)
1136 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1137 NULL
, &size_hints
, hint_flags
);
1138 f
->output_data
.x
->size_hints
= size_hints
;
1139 f
->output_data
.x
->hint_flags
= hint_flags
;
1144 /* Change background color of a frame.
1145 Since GTK uses the background color to clear the window, we must
1146 keep the GTK and X colors in sync.
1147 F is the frame to change,
1148 BG is the pixel value to change to. */
1151 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
1153 if (FRAME_GTK_WIDGET (f
))
1158 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
1159 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
1165 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1166 functions so GTK does not overwrite the icon. */
1169 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1171 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1172 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
1173 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
1174 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
1176 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1181 /***********************************************************************
1183 ***********************************************************************/
1184 /* Return the dialog title to use for a dialog of type KEY.
1185 This is the encoding used by lwlib. We use the same for GTK. */
1188 get_dialog_title (char key
)
1198 title
= "Information";
1217 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1218 the dialog, but return TRUE so the event does not propagate further
1219 in GTK. This prevents GTK from destroying the dialog widget automatically
1220 and we can always destrou the widget manually, regardles of how
1221 it was popped down (button press or WM_DELETE_WINDOW).
1222 W is the dialog widget.
1223 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1224 user_data is NULL (not used).
1226 Returns TRUE to end propagation of event. */
1229 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1231 gtk_widget_unmap (w
);
1235 /* Create a popup dialog window. See also xg_create_widget below.
1236 WV is a widget_value describing the dialog.
1237 SELECT_CB is the callback to use when a button has been pressed.
1238 DEACTIVATE_CB is the callback to use when the dialog pops down.
1240 Returns the GTK dialog widget. */
1243 create_dialog (widget_value
*wv
,
1244 GCallback select_cb
,
1245 GCallback deactivate_cb
)
1247 char *title
= get_dialog_title (wv
->name
[0]);
1248 int total_buttons
= wv
->name
[1] - '0';
1249 int right_buttons
= wv
->name
[4] - '0';
1252 int button_spacing
= 10;
1253 GtkWidget
*wdialog
= gtk_dialog_new ();
1254 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1255 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1258 GtkWidget
*whbox_up
;
1259 GtkWidget
*whbox_down
;
1261 /* If the number of buttons is greater than 4, make two rows of buttons
1262 instead. This looks better. */
1263 int make_two_rows
= total_buttons
> 4;
1265 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1266 left_buttons
= total_buttons
- right_buttons
;
1268 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1269 gtk_widget_set_name (wdialog
, "emacs-dialog");
1274 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1275 whbox_up
= gtk_hbox_new (FALSE
, 0);
1276 whbox_down
= gtk_hbox_new (FALSE
, 0);
1278 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1279 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1280 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1282 cur_box
= GTK_BOX (whbox_up
);
1285 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1286 G_CALLBACK (dialog_delete_callback
), 0);
1290 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1291 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1294 for (item
= wv
->contents
; item
; item
= item
->next
)
1296 char *utf8_label
= get_utf8_string (item
->value
);
1300 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1302 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1303 /* This is the text part of the dialog. */
1304 w
= gtk_label_new (utf8_label
);
1305 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1306 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1307 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1309 /* Try to make dialog look better. Must realize first so
1310 the widget can calculate the size it needs. */
1311 gtk_widget_realize (w
);
1312 gtk_widget_size_request (w
, &req
);
1313 gtk_box_set_spacing (wvbox
, req
.height
);
1314 if (item
->value
&& strlen (item
->value
) > 0)
1315 button_spacing
= 2*req
.width
/strlen (item
->value
);
1319 /* This is one button to add to the dialog. */
1320 w
= gtk_button_new_with_label (utf8_label
);
1321 if (! item
->enabled
)
1322 gtk_widget_set_sensitive (w
, FALSE
);
1324 g_signal_connect (G_OBJECT (w
), "clicked",
1325 select_cb
, item
->call_data
);
1327 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1328 if (++button_nr
== left_buttons
)
1331 cur_box
= GTK_BOX (whbox_down
);
1333 gtk_box_pack_start (cur_box
,
1340 if (utf8_label
&& utf8_label
!= item
->value
)
1341 g_free (utf8_label
);
1347 struct xg_dialog_data
1355 /* Function that is called when the file or font dialogs pop down.
1356 W is the dialog widget, RESPONSE is the response code.
1357 USER_DATA is what we passed in to g_signal_connect. */
1360 xg_dialog_response_cb (GtkDialog
*w
,
1364 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1365 dd
->response
= response
;
1366 g_main_loop_quit (dd
->loop
);
1370 /* Destroy the dialog. This makes it pop down. */
1373 pop_down_dialog (Lisp_Object arg
)
1375 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1376 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1379 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1380 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1382 g_main_loop_quit (dd
->loop
);
1383 g_main_loop_unref (dd
->loop
);
1390 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1391 We pass in DATA as gpointer* so we can use this as a callback. */
1394 xg_maybe_add_timer (gpointer data
)
1396 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1397 EMACS_TIME next_time
= timer_check (1);
1398 long secs
= EMACS_SECS (next_time
);
1399 long usecs
= EMACS_USECS (next_time
);
1403 if (secs
>= 0 && usecs
>= 0 && secs
< ((guint
)-1)/1000)
1405 dd
->timerid
= g_timeout_add (secs
* 1000 + usecs
/1000,
1413 /* Pops up a modal dialog W and waits for response.
1414 We don't use gtk_dialog_run because we want to process emacs timers.
1415 The dialog W is not destroyed when this function returns. */
1418 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1420 int count
= SPECPDL_INDEX ();
1421 struct xg_dialog_data dd
;
1423 xg_set_screen (w
, f
);
1424 gtk_window_set_transient_for (GTK_WINDOW (w
),
1425 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1426 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1427 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1429 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1430 dd
.response
= GTK_RESPONSE_CANCEL
;
1434 g_signal_connect (G_OBJECT (w
),
1436 G_CALLBACK (xg_dialog_response_cb
),
1438 /* Don't destroy the widget if closed by the window manager close button. */
1439 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1440 gtk_widget_show (w
);
1442 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1444 (void) xg_maybe_add_timer (&dd
);
1445 g_main_loop_run (dd
.loop
);
1448 unbind_to (count
, Qnil
);
1454 /***********************************************************************
1455 File dialog functions
1456 ***********************************************************************/
1457 /* Return non-zero if the old file selection dialog is being used.
1458 Return zero if not. */
1461 xg_uses_old_file_dialog (void)
1463 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1464 extern int x_gtk_use_old_file_dialog
;
1465 return x_gtk_use_old_file_dialog
;
1472 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1474 /* Return the selected file for file chooser dialog W.
1475 The returned string must be free:d. */
1478 xg_get_file_name_from_chooser (GtkWidget
*w
)
1480 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1483 /* Callback called when the "Show hidden files" toggle is pressed.
1484 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1487 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1489 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1491 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1492 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1496 /* Callback called when a property changes in a file chooser.
1497 GOBJECT is the file chooser dialog, ARG1 describes the property.
1498 USER_DATA is the toggle widget in the file chooser dialog.
1499 We use this to update the "Show hidden files" toggle when the user
1500 changes that property by right clicking in the file list. */
1503 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1505 extern int x_gtk_show_hidden_files
;
1507 if (strcmp (arg1
->name
, "show-hidden") == 0)
1509 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1510 gboolean visible
, toggle_on
;
1512 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1513 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1515 if (!!visible
!= !!toggle_on
)
1517 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1518 G_CALLBACK (xg_toggle_visibility_cb
),
1520 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1521 g_signal_handlers_unblock_by_func
1522 (G_OBJECT (wtoggle
),
1523 G_CALLBACK (xg_toggle_visibility_cb
),
1526 x_gtk_show_hidden_files
= visible
;
1530 /* Read a file name from the user using a file chooser dialog.
1531 F is the current frame.
1532 PROMPT is a prompt to show to the user. May not be NULL.
1533 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1534 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1535 file. *FUNC is set to a function that can be used to retrieve the
1536 selected file name from the returned widget.
1538 Returns the created widget. */
1541 xg_get_file_with_chooser (FRAME_PTR f
,
1543 char *default_filename
,
1544 int mustmatch_p
, int only_dir_p
,
1545 xg_get_file_func
*func
)
1549 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1550 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1551 GtkFileChooserAction action
= (mustmatch_p
?
1552 GTK_FILE_CHOOSER_ACTION_OPEN
:
1553 GTK_FILE_CHOOSER_ACTION_SAVE
);
1554 extern int x_gtk_show_hidden_files
;
1555 extern int x_gtk_file_dialog_help_text
;
1559 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1561 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1562 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1563 (mustmatch_p
|| only_dir_p
?
1564 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1567 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1569 wbox
= gtk_vbox_new (FALSE
, 0);
1570 gtk_widget_show (wbox
);
1571 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1573 if (x_gtk_show_hidden_files
)
1575 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1576 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1578 gtk_widget_show (wtoggle
);
1579 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1580 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1581 g_signal_connect (G_OBJECT (filewin
), "notify",
1582 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1584 if (x_gtk_file_dialog_help_text
)
1587 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1588 Show the C-l help text only for versions < 2.10. */
1589 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1590 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1591 strcat (message
, "\nIf you don't like this file selector, use the "
1592 "corresponding\nkey binding or customize "
1593 "use-file-dialog to turn it off.");
1595 wmessage
= gtk_label_new (message
);
1596 gtk_widget_show (wmessage
);
1599 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1600 if (x_gtk_file_dialog_help_text
)
1601 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1602 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1604 if (default_filename
)
1607 struct gcpro gcpro1
;
1608 char *utf8_filename
;
1611 file
= build_string (default_filename
);
1613 /* File chooser does not understand ~/... in the file name. It must be
1614 an absolute name starting with /. */
1615 if (default_filename
[0] != '/')
1616 file
= Fexpand_file_name (file
, Qnil
);
1618 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1619 if (! NILP (Ffile_directory_p (file
)))
1620 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1624 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1626 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1628 char *cp
= strrchr (utf8_filename
, '/');
1630 else cp
= utf8_filename
;
1631 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1638 *func
= xg_get_file_name_from_chooser
;
1642 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1644 /* Return the selected file for file selector dialog W.
1645 The returned string must be free:d. */
1648 xg_get_file_name_from_selector (GtkWidget
*w
)
1650 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1651 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1654 /* Create a file selection dialog.
1655 F is the current frame.
1656 PROMPT is a prompt to show to the user. May not be NULL.
1657 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1658 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1659 file. *FUNC is set to a function that can be used to retrieve the
1660 selected file name from the returned widget.
1662 Returns the created widget. */
1665 xg_get_file_with_selection (FRAME_PTR f
,
1667 char *default_filename
,
1668 int mustmatch_p
, int only_dir_p
,
1669 xg_get_file_func
*func
)
1672 GtkFileSelection
*filesel
;
1674 filewin
= gtk_file_selection_new (prompt
);
1675 filesel
= GTK_FILE_SELECTION (filewin
);
1677 if (default_filename
)
1678 gtk_file_selection_set_filename (filesel
, default_filename
);
1682 /* The selection_entry part of filesel is not documented. */
1683 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1684 gtk_file_selection_hide_fileop_buttons (filesel
);
1687 *func
= xg_get_file_name_from_selector
;
1691 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1693 /* Read a file name from the user using a file dialog, either the old
1694 file selection dialog, or the new file chooser dialog. Which to use
1695 depends on what the GTK version used has, and what the value of
1696 gtk-use-old-file-dialog.
1697 F is the current frame.
1698 PROMPT is a prompt to show to the user. May not be NULL.
1699 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1700 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1703 Returns a file name or NULL if no file was selected.
1704 The returned string must be freed by the caller. */
1707 xg_get_file_name (FRAME_PTR f
,
1709 char *default_filename
,
1715 int filesel_done
= 0;
1716 xg_get_file_func func
;
1718 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1719 /* I really don't know why this is needed, but without this the GLIBC add on
1720 library linuxthreads hangs when the Gnome file chooser backend creates
1722 sigblock (sigmask (__SIGRTMIN
));
1723 #endif /* HAVE_GTK_AND_PTHREAD */
1725 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1727 if (xg_uses_old_file_dialog ())
1728 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1729 mustmatch_p
, only_dir_p
, &func
);
1731 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1732 mustmatch_p
, only_dir_p
, &func
);
1734 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1735 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1736 mustmatch_p
, only_dir_p
, &func
);
1737 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1739 gtk_widget_set_name (w
, "emacs-filedialog");
1741 filesel_done
= xg_dialog_run (f
, w
);
1743 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1744 sigunblock (sigmask (__SIGRTMIN
));
1747 if (filesel_done
== GTK_RESPONSE_OK
)
1750 gtk_widget_destroy (w
);
1754 #ifdef HAVE_FREETYPE
1755 /* Pop up a GTK font selector and return the name of the font the user
1756 selects, as a C string. The returned font name follows GTK's own
1759 `FAMILY [VALUE1 VALUE2] SIZE'
1761 This can be parsed using font_parse_fcname in font.c.
1762 DEFAULT_NAME, if non-zero, is the default font name. */
1765 xg_get_font_name (FRAME_PTR f
, char *default_name
)
1768 char *fontname
= NULL
;
1771 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1772 sigblock (sigmask (__SIGRTMIN
));
1773 #endif /* HAVE_GTK_AND_PTHREAD */
1775 w
= gtk_font_selection_dialog_new ("Pick a font");
1777 default_name
= "Monospace 10";
1778 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1781 gtk_widget_set_name (w
, "emacs-fontdialog");
1783 done
= xg_dialog_run (f
, w
);
1785 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1786 sigunblock (sigmask (__SIGRTMIN
));
1789 if (done
== GTK_RESPONSE_OK
)
1790 fontname
= gtk_font_selection_dialog_get_font_name
1791 (GTK_FONT_SELECTION_DIALOG (w
));
1793 gtk_widget_destroy (w
);
1796 #endif /* HAVE_FREETYPE */
1800 /***********************************************************************
1802 ***********************************************************************/
1804 /* The name of menu items that can be used for customization. Since GTK
1805 RC files are very crude and primitive, we have to set this on all
1806 menu item names so a user can easily customize menu items. */
1808 #define MENU_ITEM_NAME "emacs-menuitem"
1811 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1812 during GC. The next member points to the items. */
1813 static xg_list_node xg_menu_cb_list
;
1815 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1816 during GC. The next member points to the items. */
1817 static xg_list_node xg_menu_item_cb_list
;
1819 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1820 F is the frame CL_DATA will be initialized for.
1821 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1823 The menu bar and all sub menus under the menu bar in a frame
1824 share the same structure, hence the reference count.
1826 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1827 allocated xg_menu_cb_data if CL_DATA is NULL. */
1829 static xg_menu_cb_data
*
1830 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
1834 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1836 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1837 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1838 cl_data
->highlight_cb
= highlight_cb
;
1839 cl_data
->ref_count
= 0;
1841 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1844 cl_data
->ref_count
++;
1849 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1850 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1852 When the menu bar is updated, menu items may have been added and/or
1853 removed, so menu_bar_vector and menu_bar_items_used change. We must
1854 then update CL_DATA since it is used to determine which menu
1855 item that is invoked in the menu.
1856 HIGHLIGHT_CB could change, there is no check that the same
1857 function is given when modifying a menu bar as was given when
1858 creating the menu bar. */
1861 update_cl_data (xg_menu_cb_data
*cl_data
,
1863 GCallback highlight_cb
)
1868 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1869 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1870 cl_data
->highlight_cb
= highlight_cb
;
1874 /* Decrease reference count for CL_DATA.
1875 If reference count is zero, free CL_DATA. */
1878 unref_cl_data (xg_menu_cb_data
*cl_data
)
1880 if (cl_data
&& cl_data
->ref_count
> 0)
1882 cl_data
->ref_count
--;
1883 if (cl_data
->ref_count
== 0)
1885 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1891 /* Function that marks all lisp data during GC. */
1898 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1899 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1901 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1903 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1905 if (! NILP (cb_data
->help
))
1906 mark_object (cb_data
->help
);
1911 /* Callback called when a menu item is destroyed. Used to free data.
1912 W is the widget that is being destroyed (not used).
1913 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1916 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
1920 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1921 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1926 /* Callback called when the pointer enters/leaves a menu item.
1927 W is the parent of the menu item.
1928 EVENT is either an enter event or leave event.
1929 CLIENT_DATA is not used.
1931 Returns FALSE to tell GTK to keep processing this event. */
1934 menuitem_highlight_callback (GtkWidget
*w
,
1935 GdkEventCrossing
*event
,
1936 gpointer client_data
)
1939 GtkWidget
*subwidget
;
1940 xg_menu_item_cb_data
*data
;
1942 ev
.crossing
= *event
;
1943 subwidget
= gtk_get_event_widget (&ev
);
1944 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
1948 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1950 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
1951 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1952 (*func
) (subwidget
, call_data
);
1959 /* Callback called when a menu is destroyed. Used to free data.
1960 W is the widget that is being destroyed (not used).
1961 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1964 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
1966 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1969 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1970 must be non-NULL) and can be inserted into a menu item.
1972 Returns the GtkHBox. */
1975 make_widget_for_menu_item (char *utf8_label
, char *utf8_key
)
1981 wbox
= gtk_hbox_new (FALSE
, 0);
1982 wlbl
= gtk_label_new (utf8_label
);
1983 wkey
= gtk_label_new (utf8_key
);
1985 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1986 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1988 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1989 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1991 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1992 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1993 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1998 /* Make and return a menu item widget with the key to the right.
1999 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2000 UTF8_KEY is the text representing the key binding.
2001 ITEM is the widget_value describing the menu item.
2003 GROUP is an in/out parameter. If the menu item to be created is not
2004 part of any radio menu group, *GROUP contains NULL on entry and exit.
2005 If the menu item to be created is part of a radio menu group, on entry
2006 *GROUP contains the group to use, or NULL if this is the first item
2007 in the group. On exit, *GROUP contains the radio item group.
2009 Unfortunately, keys don't line up as nicely as in Motif,
2010 but the MacOS X version doesn't either, so I guess that is OK. */
2013 make_menu_item (char *utf8_label
,
2019 GtkWidget
*wtoadd
= 0;
2021 /* It has been observed that some menu items have a NULL name field.
2022 This will lead to this function being called with a NULL utf8_label.
2023 GTK crashes on that so we set a blank label. Why there is a NULL
2024 name remains to be investigated. */
2025 if (! utf8_label
) utf8_label
= " ";
2028 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2030 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2033 if (utf8_key
) w
= gtk_check_menu_item_new ();
2034 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2035 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2037 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2039 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2040 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2041 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2043 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2048 if (utf8_key
) w
= gtk_menu_item_new ();
2049 else w
= gtk_menu_item_new_with_label (utf8_label
);
2052 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2053 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2058 /* Return non-zero if LABEL specifies a separator (GTK only has one
2061 static const char* separator_names
[] = {
2066 "single-dashed-line",
2067 "double-dashed-line",
2069 "shadow-etched-out",
2070 "shadow-etched-in-dash",
2071 "shadow-etched-out-dash",
2072 "shadow-double-etched-in",
2073 "shadow-double-etched-out",
2074 "shadow-double-etched-in-dash",
2075 "shadow-double-etched-out-dash",
2080 xg_separator_p (char *label
)
2082 if (! label
) return 0;
2083 else if (strlen (label
) > 3
2084 && strncmp (label
, "--", 2) == 0
2090 for (i
= 0; separator_names
[i
]; ++i
)
2091 if (strcmp (label
, separator_names
[i
]) == 0)
2096 /* Old-style separator, maybe. It's a separator if it contains
2098 while (*label
== '-')
2100 if (*label
== 0) return 1;
2106 static int xg_detached_menus
;
2108 /* Returns non-zero if there are detached menus. */
2111 xg_have_tear_offs (void)
2113 return xg_detached_menus
> 0;
2116 /* Callback invoked when a detached menu window is removed. Here we
2117 decrease the xg_detached_menus count.
2118 WIDGET is the top level window that is removed (the parent of the menu).
2119 CLIENT_DATA is not used. */
2122 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2124 if (xg_detached_menus
> 0) --xg_detached_menus
;
2127 /* Callback invoked when a menu is detached. It increases the
2128 xg_detached_menus count.
2129 WIDGET is the GtkTearoffMenuItem.
2130 CLIENT_DATA is not used. */
2133 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2135 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2136 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2138 ++xg_detached_menus
;
2139 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2141 G_CALLBACK (tearoff_remove
), 0);
2146 /* Create a menu item widget, and connect the callbacks.
2147 ITEM decribes the menu item.
2148 F is the frame the created menu belongs to.
2149 SELECT_CB is the callback to use when a menu item is selected.
2150 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2151 CL_DATA points to the callback data to be used for this menu.
2152 GROUP is an in/out parameter. If the menu item to be created is not
2153 part of any radio menu group, *GROUP contains NULL on entry and exit.
2154 If the menu item to be created is part of a radio menu group, on entry
2155 *GROUP contains the group to use, or NULL if this is the first item
2156 in the group. On exit, *GROUP contains the radio item group.
2158 Returns the created GtkWidget. */
2161 xg_create_one_menuitem (widget_value
*item
,
2163 GCallback select_cb
,
2164 GCallback highlight_cb
,
2165 xg_menu_cb_data
*cl_data
,
2171 xg_menu_item_cb_data
*cb_data
;
2173 utf8_label
= get_utf8_string (item
->name
);
2174 utf8_key
= get_utf8_string (item
->key
);
2176 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2178 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2179 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
2181 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2183 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2185 cb_data
->select_id
= 0;
2186 cb_data
->help
= item
->help
;
2187 cb_data
->cl_data
= cl_data
;
2188 cb_data
->call_data
= item
->call_data
;
2190 g_signal_connect (G_OBJECT (w
),
2192 G_CALLBACK (menuitem_destroy_callback
),
2195 /* Put cb_data in widget, so we can get at it when modifying menubar */
2196 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2198 /* final item, not a submenu */
2199 if (item
->call_data
&& ! item
->contents
)
2203 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2209 /* Create a full menu tree specified by DATA.
2210 F is the frame the created menu belongs to.
2211 SELECT_CB is the callback to use when a menu item is selected.
2212 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2213 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2214 POP_UP_P is non-zero if we shall create a popup menu.
2215 MENU_BAR_P is non-zero if we shall create a menu bar.
2216 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2217 if MENU_BAR_P is non-zero.
2218 TOPMENU is the topmost GtkWidget that others shall be placed under.
2219 It may be NULL, in that case we create the appropriate widget
2220 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2221 CL_DATA is the callback data we shall use for this menu, or NULL
2222 if we haven't set the first callback yet.
2223 NAME is the name to give to the top level menu if this function
2224 creates it. May be NULL to not set any name.
2226 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2229 This function calls itself to create submenus. */
2232 create_menus (widget_value
*data
,
2234 GCallback select_cb
,
2235 GCallback deactivate_cb
,
2236 GCallback highlight_cb
,
2241 xg_menu_cb_data
*cl_data
,
2245 GtkWidget
*wmenu
= topmenu
;
2246 GSList
*group
= NULL
;
2252 wmenu
= gtk_menu_new ();
2253 xg_set_screen (wmenu
, f
);
2254 /* Connect this to the menu instead of items so we get enter/leave for
2255 disabled items also. TODO: Still does not get enter/leave for
2256 disabled items in detached menus. */
2257 g_signal_connect (G_OBJECT (wmenu
),
2258 "enter-notify-event",
2259 G_CALLBACK (menuitem_highlight_callback
),
2261 g_signal_connect (G_OBJECT (wmenu
),
2262 "leave-notify-event",
2263 G_CALLBACK (menuitem_highlight_callback
),
2268 wmenu
= gtk_menu_bar_new ();
2269 /* Set width of menu bar to a small value so it doesn't enlarge
2270 a small initial frame size. The width will be set to the
2271 width of the frame later on when it is added to a container.
2272 height -1: Natural height. */
2273 gtk_widget_set_size_request (wmenu
, 1, -1);
2276 /* Put cl_data on the top menu for easier access. */
2277 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2278 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2279 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2280 G_CALLBACK (menu_destroy_callback
), cl_data
);
2283 gtk_widget_set_name (wmenu
, name
);
2286 g_signal_connect (G_OBJECT (wmenu
),
2287 "selection-done", deactivate_cb
, 0);
2290 if (! menu_bar_p
&& add_tearoff_p
)
2292 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2293 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2295 g_signal_connect (G_OBJECT (tearoff
), "activate",
2296 G_CALLBACK (tearoff_activate
), 0);
2299 for (item
= data
; item
; item
= item
->next
)
2303 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2304 && !xg_separator_p (item
->name
))
2307 /* A title for a popup. We do the same as GTK does when
2308 creating titles, but it does not look good. */
2310 utf8_label
= get_utf8_string (item
->name
);
2312 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2313 w
= gtk_menu_item_new_with_label (utf8_label
);
2314 gtk_widget_set_sensitive (w
, FALSE
);
2315 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2317 else if (xg_separator_p (item
->name
))
2320 /* GTK only have one separator type. */
2321 w
= gtk_separator_menu_item_new ();
2325 w
= xg_create_one_menuitem (item
,
2327 item
->contents
? 0 : select_cb
,
2332 /* Create a possibly empty submenu for menu bar items, since some
2333 themes don't highlight items correctly without it. */
2334 if (item
->contents
|| menu_bar_p
)
2336 GtkWidget
*submenu
= create_menus (item
->contents
,
2347 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2351 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2352 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2358 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2359 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2360 with some text and buttons.
2361 F is the frame the created item belongs to.
2362 NAME is the name to use for the top widget.
2363 VAL is a widget_value structure describing items to be created.
2364 SELECT_CB is the callback to use when a menu item is selected or
2365 a dialog button is pressed.
2366 DEACTIVATE_CB is the callback to use when an item is deactivated.
2367 For a menu, when a sub menu is not shown anymore, for a dialog it is
2368 called when the dialog is popped down.
2369 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2371 Returns the widget created. */
2374 xg_create_widget (char *type
, char *name
, FRAME_PTR f
, widget_value
*val
,
2375 GCallback select_cb
, GCallback deactivate_cb
,
2376 GCallback highlight_cb
)
2379 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2380 int pop_up_p
= strcmp (type
, "popup") == 0;
2382 if (strcmp (type
, "dialog") == 0)
2384 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2385 xg_set_screen (w
, f
);
2386 gtk_window_set_transient_for (GTK_WINDOW (w
),
2387 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2388 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2389 gtk_widget_set_name (w
, "emacs-dialog");
2390 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2392 else if (menu_bar_p
|| pop_up_p
)
2394 w
= create_menus (val
->contents
,
2406 /* Set the cursor to an arrow for popup menus when they are mapped.
2407 This is done by default for menu bar menus. */
2410 /* Must realize so the GdkWindow inside the widget is created. */
2411 gtk_widget_realize (w
);
2412 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2417 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2424 /* Return the label for menu item WITEM. */
2427 xg_get_menu_item_label (GtkMenuItem
*witem
)
2429 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2430 return gtk_label_get_label (wlabel
);
2433 /* Return non-zero if the menu item WITEM has the text LABEL. */
2436 xg_item_label_same_p (GtkMenuItem
*witem
, char *label
)
2439 char *utf8_label
= get_utf8_string (label
);
2440 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2442 if (! old_label
&& ! utf8_label
)
2444 else if (old_label
&& utf8_label
)
2445 is_same
= strcmp (utf8_label
, old_label
) == 0;
2447 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2452 /* Destroy widgets in LIST. */
2455 xg_destroy_widgets (GList
*list
)
2459 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2461 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2463 /* Destroying the widget will remove it from the container it is in. */
2464 gtk_widget_destroy (w
);
2468 /* Update the top level names in MENUBAR (i.e. not submenus).
2469 F is the frame the menu bar belongs to.
2470 *LIST is a list with the current menu bar names (menu item widgets).
2471 ITER is the item within *LIST that shall be updated.
2472 POS is the numerical position, starting at 0, of ITER in *LIST.
2473 VAL describes what the menu bar shall look like after the update.
2474 SELECT_CB is the callback to use when a menu item is selected.
2475 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2476 CL_DATA points to the callback data to be used for this menu bar.
2478 This function calls itself to walk through the menu bar names. */
2481 xg_update_menubar (GtkWidget
*menubar
,
2487 GCallback select_cb
,
2488 GCallback deactivate_cb
,
2489 GCallback highlight_cb
,
2490 xg_menu_cb_data
*cl_data
)
2492 if (! iter
&& ! val
)
2494 else if (iter
&& ! val
)
2496 /* Item(s) have been removed. Remove all remaining items. */
2497 xg_destroy_widgets (iter
);
2499 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2500 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2501 gtk_menu_item_new_with_label (""),
2507 else if (! iter
&& val
)
2509 /* Item(s) added. Add all new items in one call. */
2510 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2511 0, 1, 0, menubar
, cl_data
, 0);
2517 /* Below this neither iter or val is NULL */
2518 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2520 /* This item is still the same, check next item. */
2522 iter
= g_list_next (iter
);
2525 else /* This item is changed. */
2527 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2528 GtkMenuItem
*witem2
= 0;
2529 int val_in_menubar
= 0;
2530 int iter_in_new_menubar
= 0;
2534 /* See if the changed entry (val) is present later in the menu bar */
2536 iter2
&& ! val_in_menubar
;
2537 iter2
= g_list_next (iter2
))
2539 witem2
= GTK_MENU_ITEM (iter2
->data
);
2540 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2543 /* See if the current entry (iter) is present later in the
2544 specification for the new menu bar. */
2545 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2546 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2548 if (val_in_menubar
&& ! iter_in_new_menubar
)
2552 /* This corresponds to:
2557 g_object_ref (G_OBJECT (witem
));
2558 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2559 gtk_widget_destroy (GTK_WIDGET (witem
));
2561 /* Must get new list since the old changed. */
2562 g_list_free (*list
);
2563 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2564 while (nr
-- > 0) iter
= g_list_next (iter
);
2566 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2568 /* This corresponds to:
2571 Rename B to X. This might seem to be a strange thing to do,
2572 since if there is a menu under B it will be totally wrong for X.
2573 But consider editing a C file. Then there is a C-mode menu
2574 (corresponds to B above).
2575 If then doing C-x C-f the minibuf menu (X above) replaces the
2576 C-mode menu. When returning from the minibuffer, we get
2577 back the C-mode menu. Thus we do:
2578 Rename B to X (C-mode to minibuf menu)
2579 Rename X to B (minibuf to C-mode menu).
2580 If the X menu hasn't been invoked, the menu under B
2581 is up to date when leaving the minibuffer. */
2582 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2583 char *utf8_label
= get_utf8_string (val
->name
);
2584 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2586 gtk_label_set_text (wlabel
, utf8_label
);
2588 /* If this item has a submenu that has been detached, change
2589 the title in the WM decorations also. */
2590 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2591 /* Set the title of the detached window. */
2592 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2594 iter
= g_list_next (iter
);
2598 else if (! val_in_menubar
&& iter_in_new_menubar
)
2600 /* This corresponds to:
2607 GtkWidget
*w
= xg_create_one_menuitem (val
,
2614 /* Create a possibly empty submenu for menu bar items, since some
2615 themes don't highlight items correctly without it. */
2616 GtkWidget
*submenu
= create_menus (NULL
, f
,
2617 select_cb
, deactivate_cb
,
2619 0, 0, 0, 0, cl_data
, 0);
2620 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2621 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2622 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2624 g_list_free (*list
);
2625 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2626 while (nr
-- > 0) iter
= g_list_next (iter
);
2627 iter
= g_list_next (iter
);
2631 else /* if (val_in_menubar && iter_in_new_menubar) */
2634 /* This corresponds to:
2639 g_object_ref (G_OBJECT (witem2
));
2640 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2641 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2642 GTK_WIDGET (witem2
), pos
);
2643 g_object_unref (G_OBJECT (witem2
));
2645 g_list_free (*list
);
2646 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2647 while (nr
-- > 0) iter
= g_list_next (iter
);
2648 if (iter
) iter
= g_list_next (iter
);
2654 /* Update the rest of the menu bar. */
2655 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2656 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2659 /* Update the menu item W so it corresponds to VAL.
2660 SELECT_CB is the callback to use when a menu item is selected.
2661 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2662 CL_DATA is the data to set in the widget for menu invocation. */
2665 xg_update_menu_item (widget_value
*val
,
2667 GCallback select_cb
,
2668 GCallback highlight_cb
,
2669 xg_menu_cb_data
*cl_data
)
2676 const char *old_label
= 0;
2677 const char *old_key
= 0;
2678 xg_menu_item_cb_data
*cb_data
;
2680 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2681 utf8_label
= get_utf8_string (val
->name
);
2682 utf8_key
= get_utf8_string (val
->key
);
2684 /* See if W is a menu item with a key. See make_menu_item above. */
2685 if (GTK_IS_HBOX (wchild
))
2687 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2689 wlbl
= GTK_LABEL (list
->data
);
2690 wkey
= GTK_LABEL (list
->next
->data
);
2695 /* Remove the key and keep just the label. */
2696 g_object_ref (G_OBJECT (wlbl
));
2697 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2698 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2699 g_object_unref (G_OBJECT (wlbl
));
2704 else /* Just a label. */
2706 wlbl
= GTK_LABEL (wchild
);
2708 /* Check if there is now a key. */
2711 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2712 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2714 wlbl
= GTK_LABEL (list
->data
);
2715 wkey
= GTK_LABEL (list
->next
->data
);
2718 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2719 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2724 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2725 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2727 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2728 gtk_label_set_text (wkey
, utf8_key
);
2730 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2731 gtk_label_set_text (wlbl
, utf8_label
);
2733 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2734 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2736 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2737 gtk_widget_set_sensitive (w
, FALSE
);
2738 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2739 gtk_widget_set_sensitive (w
, TRUE
);
2741 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2745 cb_data
->call_data
= val
->call_data
;
2746 cb_data
->help
= val
->help
;
2747 cb_data
->cl_data
= cl_data
;
2749 /* We assume the callback functions don't change. */
2750 if (val
->call_data
&& ! val
->contents
)
2752 /* This item shall have a select callback. */
2753 if (! cb_data
->select_id
)
2755 = g_signal_connect (G_OBJECT (w
), "activate",
2756 select_cb
, cb_data
);
2758 else if (cb_data
->select_id
)
2760 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2761 cb_data
->select_id
= 0;
2766 /* Update the toggle menu item W so it corresponds to VAL. */
2769 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
2771 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2774 /* Update the radio menu item W so it corresponds to VAL. */
2777 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
2779 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2782 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2783 SUBMENU may be NULL, in that case a new menu is created.
2784 F is the frame the menu bar belongs to.
2785 VAL describes the contents of the menu bar.
2786 SELECT_CB is the callback to use when a menu item is selected.
2787 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2788 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2789 CL_DATA is the call back data to use for any newly created items.
2791 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2795 xg_update_submenu (GtkWidget
*submenu
,
2798 GCallback select_cb
,
2799 GCallback deactivate_cb
,
2800 GCallback highlight_cb
,
2801 xg_menu_cb_data
*cl_data
)
2803 GtkWidget
*newsub
= submenu
;
2807 int has_tearoff_p
= 0;
2808 GList
*first_radio
= 0;
2811 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2813 for (cur
= val
, iter
= list
;
2815 iter
= g_list_next (iter
), cur
= cur
->next
)
2817 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2819 /* Skip tearoff items, they have no counterpart in val. */
2820 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2823 iter
= g_list_next (iter
);
2824 if (iter
) w
= GTK_WIDGET (iter
->data
);
2828 /* Remember first radio button in a group. If we get a mismatch in
2829 a radio group we must rebuild the whole group so that the connections
2830 in GTK becomes correct. */
2831 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2833 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2834 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2837 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2839 if (! xg_separator_p (cur
->name
))
2842 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2844 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2846 xg_update_toggle_item (cur
, w
);
2847 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2849 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2851 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2853 xg_update_radio_item (cur
, w
);
2854 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2856 else if (GTK_IS_MENU_ITEM (w
))
2858 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2861 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2862 xg_separator_p (cur
->name
))
2865 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2867 sub
= gtk_menu_item_get_submenu (witem
);
2868 if (sub
&& ! cur
->contents
)
2870 /* Not a submenu anymore. */
2871 g_object_ref (G_OBJECT (sub
));
2872 remove_submenu (witem
);
2873 gtk_widget_destroy (sub
);
2875 else if (cur
->contents
)
2879 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2880 select_cb
, deactivate_cb
,
2881 highlight_cb
, cl_data
);
2883 /* If this item just became a submenu, we must set it. */
2885 gtk_menu_item_set_submenu (witem
, nsub
);
2890 /* Structural difference. Remove everything from here and down
2896 /* Remove widgets from first structual change. */
2899 /* If we are adding new menu items below, we must remove from
2900 first radio button so that radio groups become correct. */
2901 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2902 else xg_destroy_widgets (iter
);
2907 /* More items added. Create them. */
2908 newsub
= create_menus (cur
,
2921 if (list
) g_list_free (list
);
2926 /* Update the MENUBAR.
2927 F is the frame the menu bar belongs to.
2928 VAL describes the contents of the menu bar.
2929 If DEEP_P is non-zero, rebuild all but the top level menu names in
2930 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2931 SELECT_CB is the callback to use when a menu item is selected.
2932 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2933 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2936 xg_modify_menubar_widgets (GtkWidget
*menubar
, FRAME_PTR f
, widget_value
*val
,
2938 GCallback select_cb
, GCallback deactivate_cb
,
2939 GCallback highlight_cb
)
2941 xg_menu_cb_data
*cl_data
;
2942 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2946 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2949 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2950 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2956 /* Update all sub menus.
2957 We must keep the submenus (GTK menu item widgets) since the
2958 X Window in the XEvent that activates the menu are those widgets. */
2960 /* Update cl_data, menu_item things in F may have changed. */
2961 update_cl_data (cl_data
, f
, highlight_cb
);
2963 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2968 GtkMenuItem
*witem
= 0;
2970 /* Find sub menu that corresponds to val and update it. */
2971 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2973 witem
= GTK_MENU_ITEM (iter
->data
);
2974 if (xg_item_label_same_p (witem
, cur
->name
))
2976 sub
= gtk_menu_item_get_submenu (witem
);
2981 newsub
= xg_update_submenu (sub
,
2988 /* sub may still be NULL. If we just updated non deep and added
2989 a new menu bar item, it has no sub menu yet. So we set the
2990 newly created sub menu under witem. */
2991 if (newsub
!= sub
&& witem
!= 0)
2993 xg_set_screen (newsub
, f
);
2994 gtk_menu_item_set_submenu (witem
, newsub
);
3000 gtk_widget_show_all (menubar
);
3003 /* Recompute all the widgets of frame F, when the menu bar has been
3004 changed. Value is non-zero if widgets were updated. */
3007 xg_update_frame_menubar (FRAME_PTR f
)
3009 struct x_output
*x
= f
->output_data
.x
;
3012 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3015 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3016 return 0; /* Already done this, happens for frames created invisible. */
3020 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3022 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3024 gtk_widget_show_all (x
->menubar_widget
);
3025 gtk_widget_size_request (x
->menubar_widget
, &req
);
3026 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3027 xg_height_or_width_changed (f
);
3033 /* Get rid of the menu bar of frame F, and free its storage.
3034 This is used when deleting a frame, and when turning off the menu bar. */
3037 free_frame_menubar (FRAME_PTR f
)
3039 struct x_output
*x
= f
->output_data
.x
;
3041 if (x
->menubar_widget
)
3045 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3046 /* The menubar and its children shall be deleted when removed from
3048 x
->menubar_widget
= 0;
3049 FRAME_MENUBAR_HEIGHT (f
) = 0;
3050 xg_height_or_width_changed (f
);
3056 xg_event_is_for_menubar (FRAME_PTR f
, XEvent
*event
)
3058 struct x_output
*x
= f
->output_data
.x
;
3067 if (! x
->menubar_widget
) return 0;
3069 if (! (event
->xbutton
.x
>= 0
3070 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3071 && event
->xbutton
.y
>= 0
3072 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3073 && event
->xbutton
.same_screen
))
3076 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3077 gw
= gdk_xid_table_lookup_for_display (gdpy
, event
->xbutton
.window
);
3079 gevent
.any
.window
= gw
;
3080 gwdesc
= gtk_get_event_widget (&gevent
);
3081 if (! gwdesc
) return 0;
3082 if (! GTK_IS_MENU_BAR (gwdesc
)
3083 && ! GTK_IS_MENU_ITEM (gwdesc
)
3084 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3087 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3088 if (! list
) return 0;
3089 rec
.x
= event
->xbutton
.x
;
3090 rec
.y
= event
->xbutton
.y
;
3094 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3096 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3097 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3101 return iter
== 0 ? 0 : 1;
3106 /***********************************************************************
3107 Scroll bar functions
3108 ***********************************************************************/
3111 /* Setting scroll bar values invokes the callback. Use this variable
3112 to indicate that callback should do nothing. */
3114 int xg_ignore_gtk_scrollbar
;
3116 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3117 may be larger than 32 bits. Keep a mapping from integer index to widget
3118 pointers to get around the 32 bit limitation. */
3122 GtkWidget
**widgets
;
3127 /* Grow this much every time we need to allocate more */
3129 #define ID_TO_WIDGET_INCR 32
3131 /* Store the widget pointer W in id_to_widget and return the integer index. */
3134 xg_store_widget_in_map (GtkWidget
*w
)
3138 if (id_to_widget
.max_size
== id_to_widget
.used
)
3140 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3142 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
3143 sizeof (GtkWidget
*)*new_size
);
3145 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3146 id_to_widget
.widgets
[i
] = 0;
3147 id_to_widget
.max_size
= new_size
;
3150 /* Just loop over the array and find a free place. After all,
3151 how many scroll bars are we creating? Should be a small number.
3152 The check above guarantees we will find a free place. */
3153 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3155 if (! id_to_widget
.widgets
[i
])
3157 id_to_widget
.widgets
[i
] = w
;
3158 ++id_to_widget
.used
;
3164 /* Should never end up here */
3168 /* Remove pointer at IDX from id_to_widget.
3169 Called when scroll bar is destroyed. */
3172 xg_remove_widget_from_map (int idx
)
3174 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3176 id_to_widget
.widgets
[idx
] = 0;
3177 --id_to_widget
.used
;
3181 /* Get the widget pointer at IDX from id_to_widget. */
3184 xg_get_widget_from_map (int idx
)
3186 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3187 return id_to_widget
.widgets
[idx
];
3192 /* Return the scrollbar id for X Window WID on display DPY.
3193 Return -1 if WID not in id_to_widget. */
3196 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3201 w
= xg_win_to_widget (dpy
, wid
);
3205 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3206 if (id_to_widget
.widgets
[idx
] == w
)
3213 /* Callback invoked when scroll bar WIDGET is destroyed.
3214 DATA is the index into id_to_widget for WIDGET.
3215 We free pointer to last scroll bar values here and remove the index. */
3218 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3220 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
3221 xg_remove_widget_from_map (id
);
3224 /* Create a scroll bar widget for frame F. Store the scroll bar
3226 SCROLL_CALLBACK is the callback to invoke when the value of the
3228 END_CALLBACK is the callback to invoke when scrolling ends.
3229 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3230 to set resources for the widget. */
3233 xg_create_scroll_bar (FRAME_PTR f
,
3234 struct scroll_bar
*bar
,
3235 GCallback scroll_callback
,
3236 GCallback end_callback
,
3237 char *scroll_bar_name
)
3244 /* Page, step increment values are not so important here, they
3245 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3246 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3249 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3250 webox
= gtk_event_box_new ();
3251 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3252 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3253 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3255 scroll_id
= xg_store_widget_in_map (wscroll
);
3257 /* The EMACS_INT cast avoids a warning. */
3258 g_signal_connect (G_OBJECT (wscroll
),
3260 G_CALLBACK (xg_gtk_scroll_destroy
),
3261 (gpointer
) (EMACS_INT
) scroll_id
);
3262 g_signal_connect (G_OBJECT (wscroll
),
3266 g_signal_connect (G_OBJECT (wscroll
),
3267 "button-release-event",
3271 /* The scroll bar widget does not draw on a window of its own. Instead
3272 it draws on the parent window, in this case the edit widget. So
3273 whenever the edit widget is cleared, the scroll bar needs to redraw
3274 also, which causes flicker. Put an event box between the edit widget
3275 and the scroll bar, so the scroll bar instead draws itself on the
3276 event box window. */
3277 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3278 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3281 /* Set the cursor to an arrow. */
3282 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3284 bar
->x_window
= scroll_id
;
3287 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3290 xg_remove_scroll_bar (FRAME_PTR f
, int scrollbar_id
)
3292 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3295 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3296 gtk_widget_destroy (w
);
3297 gtk_widget_destroy (wparent
);
3298 SET_FRAME_GARBAGED (f
);
3302 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3304 TOP/LEFT are the new pixel positions where the bar shall appear.
3305 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3308 xg_update_scrollbar_pos (FRAME_PTR f
,
3316 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3320 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3321 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3324 /* Clear out old position. */
3325 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3326 if (gtk_widget_get_parent (wparent
) == wfixed
)
3328 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3329 "x", &oldx
, "y", &oldy
, NULL
);
3330 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3333 /* Move and resize to new values. */
3334 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3335 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3338 /* No room. Hide scroll bar as some themes output a warning if
3339 the height is less than the min size. */
3340 gtk_widget_hide (wparent
);
3341 gtk_widget_hide (wscroll
);
3345 gtk_widget_show_all (wparent
);
3346 gtk_widget_set_size_request (wscroll
, width
, height
);
3348 gtk_widget_queue_draw (wfixed
);
3349 gdk_window_process_all_updates ();
3350 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3352 /* Clear under old scroll bar position. This must be done after
3353 the gtk_widget_queue_draw and gdk_window_process_all_updates
3355 x_clear_area (FRAME_X_DISPLAY (f
),
3357 oldx
, oldy
, oldw
, oldh
, 0);
3360 /* GTK does not redraw until the main loop is entered again, but
3361 if there are no X events pending we will not enter it. So we sync
3362 here to get some events. */
3365 SET_FRAME_GARBAGED (f
);
3366 cancel_mouse_face (f
);
3370 /* Set the thumb size and position of scroll bar BAR. We are currently
3371 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3374 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3379 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3381 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3383 if (wscroll
&& NILP (bar
->dragging
))
3392 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3394 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3395 rather than the real portion value. This makes the thumb less likely
3396 to resize and that looks better. */
3397 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3398 /* When the thumb is at the bottom, position == whole.
3399 So we need to increase `whole' to make space for the thumb. */
3406 top
= (gdouble
) position
/ whole
;
3407 shown
= (gdouble
) portion
/ whole
;
3410 size
= shown
* XG_SB_RANGE
;
3411 size
= min (size
, XG_SB_RANGE
);
3412 size
= max (size
, 1);
3414 value
= top
* XG_SB_RANGE
;
3415 value
= min (value
, XG_SB_MAX
- size
);
3416 value
= max (value
, XG_SB_MIN
);
3418 /* Assume all lines are of equal size. */
3419 new_step
= size
/ max (1, FRAME_LINES (f
));
3421 if ((int) gtk_adjustment_get_page_size (adj
) != size
3422 || (int) gtk_adjustment_get_step_increment (adj
) != new_step
)
3424 gtk_adjustment_set_page_size (adj
, size
);
3425 gtk_adjustment_set_step_increment (adj
, new_step
);
3426 /* Assume a page increment is about 95% of the page size */
3427 gtk_adjustment_set_page_increment (adj
,(int) (0.95*size
));
3431 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3435 /* gtk_range_set_value invokes the callback. Set
3436 ignore_gtk_scrollbar to make the callback do nothing */
3437 xg_ignore_gtk_scrollbar
= 1;
3439 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3440 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3442 gtk_adjustment_changed (adj
);
3444 xg_ignore_gtk_scrollbar
= 0;
3451 /* Return non-zero if EVENT is for a scroll bar in frame F.
3452 When the same X window is used for several Gtk+ widgets, we cannot
3453 say for sure based on the X window alone if an event is for the
3454 frame. This function does additional checks.
3456 Return non-zero if the event is for a scroll bar, zero otherwise. */
3459 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3463 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3465 /* Check if press occurred outside the edit widget. */
3466 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3467 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3468 != gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3471 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3472 || event
->type
== MotionNotify
))
3474 /* If we are releasing or moving the scroll bar, it has the grab. */
3475 GtkWidget
*w
= gtk_grab_get_current ();
3476 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3484 /***********************************************************************
3486 ***********************************************************************/
3487 /* The key for the data we put in the GtkImage widgets. The data is
3488 the image used by Emacs. We use this to see if we need to update
3489 the GtkImage with a new image. */
3490 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3492 /* The key for storing the latest modifiers so the activate callback can
3494 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3496 /* The key for storing the button widget in its proxy menu item. */
3497 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3499 /* The key for the data we put in the GtkImage widgets. The data is
3500 the stock name used by Emacs. We use this to see if we need to update
3501 the GtkImage with a new image. */
3502 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3504 /* As above, but this is used for named theme widgets, as opposed to
3506 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3508 /* Callback function invoked when a tool bar item is pressed.
3509 W is the button widget in the tool bar that got pressed,
3510 CLIENT_DATA is an integer that is the index of the button in the
3511 tool bar. 0 is the first button. */
3514 xg_tool_bar_button_cb (GtkWidget
*widget
,
3515 GdkEventButton
*event
,
3518 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3519 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3520 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3525 /* Callback function invoked when a tool bar item is pressed.
3526 W is the button widget in the tool bar that got pressed,
3527 CLIENT_DATA is an integer that is the index of the button in the
3528 tool bar. 0 is the first button. */
3531 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3533 /* The EMACS_INT cast avoids a warning. */
3534 int idx
= (int) (EMACS_INT
) client_data
;
3535 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3536 XG_TOOL_BAR_LAST_MODIFIER
);
3538 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3539 Lisp_Object key
, frame
;
3540 struct input_event event
;
3543 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3546 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3548 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3549 XSETFRAME (frame
, f
);
3551 /* We generate two events here. The first one is to set the prefix
3552 to `(tool_bar)', see keyboard.c. */
3553 event
.kind
= TOOL_BAR_EVENT
;
3554 event
.frame_or_window
= frame
;
3556 kbd_buffer_store_event (&event
);
3558 event
.kind
= TOOL_BAR_EVENT
;
3559 event
.frame_or_window
= frame
;
3561 /* Convert between the modifier bits GDK uses and the modifier bits
3562 Emacs uses. This assumes GDK and X masks are the same, which they are when
3564 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3565 kbd_buffer_store_event (&event
);
3567 /* Return focus to the frame after we have clicked on a detached
3569 Fx_focus_frame (frame
);
3572 /* Callback function invoked when a tool bar item is pressed in a detached
3573 tool bar or the overflow drop down menu.
3574 We just call xg_tool_bar_callback.
3575 W is the menu item widget that got pressed,
3576 CLIENT_DATA is an integer that is the index of the button in the
3577 tool bar. 0 is the first button. */
3580 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3582 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3583 XG_TOOL_BAR_PROXY_BUTTON
));
3584 xg_tool_bar_callback (wbutton
, client_data
);
3589 xg_tool_bar_help_callback (GtkWidget
*w
,
3590 GdkEventCrossing
*event
,
3591 gpointer client_data
);
3593 /* This callback is called when a help is to be shown for an item in
3594 the detached tool bar when the detached tool bar it is not expanded. */
3597 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3598 GdkEventCrossing
*event
,
3599 gpointer client_data
)
3601 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3602 XG_TOOL_BAR_PROXY_BUTTON
));
3604 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3608 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3610 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3611 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3612 GtkWidget
*c2
= (GtkWidget
*) clist
->next
->data
;
3613 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3614 g_list_free (clist
);
3615 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3619 /* This callback is called when a tool item should create a proxy item,
3620 such as for the overflow menu. Also called when the tool bar is detached.
3621 If we don't create a proxy menu item, the detached tool bar will be
3625 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3627 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (toolitem
));
3628 GtkButton
*wbutton
= GTK_BUTTON (gtk_bin_get_child (GTK_BIN (weventbox
)));
3629 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
3631 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3632 GtkImage
*wimage
= GTK_IMAGE (c1
);
3633 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3634 (gtk_label_get_text (wlbl
));
3635 GtkWidget
*wmenuimage
;
3638 if (gtk_button_get_use_stock (wbutton
))
3639 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3640 GTK_ICON_SIZE_MENU
);
3643 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3644 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3646 if (store_type
== GTK_IMAGE_STOCK
)
3649 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3650 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3652 else if (store_type
== GTK_IMAGE_ICON_SET
)
3654 GtkIconSet
*icon_set
;
3655 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3656 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3657 GTK_ICON_SIZE_MENU
);
3659 else if (store_type
== GTK_IMAGE_PIXBUF
)
3664 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3667 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3669 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3670 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3671 GDK_INTERP_BILINEAR
);
3673 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3677 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3681 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3683 const gchar
*icon_name
;
3684 GtkIconSize icon_size
;
3686 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3687 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3688 GTK_ICON_SIZE_MENU
);
3692 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3697 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3699 g_signal_connect (G_OBJECT (wmenuitem
),
3701 G_CALLBACK (xg_tool_bar_proxy_callback
),
3705 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3706 (gpointer
) wbutton
);
3707 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3708 gtk_widget_set_sensitive (wmenuitem
,
3709 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
3711 /* Use enter/leave notify to show help. We use the events
3712 rather than the GtkButton specific signals "enter" and
3713 "leave", so we can have only one callback. The event
3714 will tell us what kind of event it is. */
3715 g_signal_connect (G_OBJECT (wmenuitem
),
3716 "enter-notify-event",
3717 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3719 g_signal_connect (G_OBJECT (wmenuitem
),
3720 "leave-notify-event",
3721 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3727 /* This callback is called when a tool bar is detached. We must set
3728 the height of the tool bar to zero when this happens so frame sizes
3729 are correctly calculated.
3730 WBOX is the handle box widget that enables detach/attach of the tool bar.
3731 W is the tool bar widget.
3732 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3735 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
3737 gpointer client_data
)
3739 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3740 extern int x_gtk_whole_detached_tool_bar
;
3742 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3747 GtkRequisition req
, req2
;
3748 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3749 gtk_widget_size_request (GTK_WIDGET (wbox
), &req
);
3750 gtk_widget_size_request (w
, &req2
);
3751 req
.width
-= req2
.width
;
3752 req
.height
-= req2
.height
;
3753 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
3754 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
3755 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
3756 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
3757 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
3758 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
3759 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
3760 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
3761 xg_height_or_width_changed (f
);
3765 /* This callback is called when a tool bar is reattached. We must set
3766 the height of the tool bar when this happens so frame sizes
3767 are correctly calculated.
3768 WBOX is the handle box widget that enables detach/attach of the tool bar.
3769 W is the tool bar widget.
3770 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3773 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
3775 gpointer client_data
)
3777 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3778 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3782 GtkRequisition req
, req2
;
3783 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3784 gtk_widget_size_request (GTK_WIDGET (wbox
), &req
);
3785 gtk_widget_size_request (w
, &req2
);
3786 req
.width
+= req2
.width
;
3787 req
.height
+= req2
.height
;
3788 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
3789 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
3790 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
3791 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
3792 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
3793 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
3794 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
3795 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
3796 xg_height_or_width_changed (f
);
3800 /* This callback is called when the mouse enters or leaves a tool bar item.
3801 It is used for displaying and hiding the help text.
3802 W is the tool bar item, a button.
3803 EVENT is either an enter event or leave event.
3804 CLIENT_DATA is an integer that is the index of the button in the
3805 tool bar. 0 is the first button.
3807 Returns FALSE to tell GTK to keep processing this event. */
3810 xg_tool_bar_help_callback (GtkWidget
*w
,
3811 GdkEventCrossing
*event
,
3812 gpointer client_data
)
3814 /* The EMACS_INT cast avoids a warning. */
3815 int idx
= (int) (EMACS_INT
) client_data
;
3816 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3817 Lisp_Object help
, frame
;
3819 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3822 if (event
->type
== GDK_ENTER_NOTIFY
)
3824 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3825 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3828 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3833 XSETFRAME (frame
, f
);
3834 kbd_buffer_store_help_event (frame
, help
);
3840 /* This callback is called when a tool bar item shall be redrawn.
3841 It modifies the expose event so that the GtkImage widget redraws the
3842 whole image. This to overcome a bug that makes GtkImage draw the image
3843 in the wrong place when it tries to redraw just a part of the image.
3844 W is the GtkImage to be redrawn.
3845 EVENT is the expose event for W.
3846 CLIENT_DATA is unused.
3848 Returns FALSE to tell GTK to keep processing this event. */
3851 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
3852 GdkEventExpose
*event
,
3853 gpointer client_data
)
3857 gdk_drawable_get_size (event
->window
, &width
, &height
);
3859 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3860 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3862 event
->area
.x
= max (0, event
->area
.x
);
3863 event
->area
.y
= max (0, event
->area
.y
);
3865 event
->area
.width
= max (width
, event
->area
.width
);
3866 event
->area
.height
= max (height
, event
->area
.height
);
3871 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
3872 #define toolbar_set_orientation(w, o) \
3873 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
3875 #define toolbar_set_orientation(w, o) \
3876 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
3879 /* Attach a tool bar to frame F. */
3882 xg_pack_tool_bar (FRAME_PTR f
, Lisp_Object pos
)
3884 struct x_output
*x
= f
->output_data
.x
;
3885 int into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
3887 toolbar_set_orientation (x
->toolbar_widget
,
3889 ? GTK_ORIENTATION_VERTICAL
3890 : GTK_ORIENTATION_HORIZONTAL
);
3891 if (!x
->handlebox_widget
)
3893 x
->handlebox_widget
= gtk_handle_box_new ();
3894 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3895 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3896 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3897 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3898 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3904 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), x
->handlebox_widget
,
3907 if (EQ (pos
, Qleft
))
3908 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
3909 x
->handlebox_widget
,
3911 x
->toolbar_in_hbox
= 1;
3915 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3916 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3920 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
3921 x
->handlebox_widget
,
3923 x
->toolbar_in_hbox
= 0;
3927 /* Create a tool bar for frame F. */
3930 xg_create_tool_bar (FRAME_PTR f
)
3932 struct x_output
*x
= f
->output_data
.x
;
3934 x
->toolbar_widget
= gtk_toolbar_new ();
3935 x
->toolbar_detached
= 0;
3937 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3939 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3940 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
3944 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3946 /* Find the right-to-left image named by RTL in the tool bar images for F.
3947 Returns IMAGE if RTL is not found. */
3950 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
3953 Lisp_Object file
, rtl_name
;
3954 struct gcpro gcpro1
, gcpro2
;
3955 GCPRO2 (file
, rtl_name
);
3957 rtl_name
= Ffile_name_nondirectory (rtl
);
3959 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3961 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3962 if (!NILP (file
= file_for_image (rtl_image
)))
3964 file
= call1 (intern ("file-name-sans-extension"),
3965 Ffile_name_nondirectory (file
));
3966 if (EQ (Fequal (file
, rtl_name
), Qt
))
3977 static GtkToolItem
*
3978 xg_make_tool_item (FRAME_PTR f
,
3980 GtkWidget
**wbutton
,
3984 GtkToolItem
*ti
= gtk_tool_item_new ();
3985 Lisp_Object style
= Ftool_bar_get_system_style ();
3986 int both_horiz
= EQ (style
, Qboth_horiz
);
3987 int text_image
= EQ (style
, Qtext_image_horiz
);
3989 GtkWidget
*vb
= both_horiz
|| text_image
3990 ? gtk_hbox_new (FALSE
, 0) : gtk_vbox_new (FALSE
, 0);
3991 GtkWidget
*wb
= gtk_button_new ();
3992 GtkWidget
*weventbox
= gtk_event_box_new ();
3994 if (wimage
&& ! text_image
)
3995 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
3997 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
3999 if (wimage
&& text_image
)
4000 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4002 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4003 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4004 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4005 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4006 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4010 /* The EMACS_INT cast avoids a warning. */
4011 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4012 G_CALLBACK (xg_tool_bar_menu_proxy
),
4013 (gpointer
) (EMACS_INT
) i
);
4015 g_signal_connect (G_OBJECT (wb
), "clicked",
4016 G_CALLBACK (xg_tool_bar_callback
),
4017 (gpointer
) (EMACS_INT
) i
);
4019 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4021 /* Catch expose events to overcome an annoying redraw bug, see
4022 comment for xg_tool_bar_item_expose_callback. */
4023 g_signal_connect (G_OBJECT (ti
),
4025 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4028 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4030 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
4031 no distinction based on modifiers in the activate callback,
4032 so we have to do it ourselves. */
4033 g_signal_connect (wb
, "button-release-event",
4034 G_CALLBACK (xg_tool_bar_button_cb
),
4037 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4039 /* Use enter/leave notify to show help. We use the events
4040 rather than the GtkButton specific signals "enter" and
4041 "leave", so we can have only one callback. The event
4042 will tell us what kind of event it is. */
4043 /* The EMACS_INT cast avoids a warning. */
4044 g_signal_connect (G_OBJECT (weventbox
),
4045 "enter-notify-event",
4046 G_CALLBACK (xg_tool_bar_help_callback
),
4047 (gpointer
) (EMACS_INT
) i
);
4048 g_signal_connect (G_OBJECT (weventbox
),
4049 "leave-notify-event",
4050 G_CALLBACK (xg_tool_bar_help_callback
),
4051 (gpointer
) (EMACS_INT
) i
);
4054 if (wbutton
) *wbutton
= wb
;
4060 xg_show_toolbar_item (GtkToolItem
*ti
)
4062 Lisp_Object style
= Ftool_bar_get_system_style ();
4063 int both_horiz
= EQ (style
, Qboth_horiz
);
4064 int text_image
= EQ (style
, Qtext_image_horiz
);
4066 int horiz
= both_horiz
|| text_image
;
4067 int show_label
= ! EQ (style
, Qimage
);
4068 int show_image
= ! EQ (style
, Qtext
);
4070 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
4071 GtkWidget
*wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
4072 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
4074 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4075 GtkWidget
*new_box
= NULL
;
4077 if (GTK_IS_VBOX (vb
) && horiz
)
4078 new_box
= gtk_hbox_new (FALSE
, 0);
4079 else if (GTK_IS_HBOX (vb
) && !horiz
&& show_label
&& show_image
)
4080 new_box
= gtk_vbox_new (FALSE
, 0);
4082 if (!new_box
&& horiz
)
4083 gtk_box_reorder_child (GTK_BOX (vb
), wlbl
, text_image
? 0 : 1);
4086 g_object_ref (G_OBJECT (wimage
));
4087 g_object_ref (G_OBJECT (wlbl
));
4088 gtk_container_remove (GTK_CONTAINER (vb
), wimage
);
4089 gtk_container_remove (GTK_CONTAINER (vb
), wlbl
);
4090 gtk_widget_destroy (GTK_WIDGET (vb
));
4092 gtk_box_pack_start (GTK_BOX (new_box
), wimage
, TRUE
, TRUE
, 0);
4093 gtk_box_pack_start (GTK_BOX (new_box
), wlbl
, TRUE
, TRUE
, 0);
4095 gtk_box_pack_start (GTK_BOX (new_box
), wimage
, TRUE
, TRUE
, 0);
4096 gtk_container_add (GTK_CONTAINER (wbutton
), new_box
);
4097 g_object_unref (G_OBJECT (wimage
));
4098 g_object_unref (G_OBJECT (wlbl
));
4102 if (show_label
) gtk_widget_show (wlbl
);
4103 else gtk_widget_hide (wlbl
);
4104 if (show_image
) gtk_widget_show (wimage
);
4105 else gtk_widget_hide (wimage
);
4106 gtk_widget_show (GTK_WIDGET (weventbox
));
4107 gtk_widget_show (GTK_WIDGET (vb
));
4108 gtk_widget_show (GTK_WIDGET (wbutton
));
4109 gtk_widget_show (GTK_WIDGET (ti
));
4113 xg_update_tool_bar_sizes (FRAME_PTR f
)
4115 struct x_output
*x
= f
->output_data
.x
;
4117 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4119 gtk_widget_size_request (GTK_WIDGET (x
->handlebox_widget
), &req
);
4120 if (x
->toolbar_in_hbox
)
4123 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4124 x
->handlebox_widget
,
4125 "position", &pos
, NULL
);
4126 if (pos
== 0) nl
= req
.width
;
4127 else nr
= req
.width
;
4132 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4133 x
->handlebox_widget
,
4134 "position", &pos
, NULL
);
4135 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4136 else nb
= req
.height
;
4139 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4140 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4141 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4142 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4144 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4145 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4146 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4147 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4148 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4149 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4157 /* Update the tool bar for frame F. Add new buttons and remove old. */
4160 update_frame_tool_bar (FRAME_PTR f
)
4163 struct x_output
*x
= f
->output_data
.x
;
4164 int hmargin
= 0, vmargin
= 0;
4165 GtkToolbar
*wtoolbar
;
4167 GtkTextDirection dir
;
4168 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
4170 if (! FRAME_GTK_WIDGET (f
))
4175 if (INTEGERP (Vtool_bar_button_margin
)
4176 && XINT (Vtool_bar_button_margin
) > 0)
4178 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4179 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4181 else if (CONSP (Vtool_bar_button_margin
))
4183 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
4184 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
4185 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4187 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
4188 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
4189 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4192 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4193 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4194 i.e. zero. This means that margins less than
4195 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4196 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4197 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4199 if (! x
->toolbar_widget
)
4200 xg_create_tool_bar (f
);
4202 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4203 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4205 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4207 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4208 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4212 struct image
*img
= NULL
;
4214 Lisp_Object stock
= Qnil
;
4215 GtkStockItem stock_item
;
4216 char *stock_name
= NULL
;
4217 char *icon_name
= NULL
;
4219 GtkWidget
*wbutton
= NULL
;
4220 GtkWidget
*weventbox
;
4221 Lisp_Object specified_file
;
4222 char *label
= SSDATA (PROP (TOOL_BAR_ITEM_LABEL
));
4224 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), i
);
4228 weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
4229 wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
4233 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4235 /* Ignore invalid image specifications. */
4236 if (!valid_image_p (image
))
4238 if (wbutton
) gtk_widget_hide (wbutton
);
4242 specified_file
= file_for_image (image
);
4243 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4244 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4246 if (STRINGP (stock
))
4248 stock_name
= SSDATA (stock
);
4249 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4251 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4252 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4254 icon_name
= stock_name
+ 2;
4258 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4261 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4263 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4264 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4272 if (stock_name
== NULL
&& icon_name
== NULL
)
4274 /* No stock image, or stock item not known. Try regular image. */
4276 /* If image is a vector, choose the image according to the
4278 if (dir
== GTK_TEXT_DIR_RTL
4279 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4282 image
= find_rtl_image (f
, image
, rtl
);
4285 if (VECTORP (image
))
4289 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4290 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4293 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4294 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4296 xassert (ASIZE (image
) >= idx
);
4297 image
= AREF (image
, idx
);
4302 img_id
= lookup_image (f
, image
);
4303 img
= IMAGE_FROM_ID (f
, img_id
);
4304 prepare_image_for_display (f
, img
);
4306 if (img
->load_failed_p
|| img
->pixmap
== None
)
4309 gtk_widget_hide_all (GTK_WIDGET (ti
));
4312 /* Insert an empty (non-image) button */
4313 ti
= xg_make_tool_item (f
, NULL
, NULL
, "", i
);
4314 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, -1);
4325 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4326 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4327 (gpointer
) xstrdup (stock_name
),
4328 (GDestroyNotify
) xfree
);
4332 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4333 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4334 (gpointer
) xstrdup (icon_name
),
4335 (GDestroyNotify
) xfree
);
4339 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4340 /* Save the image so we can see if an update is needed when
4341 this function is called again. */
4342 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4343 (gpointer
)img
->pixmap
);
4346 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4347 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
);
4348 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, -1);
4349 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4353 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
4355 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4357 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
4358 XG_TOOL_BAR_IMAGE_DATA
);
4359 gpointer old_stock_name
= g_object_get_data (G_OBJECT (wimage
),
4360 XG_TOOL_BAR_STOCK_NAME
);
4361 gpointer old_icon_name
= g_object_get_data (G_OBJECT (wimage
),
4362 XG_TOOL_BAR_ICON_NAME
);
4363 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4365 (! old_stock_name
|| strcmp (old_stock_name
, stock_name
) != 0))
4367 gtk_image_set_from_stock (GTK_IMAGE (wimage
),
4368 stock_name
, icon_size
);
4369 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4370 (gpointer
) xstrdup (stock_name
),
4371 (GDestroyNotify
) xfree
);
4372 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4374 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4377 else if (icon_name
&&
4378 (! old_icon_name
|| strcmp (old_icon_name
, icon_name
) != 0))
4380 gtk_image_set_from_icon_name (GTK_IMAGE (wimage
),
4381 icon_name
, icon_size
);
4382 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4383 (gpointer
) xstrdup (icon_name
),
4384 (GDestroyNotify
) xfree
);
4385 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4387 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4390 else if (img
&& old_img
!= img
->pixmap
)
4392 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
,
4393 GTK_IMAGE (wimage
));
4394 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4395 (gpointer
)img
->pixmap
);
4397 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4399 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4403 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
4405 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4407 xg_show_toolbar_item (ti
);
4412 /* Remove buttons not longer needed. We just hide them so they
4413 can be reused later on. */
4416 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), i
++);
4417 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
4418 } while (ti
!= NULL
);
4420 if (f
->n_tool_bar_items
!= 0)
4423 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4424 gtk_widget_show (x
->toolbar_widget
);
4425 gtk_widget_show (x
->handlebox_widget
);
4426 if (xg_update_tool_bar_sizes (f
))
4427 xg_height_or_width_changed (f
);
4433 /* Deallocate all resources for the tool bar on frame F.
4434 Remove the tool bar. */
4437 free_frame_tool_bar (FRAME_PTR f
)
4439 struct x_output
*x
= f
->output_data
.x
;
4441 if (x
->toolbar_widget
)
4443 int is_packed
= x
->handlebox_widget
!= 0;
4445 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4446 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4449 if (x
->toolbar_in_hbox
)
4450 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4451 x
->handlebox_widget
);
4453 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4454 x
->handlebox_widget
);
4457 gtk_widget_destroy (x
->toolbar_widget
);
4459 x
->toolbar_widget
= 0;
4460 x
->handlebox_widget
= 0;
4461 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4462 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4464 xg_height_or_width_changed (f
);
4471 xg_change_toolbar_position (FRAME_PTR f
, Lisp_Object pos
)
4473 struct x_output
*x
= f
->output_data
.x
;
4475 if (! x
->toolbar_widget
|| ! x
->handlebox_widget
)
4479 g_object_ref (x
->handlebox_widget
);
4480 if (x
->toolbar_in_hbox
)
4481 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4482 x
->handlebox_widget
);
4484 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4485 x
->handlebox_widget
);
4486 xg_pack_tool_bar (f
, pos
);
4487 g_object_unref (x
->handlebox_widget
);
4488 if (xg_update_tool_bar_sizes (f
))
4489 xg_height_or_width_changed (f
);
4497 /***********************************************************************
4499 ***********************************************************************/
4501 xg_initialize (void)
4503 GtkBindingSet
*binding_set
;
4506 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4507 we keep it permanently linked in. */
4512 xg_ignore_gtk_scrollbar
= 0;
4513 xg_detached_menus
= 0;
4514 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4515 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4517 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4518 id_to_widget
.widgets
= 0;
4520 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4521 bindings. It doesn't seem to be any way to remove properties,
4522 so we set it to VoidSymbol which in X means "no key". */
4523 gtk_settings_set_string_property (gtk_settings_get_default (),
4524 "gtk-menu-bar-accel",
4528 /* Make GTK text input widgets use Emacs style keybindings. This is
4530 gtk_settings_set_string_property (gtk_settings_get_default (),
4531 "gtk-key-theme-name",
4535 /* Make dialogs close on C-g. Since file dialog inherits from
4536 dialog, this works for them also. */
4537 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4538 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4541 /* Make menus close on C-g. */
4542 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4543 (GTK_TYPE_MENU_SHELL
));
4544 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4548 #endif /* USE_GTK */
4550 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
4551 (do not change this comment) */