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 /* Avoid "differ in sign" warnings */
48 #define SSDATA(x) ((char *) SDATA (x))
50 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
51 #define gtk_widget_set_has_window(w, b) \
52 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
54 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
55 #define gtk_dialog_get_action_area(w) ((w)->action_area)
56 #define gtk_dialog_get_content_area(w) ((w)->vbox)
58 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
59 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
61 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
62 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
63 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
64 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
65 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
67 #if GTK_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 11
68 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
70 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
74 /***********************************************************************
75 Display handling functions
76 ***********************************************************************/
78 /* Keep track of the default display, or NULL if there is none. Emacs
79 may close all its displays. */
81 static GdkDisplay
*gdpy_def
;
83 /* When the GTK widget W is to be created on a display for F that
84 is not the default display, set the display for W.
85 W can be a GtkMenu or a GtkWindow widget. */
88 xg_set_screen (GtkWidget
*w
, FRAME_PTR f
)
90 if (FRAME_X_DISPLAY (f
) != GDK_DISPLAY ())
92 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
93 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
96 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
98 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
103 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
104 *DPY is set to NULL if the display can't be opened.
106 Returns non-zero if display could be opened, zero if display could not
107 be opened, and less than zero if the GTK version doesn't support
111 xg_display_open (char *display_name
, Display
**dpy
)
115 gdpy
= gdk_display_open (display_name
);
116 if (!gdpy_def
&& gdpy
)
119 gdk_display_manager_set_default_display (gdk_display_manager_get (),
123 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
127 /* Close display DPY. */
130 xg_display_close (Display
*dpy
)
132 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
134 /* If this is the default display, try to change it before closing.
135 If there is no other display to use, gdpy_def is set to NULL, and
136 the next call to xg_display_open resets the default display. */
137 if (gdk_display_get_default () == gdpy
)
139 struct x_display_info
*dpyinfo
;
140 GdkDisplay
*gdpy_new
= NULL
;
142 /* Find another display. */
143 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
144 if (dpyinfo
->display
!= dpy
)
146 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
147 gdk_display_manager_set_default_display (gdk_display_manager_get (),
154 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
155 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
156 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
157 can continue running, but there will be memory leaks. */
158 g_object_run_dispose (G_OBJECT (gdpy
));
160 /* This seems to be fixed in GTK 2.10. */
161 gdk_display_close (gdpy
);
166 /***********************************************************************
168 ***********************************************************************/
169 /* The next two variables and functions are taken from lwlib. */
170 static widget_value
*widget_value_free_list
;
171 static int malloc_cpt
;
173 /* Allocate a widget_value structure, either by taking one from the
174 widget_value_free_list or by malloc:ing a new one.
176 Return a pointer to the allocated structure. */
179 malloc_widget_value (void)
182 if (widget_value_free_list
)
184 wv
= widget_value_free_list
;
185 widget_value_free_list
= wv
->free_list
;
190 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
193 memset (wv
, 0, sizeof (widget_value
));
197 /* This is analogous to free. It frees only what was allocated
198 by malloc_widget_value, and no substructures. */
201 free_widget_value (widget_value
*wv
)
208 /* When the number of already allocated cells is too big,
215 wv
->free_list
= widget_value_free_list
;
216 widget_value_free_list
= wv
;
221 /* Create and return the cursor to be used for popup menus and
222 scroll bars on display DPY. */
225 xg_create_default_cursor (Display
*dpy
)
227 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
228 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
231 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
234 xg_get_pixbuf_from_pix_and_mask (GdkPixmap
*gpix
, GdkPixmap
*gmask
, GdkColormap
*cmap
)
237 GdkPixbuf
*icon_buf
, *tmp_buf
;
239 gdk_drawable_get_size (gpix
, &width
, &height
);
240 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
241 0, 0, 0, 0, width
, height
);
242 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
243 g_object_unref (G_OBJECT (tmp_buf
));
247 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
252 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
253 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
254 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
255 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
258 for (y
= 0; y
< height
; ++y
)
260 guchar
*iconptr
, *maskptr
;
263 iconptr
= pixels
+ y
* rowstride
;
264 maskptr
= mask_pixels
+ y
* mask_rowstride
;
266 for (x
= 0; x
< width
; ++x
)
268 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
269 just R is sufficient. */
271 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
273 iconptr
+= rowstride
/width
;
274 maskptr
+= mask_rowstride
/width
;
278 g_object_unref (G_OBJECT (mask_buf
));
285 file_for_image (Lisp_Object image
)
287 Lisp_Object specified_file
= Qnil
;
289 extern Lisp_Object QCfile
;
291 for (tail
= XCDR (image
);
292 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
293 tail
= XCDR (XCDR (tail
)))
294 if (EQ (XCAR (tail
), QCfile
))
295 specified_file
= XCAR (XCDR (tail
));
297 return specified_file
;
300 /* For the image defined in IMG, make and return a GtkImage. For displays with
301 8 planes or less we must make a GdkPixbuf and apply the mask manually.
302 Otherwise the highlightning and dimming the tool bar code in GTK does
303 will look bad. For display with more than 8 planes we just use the
304 pixmap and mask directly. For monochrome displays, GTK doesn't seem
305 able to use external pixmaps, it looks bad whatever we do.
306 The image is defined on the display where frame F is.
307 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
308 If OLD_WIDGET is NULL, a new widget is constructed and returned.
309 If OLD_WIDGET is not NULL, that widget is modified. */
312 xg_get_image_for_pixmap (FRAME_PTR f
, struct image
*img
, GtkWidget
*widget
, GtkImage
*old_widget
)
320 /* If we have a file, let GTK do all the image handling.
321 This seems to be the only way to make insensitive and activated icons
322 look good in all cases. */
323 Lisp_Object specified_file
= file_for_image (img
->spec
);
326 /* We already loaded the image once before calling this
327 function, so this only fails if the image file has been removed.
328 In that case, use the pixmap already loaded. */
330 if (STRINGP (specified_file
)
331 && STRINGP (file
= x_find_image_file (specified_file
)))
334 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
336 gtk_image_set_from_file (old_widget
, SSDATA (file
));
338 return GTK_WIDGET (old_widget
);
341 /* No file, do the image handling ourselves. This will look very bad
342 on a monochrome display, and sometimes bad on all displays with
345 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
346 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
347 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
349 /* This is a workaround to make icons look good on pseudo color
350 displays. Apparently GTK expects the images to have an alpha
351 channel. If they don't, insensitive and activated icons will
352 look bad. This workaround does not work on monochrome displays,
353 and is strictly not needed on true color/static color displays (i.e.
354 16 bits and higher). But we do it anyway so we get a pixbuf that is
355 not associated with the img->pixmap. The img->pixmap may be removed
356 by clearing the image cache and then the tool bar redraw fails, since
357 Gtk+ assumes the pixmap is always there. */
358 cmap
= gtk_widget_get_colormap (widget
);
359 icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
362 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
364 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
366 g_object_unref (G_OBJECT (icon_buf
));
368 g_object_unref (G_OBJECT (gpix
));
369 if (gmask
) g_object_unref (G_OBJECT (gmask
));
371 return GTK_WIDGET (old_widget
);
375 /* Set CURSOR on W and all widgets W contain. We must do like this
376 for scroll bars and menu because they create widgets internally,
377 and it is those widgets that are visible. */
380 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
382 GdkWindow
*window
= gtk_widget_get_window(w
);
383 GList
*children
= gdk_window_peek_children (window
);
385 gdk_window_set_cursor (window
, cursor
);
387 /* The scroll bar widget has more than one GDK window (had to look at
388 the source to figure this out), and there is no way to set cursor
389 on widgets in GTK. So we must set the cursor for all GDK windows.
392 for ( ; children
; children
= g_list_next (children
))
393 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
396 /* Insert NODE into linked LIST. */
399 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
401 xg_list_node
*list_start
= list
->next
;
403 if (list_start
) list_start
->prev
= node
;
404 node
->next
= list_start
;
409 /* Remove NODE from linked LIST. */
412 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
414 xg_list_node
*list_start
= list
->next
;
415 if (node
== list_start
)
417 list
->next
= node
->next
;
418 if (list
->next
) list
->next
->prev
= 0;
422 node
->prev
->next
= node
->next
;
423 if (node
->next
) node
->next
->prev
= node
->prev
;
427 /* Allocate and return a utf8 version of STR. If STR is already
428 utf8 or NULL, just return STR.
429 If not, a new string is allocated and the caller must free the result
433 get_utf8_string (char *str
)
435 char *utf8_str
= str
;
437 if (!str
) return NULL
;
439 /* If not UTF-8, try current locale. */
440 if (!g_utf8_validate (str
, -1, NULL
))
441 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
445 /* Probably some control characters in str. Escape them. */
449 unsigned char *p
= (unsigned char *)str
;
451 GError
*error
= NULL
;
453 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
454 &bytes_written
, &error
))
455 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
458 p
+= bytes_written
+1;
459 g_error_free (error
);
465 g_error_free (error
);
470 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
471 p
= (unsigned char *)str
;
473 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
474 &bytes_written
, &error
))
475 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
477 strncpy (up
, (char *)p
, bytes_written
);
478 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
479 up
[bytes_written
+4] = '\0';
480 up
+= bytes_written
+4;
481 p
+= bytes_written
+1;
482 g_error_free (error
);
488 strcat (utf8_str
, cp
);
493 g_error_free (error
);
502 /***********************************************************************
503 General functions for creating widgets, resizing, events, e.t.c.
504 ***********************************************************************/
506 /* Make a geometry string and pass that to GTK. It seems this is the
507 only way to get geometry position right if the user explicitly
508 asked for a position when starting Emacs.
509 F is the frame we shall set geometry for. */
512 xg_set_geometry (FRAME_PTR f
)
514 if (f
->size_hint_flags
& (USPosition
| PPosition
))
516 int left
= f
->left_pos
;
517 int xneg
= f
->size_hint_flags
& XNegative
;
518 int top
= f
->top_pos
;
519 int yneg
= f
->size_hint_flags
& YNegative
;
527 sprintf (geom_str
, "=%dx%d%c%d%c%d",
528 FRAME_PIXEL_WIDTH (f
),
529 FRAME_PIXEL_HEIGHT (f
),
530 (xneg
? '-' : '+'), left
,
531 (yneg
? '-' : '+'), top
);
533 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
535 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
539 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
540 and use a GtkFixed widget, this doesn't happen automatically. */
543 xg_clear_under_internal_border (FRAME_PTR f
)
545 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
547 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
548 gtk_widget_queue_draw (wfixed
);
549 gdk_window_process_all_updates ();
550 x_clear_area (FRAME_X_DISPLAY (f
),
553 FRAME_PIXEL_WIDTH (f
),
554 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
555 x_clear_area (FRAME_X_DISPLAY (f
),
558 FRAME_INTERNAL_BORDER_WIDTH (f
),
559 FRAME_PIXEL_HEIGHT (f
), 0);
560 x_clear_area (FRAME_X_DISPLAY (f
),
562 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
563 FRAME_PIXEL_WIDTH (f
),
564 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
565 x_clear_area (FRAME_X_DISPLAY (f
),
567 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
569 FRAME_INTERNAL_BORDER_WIDTH (f
),
570 FRAME_PIXEL_HEIGHT (f
), 0);
574 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
575 and a Gtk+ menu bar, we get resize events for the edit part of the
576 frame only. We let Gtk+ deal with the Gtk+ parts.
577 F is the frame to resize.
578 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
581 xg_frame_resized (FRAME_PTR f
, int pixelwidth
, int pixelheight
)
585 if (pixelwidth
== -1 && pixelheight
== -1)
587 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
588 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
590 &pixelwidth
, &pixelheight
, 0);
595 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
596 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
598 if (columns
!= FRAME_COLS (f
)
599 || rows
!= FRAME_LINES (f
)
600 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
601 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
603 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
604 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
606 xg_clear_under_internal_border (f
);
607 change_frame_size (f
, rows
, columns
, 0, 1, 0);
608 SET_FRAME_GARBAGED (f
);
609 cancel_mouse_face (f
);
613 /* Resize the outer window of frame F after chainging the height.
614 COLUMNS/ROWS is the size the edit area shall have after the resize. */
617 xg_frame_set_char_size (FRAME_PTR f
, int cols
, int rows
)
619 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
620 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
623 if (FRAME_PIXEL_HEIGHT (f
) == 0)
626 /* Take into account the size of the scroll bar. Always use the
627 number of columns occupied by the scroll bar here otherwise we
628 might end up with a frame width that is not a multiple of the
629 frame's character width which is bad for vertically split
631 f
->scroll_bar_actual_width
632 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
634 compute_fringe_widths (f
, 0);
636 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
637 after calculating that value. */
638 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
641 /* Do this before resize, as we don't know yet if we will be resized. */
642 xg_clear_under_internal_border (f
);
644 /* Must resize our top level widget. Font size may have changed,
645 but not rows/cols. */
646 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
647 pixelwidth
, pixelheight
);
648 x_wm_set_size_hint (f
, 0, 0);
650 SET_FRAME_GARBAGED (f
);
651 cancel_mouse_face (f
);
653 /* We can not call change_frame_size for a mapped frame,
654 we can not set pixel width/height either. The window manager may
655 override our resize request, XMonad does this all the time.
656 The best we can do is try to sync, so lisp code sees the updated
657 size as fast as possible.
658 For unmapped windows, we can set rows/cols. When
659 the frame is mapped again we will (hopefully) get the correct size. */
660 if (f
->async_visible
)
662 /* Must call this to flush out events */
663 (void)gtk_events_pending ();
665 x_wait_for_event (f
, ConfigureNotify
);
669 change_frame_size (f
, rows
, cols
, 0, 1, 0);
670 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
671 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
675 /* Handle height changes (i.e. add/remove menu/toolbar).
676 The policy is to keep the number of editable lines. */
679 xg_height_changed (FRAME_PTR f
)
681 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
682 FRAME_PIXEL_WIDTH (f
), FRAME_TOTAL_PIXEL_HEIGHT (f
));
683 f
->output_data
.x
->hint_flags
= 0;
684 x_wm_set_size_hint (f
, 0, 0);
687 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
688 Must be done like this, because GtkWidget:s can have "hidden"
689 X Window that aren't accessible.
691 Return 0 if no widget match WDESC. */
694 xg_win_to_widget (Display
*dpy
, Window wdesc
)
697 GtkWidget
*gwdesc
= 0;
701 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
706 event
.any
.window
= gdkwin
;
707 gwdesc
= gtk_get_event_widget (&event
);
714 /* Fill in the GdkColor C so that it represents PIXEL.
715 W is the widget that color will be used for. Used to find colormap. */
718 xg_pix_to_gcolor (GtkWidget
*w
, long unsigned int pixel
, GdkColor
*c
)
720 GdkColormap
*map
= gtk_widget_get_colormap (w
);
721 gdk_colormap_query_color (map
, pixel
, c
);
724 /* Create and set up the GTK widgets for frame F.
725 Return 0 if creation failed, non-zero otherwise. */
728 xg_create_frame_widgets (FRAME_PTR f
)
739 if (FRAME_X_EMBEDDED_P (f
))
740 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
742 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
744 xg_set_screen (wtop
, f
);
746 wvbox
= gtk_vbox_new (FALSE
, 0);
747 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
749 if (! wtop
|| ! wvbox
|| ! wfixed
)
751 if (wtop
) gtk_widget_destroy (wtop
);
752 if (wvbox
) gtk_widget_destroy (wvbox
);
753 if (wfixed
) gtk_widget_destroy (wfixed
);
759 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
760 gtk_widget_set_name (wtop
, EMACS_CLASS
);
761 gtk_widget_set_name (wvbox
, "pane");
762 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
764 /* If this frame has a title or name, set it in the title bar. */
765 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
766 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
768 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
770 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
771 FRAME_GTK_WIDGET (f
) = wfixed
;
772 f
->output_data
.x
->vbox_widget
= wvbox
;
774 gtk_widget_set_has_window (wfixed
, TRUE
);
776 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
777 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
779 if (FRAME_EXTERNAL_TOOL_BAR (f
))
780 update_frame_tool_bar (f
);
782 /* We don't want this widget double buffered, because we draw on it
783 with regular X drawing primitives, so from a GTK/GDK point of
784 view, the widget is totally blank. When an expose comes, this
785 will make the widget blank, and then Emacs redraws it. This flickers
786 a lot, so we turn off double buffering. */
787 gtk_widget_set_double_buffered (wfixed
, FALSE
);
789 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
790 SSDATA (Vx_resource_name
),
791 SSDATA (Vx_resource_class
));
793 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
794 GTK is to destroy the widget. We want Emacs to do that instead. */
795 g_signal_connect (G_OBJECT (wtop
), "delete-event",
796 G_CALLBACK (gtk_true
), 0);
798 /* Convert our geometry parameters into a geometry string
800 GTK will itself handle calculating the real position this way. */
803 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
805 gtk_widget_add_events (wfixed
,
806 GDK_POINTER_MOTION_MASK
808 | GDK_BUTTON_PRESS_MASK
809 | GDK_BUTTON_RELEASE_MASK
811 | GDK_ENTER_NOTIFY_MASK
812 | GDK_LEAVE_NOTIFY_MASK
813 | GDK_FOCUS_CHANGE_MASK
815 | GDK_VISIBILITY_NOTIFY_MASK
);
817 /* Must realize the windows so the X window gets created. It is used
818 by callers of this function. */
819 gtk_widget_realize (wfixed
);
820 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
822 /* Since GTK clears its window by filling with the background color,
823 we must keep X and GTK background in sync. */
824 xg_pix_to_gcolor (wfixed
, FRAME_BACKGROUND_PIXEL (f
), &bg
);
825 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
827 /* Also, do not let any background pixmap to be set, this looks very
828 bad as Emacs overwrites the background pixmap with its own idea
829 of background color. */
830 style
= gtk_widget_get_modifier_style (wfixed
);
832 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
833 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
834 gtk_widget_modify_style (wfixed
, style
);
836 /* GTK does not set any border, and they look bad with GTK. */
837 /* That they look bad is no excuse for imposing this here. --Stef
838 It should be done by providing the proper default in Fx_create_Frame.
840 f->internal_border_width = 0; */
847 /* Set the normal size hints for the window manager, for frame F.
848 FLAGS is the flags word to use--or 0 meaning preserve the flags
849 that the window now has.
850 If USER_POSITION is nonzero, we set the User Position
851 flag (this is useful when FLAGS is 0). */
854 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
856 /* Must use GTK routines here, otherwise GTK resets the size hints
857 to its own defaults. */
858 GdkGeometry size_hints
;
860 int base_width
, base_height
;
861 int min_rows
= 0, min_cols
= 0;
862 int win_gravity
= f
->win_gravity
;
864 /* Don't set size hints during initialization; that apparently leads
865 to a race condition. See the thread at
866 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
867 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
872 memset (&size_hints
, 0, sizeof (size_hints
));
873 f
->output_data
.x
->size_hints
= size_hints
;
874 f
->output_data
.x
->hint_flags
= hint_flags
;
877 flags
= f
->size_hint_flags
;
879 size_hints
= f
->output_data
.x
->size_hints
;
880 hint_flags
= f
->output_data
.x
->hint_flags
;
882 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
883 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
884 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
886 hint_flags
|= GDK_HINT_BASE_SIZE
;
887 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
888 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
889 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
891 check_frame_size (f
, &min_rows
, &min_cols
);
893 size_hints
.base_width
= base_width
;
894 size_hints
.base_height
= base_height
;
895 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
896 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
898 /* These currently have a one to one mapping with the X values, but I
899 don't think we should rely on that. */
900 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
901 size_hints
.win_gravity
= 0;
902 if (win_gravity
== NorthWestGravity
)
903 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
904 else if (win_gravity
== NorthGravity
)
905 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
906 else if (win_gravity
== NorthEastGravity
)
907 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
908 else if (win_gravity
== WestGravity
)
909 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
910 else if (win_gravity
== CenterGravity
)
911 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
912 else if (win_gravity
== EastGravity
)
913 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
914 else if (win_gravity
== SouthWestGravity
)
915 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
916 else if (win_gravity
== SouthGravity
)
917 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
918 else if (win_gravity
== SouthEastGravity
)
919 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
920 else if (win_gravity
== StaticGravity
)
921 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
925 hint_flags
&= ~GDK_HINT_POS
;
926 hint_flags
|= GDK_HINT_USER_POS
;
929 if (hint_flags
!= f
->output_data
.x
->hint_flags
930 || memcmp (&size_hints
,
931 &f
->output_data
.x
->size_hints
,
932 sizeof (size_hints
)) != 0)
935 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
936 NULL
, &size_hints
, hint_flags
);
937 f
->output_data
.x
->size_hints
= size_hints
;
938 f
->output_data
.x
->hint_flags
= hint_flags
;
943 /* Change background color of a frame.
944 Since GTK uses the background color to clear the window, we must
945 keep the GTK and X colors in sync.
946 F is the frame to change,
947 BG is the pixel value to change to. */
950 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
952 if (FRAME_GTK_WIDGET (f
))
957 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
958 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
964 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
965 functions so GTK does not overwrite the icon. */
968 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
970 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
971 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
972 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
973 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
975 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
980 /***********************************************************************
982 ***********************************************************************/
983 /* Return the dialog title to use for a dialog of type KEY.
984 This is the encoding used by lwlib. We use the same for GTK. */
987 get_dialog_title (char key
)
997 title
= "Information";
1016 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1017 the dialog, but return TRUE so the event does not propagate further
1018 in GTK. This prevents GTK from destroying the dialog widget automatically
1019 and we can always destrou the widget manually, regardles of how
1020 it was popped down (button press or WM_DELETE_WINDOW).
1021 W is the dialog widget.
1022 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1023 user_data is NULL (not used).
1025 Returns TRUE to end propagation of event. */
1028 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1030 gtk_widget_unmap (w
);
1034 /* Create a popup dialog window. See also xg_create_widget below.
1035 WV is a widget_value describing the dialog.
1036 SELECT_CB is the callback to use when a button has been pressed.
1037 DEACTIVATE_CB is the callback to use when the dialog pops down.
1039 Returns the GTK dialog widget. */
1042 create_dialog (widget_value
*wv
, GCallback select_cb
, GCallback deactivate_cb
)
1044 char *title
= get_dialog_title (wv
->name
[0]);
1045 int total_buttons
= wv
->name
[1] - '0';
1046 int right_buttons
= wv
->name
[4] - '0';
1049 int button_spacing
= 10;
1050 GtkWidget
*wdialog
= gtk_dialog_new ();
1051 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1052 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1055 GtkWidget
*whbox_up
;
1056 GtkWidget
*whbox_down
;
1058 /* If the number of buttons is greater than 4, make two rows of buttons
1059 instead. This looks better. */
1060 int make_two_rows
= total_buttons
> 4;
1062 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1063 left_buttons
= total_buttons
- right_buttons
;
1065 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1066 gtk_widget_set_name (wdialog
, "emacs-dialog");
1071 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1072 whbox_up
= gtk_hbox_new (FALSE
, 0);
1073 whbox_down
= gtk_hbox_new (FALSE
, 0);
1075 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1076 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1077 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1079 cur_box
= GTK_BOX (whbox_up
);
1082 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1083 G_CALLBACK (dialog_delete_callback
), 0);
1087 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1088 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1091 for (item
= wv
->contents
; item
; item
= item
->next
)
1093 char *utf8_label
= get_utf8_string (item
->value
);
1097 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1099 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1100 /* This is the text part of the dialog. */
1101 w
= gtk_label_new (utf8_label
);
1102 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1103 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1104 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1106 /* Try to make dialog look better. Must realize first so
1107 the widget can calculate the size it needs. */
1108 gtk_widget_realize (w
);
1109 gtk_widget_size_request (w
, &req
);
1110 gtk_box_set_spacing (wvbox
, req
.height
);
1111 if (item
->value
&& strlen (item
->value
) > 0)
1112 button_spacing
= 2*req
.width
/strlen (item
->value
);
1116 /* This is one button to add to the dialog. */
1117 w
= gtk_button_new_with_label (utf8_label
);
1118 if (! item
->enabled
)
1119 gtk_widget_set_sensitive (w
, FALSE
);
1121 g_signal_connect (G_OBJECT (w
), "clicked",
1122 select_cb
, item
->call_data
);
1124 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1125 if (++button_nr
== left_buttons
)
1128 cur_box
= GTK_BOX (whbox_down
);
1130 gtk_box_pack_start (cur_box
,
1137 if (utf8_label
&& utf8_label
!= item
->value
)
1138 g_free (utf8_label
);
1144 struct xg_dialog_data
1152 /* Function that is called when the file or font dialogs pop down.
1153 W is the dialog widget, RESPONSE is the response code.
1154 USER_DATA is what we passed in to g_signal_connect. */
1157 xg_dialog_response_cb (GtkDialog
*w
,
1161 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1162 dd
->response
= response
;
1163 g_main_loop_quit (dd
->loop
);
1167 /* Destroy the dialog. This makes it pop down. */
1170 pop_down_dialog (Lisp_Object arg
)
1172 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1173 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1176 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1177 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1179 g_main_loop_quit (dd
->loop
);
1180 g_main_loop_unref (dd
->loop
);
1187 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1188 We pass in DATA as gpointer* so we can use this as a callback. */
1191 xg_maybe_add_timer (gpointer data
)
1193 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1194 EMACS_TIME next_time
= timer_check (1);
1195 long secs
= EMACS_SECS (next_time
);
1196 long usecs
= EMACS_USECS (next_time
);
1200 if (secs
>= 0 && usecs
>= 0 && secs
< ((guint
)-1)/1000)
1202 dd
->timerid
= g_timeout_add (secs
* 1000 + usecs
/1000,
1210 /* Pops up a modal dialog W and waits for response.
1211 We don't use gtk_dialog_run because we want to process emacs timers.
1212 The dialog W is not destroyed when this function returns. */
1215 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1217 int count
= SPECPDL_INDEX ();
1218 struct xg_dialog_data dd
;
1220 xg_set_screen (w
, f
);
1221 gtk_window_set_transient_for (GTK_WINDOW (w
),
1222 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1223 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1224 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1226 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1227 dd
.response
= GTK_RESPONSE_CANCEL
;
1231 g_signal_connect (G_OBJECT (w
),
1233 G_CALLBACK (xg_dialog_response_cb
),
1235 /* Don't destroy the widget if closed by the window manager close button. */
1236 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1237 gtk_widget_show (w
);
1239 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1241 (void) xg_maybe_add_timer (&dd
);
1242 g_main_loop_run (dd
.loop
);
1245 unbind_to (count
, Qnil
);
1251 /***********************************************************************
1252 File dialog functions
1253 ***********************************************************************/
1254 /* Return non-zero if the old file selection dialog is being used.
1255 Return zero if not. */
1258 xg_uses_old_file_dialog (void)
1260 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1261 extern int x_gtk_use_old_file_dialog
;
1262 return x_gtk_use_old_file_dialog
;
1269 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1271 /* Return the selected file for file chooser dialog W.
1272 The returned string must be free:d. */
1275 xg_get_file_name_from_chooser (GtkWidget
*w
)
1277 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1280 /* Callback called when the "Show hidden files" toggle is pressed.
1281 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1284 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1286 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1288 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1289 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1293 /* Callback called when a property changes in a file chooser.
1294 GOBJECT is the file chooser dialog, ARG1 describes the property.
1295 USER_DATA is the toggle widget in the file chooser dialog.
1296 We use this to update the "Show hidden files" toggle when the user
1297 changes that property by right clicking in the file list. */
1300 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1302 extern int x_gtk_show_hidden_files
;
1304 if (strcmp (arg1
->name
, "show-hidden") == 0)
1306 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1307 gboolean visible
, toggle_on
;
1309 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1310 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1312 if (!!visible
!= !!toggle_on
)
1314 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1315 G_CALLBACK (xg_toggle_visibility_cb
),
1317 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1318 g_signal_handlers_unblock_by_func
1319 (G_OBJECT (wtoggle
),
1320 G_CALLBACK (xg_toggle_visibility_cb
),
1323 x_gtk_show_hidden_files
= visible
;
1327 /* Read a file name from the user using a file chooser dialog.
1328 F is the current frame.
1329 PROMPT is a prompt to show to the user. May not be NULL.
1330 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1331 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1332 file. *FUNC is set to a function that can be used to retrieve the
1333 selected file name from the returned widget.
1335 Returns the created widget. */
1338 xg_get_file_with_chooser (FRAME_PTR f
,
1340 char *default_filename
,
1341 int mustmatch_p
, int only_dir_p
,
1342 xg_get_file_func
*func
)
1346 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1347 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1348 GtkFileChooserAction action
= (mustmatch_p
?
1349 GTK_FILE_CHOOSER_ACTION_OPEN
:
1350 GTK_FILE_CHOOSER_ACTION_SAVE
);
1351 extern int x_gtk_show_hidden_files
;
1352 extern int x_gtk_file_dialog_help_text
;
1356 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1358 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1359 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1360 (mustmatch_p
|| only_dir_p
?
1361 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1364 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1366 wbox
= gtk_vbox_new (FALSE
, 0);
1367 gtk_widget_show (wbox
);
1368 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1370 if (x_gtk_show_hidden_files
)
1372 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1373 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1375 gtk_widget_show (wtoggle
);
1376 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1377 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1378 g_signal_connect (G_OBJECT (filewin
), "notify",
1379 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1381 if (x_gtk_file_dialog_help_text
)
1384 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1385 Show the C-l help text only for versions < 2.10. */
1386 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1387 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1388 strcat (message
, "\nIf you don't like this file selector, use the "
1389 "corresponding\nkey binding or customize "
1390 "use-file-dialog to turn it off.");
1392 wmessage
= gtk_label_new (message
);
1393 gtk_widget_show (wmessage
);
1396 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1397 if (x_gtk_file_dialog_help_text
)
1398 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1399 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1401 if (default_filename
)
1404 struct gcpro gcpro1
;
1405 char *utf8_filename
;
1408 file
= build_string (default_filename
);
1410 /* File chooser does not understand ~/... in the file name. It must be
1411 an absolute name starting with /. */
1412 if (default_filename
[0] != '/')
1413 file
= Fexpand_file_name (file
, Qnil
);
1415 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1416 if (! NILP (Ffile_directory_p (file
)))
1417 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1421 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1423 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1425 char *cp
= strrchr (utf8_filename
, '/');
1427 else cp
= utf8_filename
;
1428 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1435 *func
= xg_get_file_name_from_chooser
;
1439 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1441 /* Return the selected file for file selector dialog W.
1442 The returned string must be free:d. */
1445 xg_get_file_name_from_selector (GtkWidget
*w
)
1447 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1448 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1451 /* Create a file selection dialog.
1452 F is the current frame.
1453 PROMPT is a prompt to show to the user. May not be NULL.
1454 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1455 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1456 file. *FUNC is set to a function that can be used to retrieve the
1457 selected file name from the returned widget.
1459 Returns the created widget. */
1462 xg_get_file_with_selection (
1465 char *default_filename
,
1466 int mustmatch_p
, int only_dir_p
,
1467 xg_get_file_func
*func
)
1470 GtkFileSelection
*filesel
;
1472 filewin
= gtk_file_selection_new (prompt
);
1473 filesel
= GTK_FILE_SELECTION (filewin
);
1475 if (default_filename
)
1476 gtk_file_selection_set_filename (filesel
, default_filename
);
1480 /* The selection_entry part of filesel is not documented. */
1481 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1482 gtk_file_selection_hide_fileop_buttons (filesel
);
1485 *func
= xg_get_file_name_from_selector
;
1489 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1491 /* Read a file name from the user using a file dialog, either the old
1492 file selection dialog, or the new file chooser dialog. Which to use
1493 depends on what the GTK version used has, and what the value of
1494 gtk-use-old-file-dialog.
1495 F is the current frame.
1496 PROMPT is a prompt to show to the user. May not be NULL.
1497 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1498 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1501 Returns a file name or NULL if no file was selected.
1502 The returned string must be freed by the caller. */
1505 xg_get_file_name (FRAME_PTR f
, char *prompt
, char *default_filename
, int mustmatch_p
, int only_dir_p
)
1509 int filesel_done
= 0;
1510 xg_get_file_func func
;
1512 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1513 /* I really don't know why this is needed, but without this the GLIBC add on
1514 library linuxthreads hangs when the Gnome file chooser backend creates
1516 sigblock (sigmask (__SIGRTMIN
));
1517 #endif /* HAVE_GTK_AND_PTHREAD */
1519 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1521 if (xg_uses_old_file_dialog ())
1522 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1523 mustmatch_p
, only_dir_p
, &func
);
1525 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1526 mustmatch_p
, only_dir_p
, &func
);
1528 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1529 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1530 mustmatch_p
, only_dir_p
, &func
);
1531 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1533 gtk_widget_set_name (w
, "emacs-filedialog");
1535 filesel_done
= xg_dialog_run (f
, w
);
1537 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1538 sigunblock (sigmask (__SIGRTMIN
));
1541 if (filesel_done
== GTK_RESPONSE_OK
)
1544 gtk_widget_destroy (w
);
1548 #ifdef HAVE_FREETYPE
1549 /* Pop up a GTK font selector and return the name of the font the user
1550 selects, as a C string. The returned font name follows GTK's own
1553 `FAMILY [VALUE1 VALUE2] SIZE'
1555 This can be parsed using font_parse_fcname in font.c.
1556 DEFAULT_NAME, if non-zero, is the default font name. */
1559 xg_get_font_name (FRAME_PTR f
, char *default_name
)
1562 char *fontname
= NULL
;
1565 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1566 sigblock (sigmask (__SIGRTMIN
));
1567 #endif /* HAVE_GTK_AND_PTHREAD */
1569 w
= gtk_font_selection_dialog_new ("Pick a font");
1571 default_name
= "Monospace 10";
1572 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1575 gtk_widget_set_name (w
, "emacs-fontdialog");
1577 done
= xg_dialog_run (f
, w
);
1579 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1580 sigunblock (sigmask (__SIGRTMIN
));
1583 if (done
== GTK_RESPONSE_OK
)
1584 fontname
= gtk_font_selection_dialog_get_font_name
1585 (GTK_FONT_SELECTION_DIALOG (w
));
1587 gtk_widget_destroy (w
);
1590 #endif /* HAVE_FREETYPE */
1594 /***********************************************************************
1596 ***********************************************************************/
1598 /* The name of menu items that can be used for customization. Since GTK
1599 RC files are very crude and primitive, we have to set this on all
1600 menu item names so a user can easily customize menu items. */
1602 #define MENU_ITEM_NAME "emacs-menuitem"
1605 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1606 during GC. The next member points to the items. */
1607 static xg_list_node xg_menu_cb_list
;
1609 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1610 during GC. The next member points to the items. */
1611 static xg_list_node xg_menu_item_cb_list
;
1613 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1614 F is the frame CL_DATA will be initialized for.
1615 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1617 The menu bar and all sub menus under the menu bar in a frame
1618 share the same structure, hence the reference count.
1620 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1621 allocated xg_menu_cb_data if CL_DATA is NULL. */
1623 static xg_menu_cb_data
*
1624 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
1628 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1630 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1631 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1632 cl_data
->highlight_cb
= highlight_cb
;
1633 cl_data
->ref_count
= 0;
1635 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1638 cl_data
->ref_count
++;
1643 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1644 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1646 When the menu bar is updated, menu items may have been added and/or
1647 removed, so menu_bar_vector and menu_bar_items_used change. We must
1648 then update CL_DATA since it is used to determine which menu
1649 item that is invoked in the menu.
1650 HIGHLIGHT_CB could change, there is no check that the same
1651 function is given when modifying a menu bar as was given when
1652 creating the menu bar. */
1655 update_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
1660 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1661 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1662 cl_data
->highlight_cb
= highlight_cb
;
1666 /* Decrease reference count for CL_DATA.
1667 If reference count is zero, free CL_DATA. */
1670 unref_cl_data (xg_menu_cb_data
*cl_data
)
1672 if (cl_data
&& cl_data
->ref_count
> 0)
1674 cl_data
->ref_count
--;
1675 if (cl_data
->ref_count
== 0)
1677 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1683 /* Function that marks all lisp data during GC. */
1690 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1691 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1693 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1695 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1697 if (! NILP (cb_data
->help
))
1698 mark_object (cb_data
->help
);
1703 /* Callback called when a menu item is destroyed. Used to free data.
1704 W is the widget that is being destroyed (not used).
1705 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1708 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
1712 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1713 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1718 /* Callback called when the pointer enters/leaves a menu item.
1719 W is the parent of the menu item.
1720 EVENT is either an enter event or leave event.
1721 CLIENT_DATA is not used.
1723 Returns FALSE to tell GTK to keep processing this event. */
1726 menuitem_highlight_callback (GtkWidget
*w
, GdkEventCrossing
*event
, gpointer client_data
)
1729 GtkWidget
*subwidget
;
1730 xg_menu_item_cb_data
*data
;
1732 ev
.crossing
= *event
;
1733 subwidget
= gtk_get_event_widget (&ev
);
1734 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
1738 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1740 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
1741 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1742 (*func
) (subwidget
, call_data
);
1749 /* Callback called when a menu is destroyed. Used to free data.
1750 W is the widget that is being destroyed (not used).
1751 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1754 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
1756 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1759 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1760 must be non-NULL) and can be inserted into a menu item.
1762 Returns the GtkHBox. */
1765 make_widget_for_menu_item (char *utf8_label
, char *utf8_key
)
1771 wbox
= gtk_hbox_new (FALSE
, 0);
1772 wlbl
= gtk_label_new (utf8_label
);
1773 wkey
= gtk_label_new (utf8_key
);
1775 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1776 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1778 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1779 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1781 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1782 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1783 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1788 /* Make and return a menu item widget with the key to the right.
1789 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1790 UTF8_KEY is the text representing the key binding.
1791 ITEM is the widget_value describing the menu item.
1793 GROUP is an in/out parameter. If the menu item to be created is not
1794 part of any radio menu group, *GROUP contains NULL on entry and exit.
1795 If the menu item to be created is part of a radio menu group, on entry
1796 *GROUP contains the group to use, or NULL if this is the first item
1797 in the group. On exit, *GROUP contains the radio item group.
1799 Unfortunately, keys don't line up as nicely as in Motif,
1800 but the MacOS X version doesn't either, so I guess that is OK. */
1803 make_menu_item (char *utf8_label
, char *utf8_key
, widget_value
*item
, GSList
**group
)
1806 GtkWidget
*wtoadd
= 0;
1808 /* It has been observed that some menu items have a NULL name field.
1809 This will lead to this function being called with a NULL utf8_label.
1810 GTK crashes on that so we set a blank label. Why there is a NULL
1811 name remains to be investigated. */
1812 if (! utf8_label
) utf8_label
= " ";
1815 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1817 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1820 if (utf8_key
) w
= gtk_check_menu_item_new ();
1821 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1822 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1824 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1826 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1827 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1828 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1830 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1835 if (utf8_key
) w
= gtk_menu_item_new ();
1836 else w
= gtk_menu_item_new_with_label (utf8_label
);
1839 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1840 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1845 /* Return non-zero if LABEL specifies a separator (GTK only has one
1848 static const char* separator_names
[] = {
1853 "single-dashed-line",
1854 "double-dashed-line",
1856 "shadow-etched-out",
1857 "shadow-etched-in-dash",
1858 "shadow-etched-out-dash",
1859 "shadow-double-etched-in",
1860 "shadow-double-etched-out",
1861 "shadow-double-etched-in-dash",
1862 "shadow-double-etched-out-dash",
1867 xg_separator_p (char *label
)
1869 if (! label
) return 0;
1870 else if (strlen (label
) > 3
1871 && strncmp (label
, "--", 2) == 0
1877 for (i
= 0; separator_names
[i
]; ++i
)
1878 if (strcmp (label
, separator_names
[i
]) == 0)
1883 /* Old-style separator, maybe. It's a separator if it contains
1885 while (*label
== '-')
1887 if (*label
== 0) return 1;
1893 static int xg_detached_menus
;
1895 /* Returns non-zero if there are detached menus. */
1898 xg_have_tear_offs (void)
1900 return xg_detached_menus
> 0;
1903 /* Callback invoked when a detached menu window is removed. Here we
1904 decrease the xg_detached_menus count.
1905 WIDGET is the top level window that is removed (the parent of the menu).
1906 CLIENT_DATA is not used. */
1909 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
1911 if (xg_detached_menus
> 0) --xg_detached_menus
;
1914 /* Callback invoked when a menu is detached. It increases the
1915 xg_detached_menus count.
1916 WIDGET is the GtkTearoffMenuItem.
1917 CLIENT_DATA is not used. */
1920 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
1922 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
1923 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
1925 ++xg_detached_menus
;
1926 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
1928 G_CALLBACK (tearoff_remove
), 0);
1933 /* Create a menu item widget, and connect the callbacks.
1934 ITEM decribes the menu item.
1935 F is the frame the created menu belongs to.
1936 SELECT_CB is the callback to use when a menu item is selected.
1937 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1938 CL_DATA points to the callback data to be used for this menu.
1939 GROUP is an in/out parameter. If the menu item to be created is not
1940 part of any radio menu group, *GROUP contains NULL on entry and exit.
1941 If the menu item to be created is part of a radio menu group, on entry
1942 *GROUP contains the group to use, or NULL if this is the first item
1943 in the group. On exit, *GROUP contains the radio item group.
1945 Returns the created GtkWidget. */
1948 xg_create_one_menuitem (widget_value
*item
, FRAME_PTR f
, GCallback select_cb
, GCallback highlight_cb
, xg_menu_cb_data
*cl_data
, GSList
**group
)
1953 xg_menu_item_cb_data
*cb_data
;
1955 utf8_label
= get_utf8_string (item
->name
);
1956 utf8_key
= get_utf8_string (item
->key
);
1958 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
1960 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
1961 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
1963 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
1965 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
1967 cb_data
->select_id
= 0;
1968 cb_data
->help
= item
->help
;
1969 cb_data
->cl_data
= cl_data
;
1970 cb_data
->call_data
= item
->call_data
;
1972 g_signal_connect (G_OBJECT (w
),
1974 G_CALLBACK (menuitem_destroy_callback
),
1977 /* Put cb_data in widget, so we can get at it when modifying menubar */
1978 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
1980 /* final item, not a submenu */
1981 if (item
->call_data
&& ! item
->contents
)
1985 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
1991 static GtkWidget
*create_menus (widget_value
*, FRAME_PTR
, GCallback
,
1992 GCallback
, GCallback
, int, int, int,
1993 GtkWidget
*, xg_menu_cb_data
*, char *);
1995 /* Create a full menu tree specified by DATA.
1996 F is the frame the created menu belongs to.
1997 SELECT_CB is the callback to use when a menu item is selected.
1998 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
1999 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2000 POP_UP_P is non-zero if we shall create a popup menu.
2001 MENU_BAR_P is non-zero if we shall create a menu bar.
2002 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2003 if MENU_BAR_P is non-zero.
2004 TOPMENU is the topmost GtkWidget that others shall be placed under.
2005 It may be NULL, in that case we create the appropriate widget
2006 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2007 CL_DATA is the callback data we shall use for this menu, or NULL
2008 if we haven't set the first callback yet.
2009 NAME is the name to give to the top level menu if this function
2010 creates it. May be NULL to not set any name.
2012 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2015 This function calls itself to create submenus. */
2018 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2019 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
2022 GCallback select_cb
;
2023 GCallback deactivate_cb
;
2024 GCallback highlight_cb
;
2029 xg_menu_cb_data
*cl_data
;
2033 GtkWidget
*wmenu
= topmenu
;
2034 GSList
*group
= NULL
;
2040 wmenu
= gtk_menu_new ();
2041 xg_set_screen (wmenu
, f
);
2042 /* Connect this to the menu instead of items so we get enter/leave for
2043 disabled items also. TODO: Still does not get enter/leave for
2044 disabled items in detached menus. */
2045 g_signal_connect (G_OBJECT (wmenu
),
2046 "enter-notify-event",
2047 G_CALLBACK (menuitem_highlight_callback
),
2049 g_signal_connect (G_OBJECT (wmenu
),
2050 "leave-notify-event",
2051 G_CALLBACK (menuitem_highlight_callback
),
2056 wmenu
= gtk_menu_bar_new ();
2057 /* Set width of menu bar to a small value so it doesn't enlarge
2058 a small initial frame size. The width will be set to the
2059 width of the frame later on when it is added to a container.
2060 height -1: Natural height. */
2061 gtk_widget_set_size_request (wmenu
, 1, -1);
2064 /* Put cl_data on the top menu for easier access. */
2065 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2066 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2067 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2068 G_CALLBACK (menu_destroy_callback
), cl_data
);
2071 gtk_widget_set_name (wmenu
, name
);
2074 g_signal_connect (G_OBJECT (wmenu
),
2075 "selection-done", deactivate_cb
, 0);
2078 if (! menu_bar_p
&& add_tearoff_p
)
2080 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2081 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2083 g_signal_connect (G_OBJECT (tearoff
), "activate",
2084 G_CALLBACK (tearoff_activate
), 0);
2087 for (item
= data
; item
; item
= item
->next
)
2091 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2092 && !xg_separator_p (item
->name
))
2095 /* A title for a popup. We do the same as GTK does when
2096 creating titles, but it does not look good. */
2098 utf8_label
= get_utf8_string (item
->name
);
2100 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2101 w
= gtk_menu_item_new_with_label (utf8_label
);
2102 gtk_widget_set_sensitive (w
, FALSE
);
2103 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2105 else if (xg_separator_p (item
->name
))
2108 /* GTK only have one separator type. */
2109 w
= gtk_separator_menu_item_new ();
2113 w
= xg_create_one_menuitem (item
,
2115 item
->contents
? 0 : select_cb
,
2120 /* Create a possibly empty submenu for menu bar items, since some
2121 themes don't highlight items correctly without it. */
2122 if (item
->contents
|| menu_bar_p
)
2124 GtkWidget
*submenu
= create_menus (item
->contents
,
2135 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2139 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2140 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2146 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2147 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2148 with some text and buttons.
2149 F is the frame the created item belongs to.
2150 NAME is the name to use for the top widget.
2151 VAL is a widget_value structure describing items to be created.
2152 SELECT_CB is the callback to use when a menu item is selected or
2153 a dialog button is pressed.
2154 DEACTIVATE_CB is the callback to use when an item is deactivated.
2155 For a menu, when a sub menu is not shown anymore, for a dialog it is
2156 called when the dialog is popped down.
2157 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2159 Returns the widget created. */
2162 xg_create_widget (type
, name
, f
, val
,
2163 select_cb
, deactivate_cb
, highlight_cb
)
2168 GCallback select_cb
;
2169 GCallback deactivate_cb
;
2170 GCallback highlight_cb
;
2173 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2174 int pop_up_p
= strcmp (type
, "popup") == 0;
2176 if (strcmp (type
, "dialog") == 0)
2178 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2179 xg_set_screen (w
, f
);
2180 gtk_window_set_transient_for (GTK_WINDOW (w
),
2181 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2182 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2183 gtk_widget_set_name (w
, "emacs-dialog");
2184 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2186 else if (menu_bar_p
|| pop_up_p
)
2188 w
= create_menus (val
->contents
,
2200 /* Set the cursor to an arrow for popup menus when they are mapped.
2201 This is done by default for menu bar menus. */
2204 /* Must realize so the GdkWindow inside the widget is created. */
2205 gtk_widget_realize (w
);
2206 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2211 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2218 /* Return the label for menu item WITEM. */
2221 xg_get_menu_item_label (GtkMenuItem
*witem
)
2223 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2224 return gtk_label_get_label (wlabel
);
2227 /* Return non-zero if the menu item WITEM has the text LABEL. */
2230 xg_item_label_same_p (GtkMenuItem
*witem
, char *label
)
2233 char *utf8_label
= get_utf8_string (label
);
2234 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2236 if (! old_label
&& ! utf8_label
)
2238 else if (old_label
&& utf8_label
)
2239 is_same
= strcmp (utf8_label
, old_label
) == 0;
2241 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2246 /* Destroy widgets in LIST. */
2249 xg_destroy_widgets (GList
*list
)
2253 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2255 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2257 /* Destroying the widget will remove it from the container it is in. */
2258 gtk_widget_destroy (w
);
2262 /* Update the top level names in MENUBAR (i.e. not submenus).
2263 F is the frame the menu bar belongs to.
2264 *LIST is a list with the current menu bar names (menu item widgets).
2265 ITER is the item within *LIST that shall be updated.
2266 POS is the numerical position, starting at 0, of ITER in *LIST.
2267 VAL describes what the menu bar shall look like after the update.
2268 SELECT_CB is the callback to use when a menu item is selected.
2269 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2270 CL_DATA points to the callback data to be used for this menu bar.
2272 This function calls itself to walk through the menu bar names. */
2275 xg_update_menubar (GtkWidget
*menubar
,
2281 GCallback select_cb
,
2282 GCallback deactivate_cb
,
2283 GCallback highlight_cb
,
2284 xg_menu_cb_data
*cl_data
)
2286 if (! iter
&& ! val
)
2288 else if (iter
&& ! val
)
2290 /* Item(s) have been removed. Remove all remaining items. */
2291 xg_destroy_widgets (iter
);
2293 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2294 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2295 gtk_menu_item_new_with_label (""),
2301 else if (! iter
&& val
)
2303 /* Item(s) added. Add all new items in one call. */
2304 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2305 0, 1, 0, menubar
, cl_data
, 0);
2311 /* Below this neither iter or val is NULL */
2312 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2314 /* This item is still the same, check next item. */
2316 iter
= g_list_next (iter
);
2319 else /* This item is changed. */
2321 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2322 GtkMenuItem
*witem2
= 0;
2323 int val_in_menubar
= 0;
2324 int iter_in_new_menubar
= 0;
2328 /* See if the changed entry (val) is present later in the menu bar */
2330 iter2
&& ! val_in_menubar
;
2331 iter2
= g_list_next (iter2
))
2333 witem2
= GTK_MENU_ITEM (iter2
->data
);
2334 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2337 /* See if the current entry (iter) is present later in the
2338 specification for the new menu bar. */
2339 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2340 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2342 if (val_in_menubar
&& ! iter_in_new_menubar
)
2346 /* This corresponds to:
2351 g_object_ref (G_OBJECT (witem
));
2352 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2353 gtk_widget_destroy (GTK_WIDGET (witem
));
2355 /* Must get new list since the old changed. */
2356 g_list_free (*list
);
2357 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2358 while (nr
-- > 0) iter
= g_list_next (iter
);
2360 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2362 /* This corresponds to:
2365 Rename B to X. This might seem to be a strange thing to do,
2366 since if there is a menu under B it will be totally wrong for X.
2367 But consider editing a C file. Then there is a C-mode menu
2368 (corresponds to B above).
2369 If then doing C-x C-f the minibuf menu (X above) replaces the
2370 C-mode menu. When returning from the minibuffer, we get
2371 back the C-mode menu. Thus we do:
2372 Rename B to X (C-mode to minibuf menu)
2373 Rename X to B (minibuf to C-mode menu).
2374 If the X menu hasn't been invoked, the menu under B
2375 is up to date when leaving the minibuffer. */
2376 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2377 char *utf8_label
= get_utf8_string (val
->name
);
2378 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2380 gtk_label_set_text (wlabel
, utf8_label
);
2382 /* If this item has a submenu that has been detached, change
2383 the title in the WM decorations also. */
2384 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2385 /* Set the title of the detached window. */
2386 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2388 iter
= g_list_next (iter
);
2392 else if (! val_in_menubar
&& iter_in_new_menubar
)
2394 /* This corresponds to:
2401 GtkWidget
*w
= xg_create_one_menuitem (val
,
2408 /* Create a possibly empty submenu for menu bar items, since some
2409 themes don't highlight items correctly without it. */
2410 GtkWidget
*submenu
= create_menus (NULL
, f
,
2411 select_cb
, deactivate_cb
,
2413 0, 0, 0, 0, cl_data
, 0);
2414 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2415 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2416 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2418 g_list_free (*list
);
2419 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2420 while (nr
-- > 0) iter
= g_list_next (iter
);
2421 iter
= g_list_next (iter
);
2425 else /* if (val_in_menubar && iter_in_new_menubar) */
2428 /* This corresponds to:
2433 g_object_ref (G_OBJECT (witem2
));
2434 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2435 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2436 GTK_WIDGET (witem2
), pos
);
2437 g_object_unref (G_OBJECT (witem2
));
2439 g_list_free (*list
);
2440 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2441 while (nr
-- > 0) iter
= g_list_next (iter
);
2442 if (iter
) iter
= g_list_next (iter
);
2448 /* Update the rest of the menu bar. */
2449 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2450 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2453 /* Update the menu item W so it corresponds to VAL.
2454 SELECT_CB is the callback to use when a menu item is selected.
2455 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2456 CL_DATA is the data to set in the widget for menu invocation. */
2459 xg_update_menu_item (widget_value
*val
, GtkWidget
*w
, GCallback select_cb
, GCallback highlight_cb
, xg_menu_cb_data
*cl_data
)
2466 const char *old_label
= 0;
2467 const char *old_key
= 0;
2468 xg_menu_item_cb_data
*cb_data
;
2470 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2471 utf8_label
= get_utf8_string (val
->name
);
2472 utf8_key
= get_utf8_string (val
->key
);
2474 /* See if W is a menu item with a key. See make_menu_item above. */
2475 if (GTK_IS_HBOX (wchild
))
2477 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2479 wlbl
= GTK_LABEL (list
->data
);
2480 wkey
= GTK_LABEL (list
->next
->data
);
2485 /* Remove the key and keep just the label. */
2486 g_object_ref (G_OBJECT (wlbl
));
2487 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2488 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2489 g_object_unref (G_OBJECT (wlbl
));
2494 else /* Just a label. */
2496 wlbl
= GTK_LABEL (wchild
);
2498 /* Check if there is now a key. */
2501 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2502 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2504 wlbl
= GTK_LABEL (list
->data
);
2505 wkey
= GTK_LABEL (list
->next
->data
);
2508 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2509 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2514 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2515 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2517 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2518 gtk_label_set_text (wkey
, utf8_key
);
2520 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2521 gtk_label_set_text (wlbl
, utf8_label
);
2523 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2524 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2526 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2527 gtk_widget_set_sensitive (w
, FALSE
);
2528 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2529 gtk_widget_set_sensitive (w
, TRUE
);
2531 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2535 cb_data
->call_data
= val
->call_data
;
2536 cb_data
->help
= val
->help
;
2537 cb_data
->cl_data
= cl_data
;
2539 /* We assume the callback functions don't change. */
2540 if (val
->call_data
&& ! val
->contents
)
2542 /* This item shall have a select callback. */
2543 if (! cb_data
->select_id
)
2545 = g_signal_connect (G_OBJECT (w
), "activate",
2546 select_cb
, cb_data
);
2548 else if (cb_data
->select_id
)
2550 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2551 cb_data
->select_id
= 0;
2556 /* Update the toggle menu item W so it corresponds to VAL. */
2559 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
2561 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2564 /* Update the radio menu item W so it corresponds to VAL. */
2567 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
2569 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2572 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2573 SUBMENU may be NULL, in that case a new menu is created.
2574 F is the frame the menu bar belongs to.
2575 VAL describes the contents of the menu bar.
2576 SELECT_CB is the callback to use when a menu item is selected.
2577 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2578 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2579 CL_DATA is the call back data to use for any newly created items.
2581 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2585 xg_update_submenu (GtkWidget
*submenu
,
2588 GCallback select_cb
,
2589 GCallback deactivate_cb
,
2590 GCallback highlight_cb
,
2591 xg_menu_cb_data
*cl_data
)
2593 GtkWidget
*newsub
= submenu
;
2597 int has_tearoff_p
= 0;
2598 GList
*first_radio
= 0;
2601 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2603 for (cur
= val
, iter
= list
;
2605 iter
= g_list_next (iter
), cur
= cur
->next
)
2607 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2609 /* Skip tearoff items, they have no counterpart in val. */
2610 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2613 iter
= g_list_next (iter
);
2614 if (iter
) w
= GTK_WIDGET (iter
->data
);
2618 /* Remember first radio button in a group. If we get a mismatch in
2619 a radio group we must rebuild the whole group so that the connections
2620 in GTK becomes correct. */
2621 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2623 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2624 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2627 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2629 if (! xg_separator_p (cur
->name
))
2632 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2634 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2636 xg_update_toggle_item (cur
, w
);
2637 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2639 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2641 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2643 xg_update_radio_item (cur
, w
);
2644 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2646 else if (GTK_IS_MENU_ITEM (w
))
2648 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2651 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2652 xg_separator_p (cur
->name
))
2655 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2657 sub
= gtk_menu_item_get_submenu (witem
);
2658 if (sub
&& ! cur
->contents
)
2660 /* Not a submenu anymore. */
2661 g_object_ref (G_OBJECT (sub
));
2662 remove_submenu (witem
);
2663 gtk_widget_destroy (sub
);
2665 else if (cur
->contents
)
2669 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2670 select_cb
, deactivate_cb
,
2671 highlight_cb
, cl_data
);
2673 /* If this item just became a submenu, we must set it. */
2675 gtk_menu_item_set_submenu (witem
, nsub
);
2680 /* Structural difference. Remove everything from here and down
2686 /* Remove widgets from first structual change. */
2689 /* If we are adding new menu items below, we must remove from
2690 first radio button so that radio groups become correct. */
2691 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2692 else xg_destroy_widgets (iter
);
2697 /* More items added. Create them. */
2698 newsub
= create_menus (cur
,
2711 if (list
) g_list_free (list
);
2716 /* Update the MENUBAR.
2717 F is the frame the menu bar belongs to.
2718 VAL describes the contents of the menu bar.
2719 If DEEP_P is non-zero, rebuild all but the top level menu names in
2720 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2721 SELECT_CB is the callback to use when a menu item is selected.
2722 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2723 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2726 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2727 select_cb
, deactivate_cb
, highlight_cb
)
2732 GCallback select_cb
;
2733 GCallback deactivate_cb
;
2734 GCallback highlight_cb
;
2736 xg_menu_cb_data
*cl_data
;
2737 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2741 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2744 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2745 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2751 /* Update all sub menus.
2752 We must keep the submenus (GTK menu item widgets) since the
2753 X Window in the XEvent that activates the menu are those widgets. */
2755 /* Update cl_data, menu_item things in F may have changed. */
2756 update_cl_data (cl_data
, f
, highlight_cb
);
2758 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2765 /* Find sub menu that corresponds to val and update it. */
2766 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2768 witem
= GTK_MENU_ITEM (iter
->data
);
2769 if (xg_item_label_same_p (witem
, cur
->name
))
2771 sub
= gtk_menu_item_get_submenu (witem
);
2776 newsub
= xg_update_submenu (sub
,
2783 /* sub may still be NULL. If we just updated non deep and added
2784 a new menu bar item, it has no sub menu yet. So we set the
2785 newly created sub menu under witem. */
2788 xg_set_screen (newsub
, f
);
2789 gtk_menu_item_set_submenu (witem
, newsub
);
2795 gtk_widget_show_all (menubar
);
2798 /* Recompute all the widgets of frame F, when the menu bar has been
2799 changed. Value is non-zero if widgets were updated. */
2802 xg_update_frame_menubar (FRAME_PTR f
)
2804 struct x_output
*x
= f
->output_data
.x
;
2807 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
2810 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
2811 return 0; /* Already done this, happens for frames created invisible. */
2815 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2817 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2819 gtk_widget_show_all (x
->menubar_widget
);
2820 gtk_widget_size_request (x
->menubar_widget
, &req
);
2821 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2822 xg_height_changed (f
);
2828 /* Get rid of the menu bar of frame F, and free its storage.
2829 This is used when deleting a frame, and when turning off the menu bar. */
2832 free_frame_menubar (FRAME_PTR f
)
2834 struct x_output
*x
= f
->output_data
.x
;
2836 if (x
->menubar_widget
)
2840 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2841 /* The menubar and its children shall be deleted when removed from
2843 x
->menubar_widget
= 0;
2844 FRAME_MENUBAR_HEIGHT (f
) = 0;
2845 xg_height_changed (f
);
2852 /***********************************************************************
2853 Scroll bar functions
2854 ***********************************************************************/
2857 /* Setting scroll bar values invokes the callback. Use this variable
2858 to indicate that callback should do nothing. */
2860 int xg_ignore_gtk_scrollbar
;
2862 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
2863 may be larger than 32 bits. Keep a mapping from integer index to widget
2864 pointers to get around the 32 bit limitation. */
2868 GtkWidget
**widgets
;
2873 /* Grow this much every time we need to allocate more */
2875 #define ID_TO_WIDGET_INCR 32
2877 /* Store the widget pointer W in id_to_widget and return the integer index. */
2880 xg_store_widget_in_map (GtkWidget
*w
)
2884 if (id_to_widget
.max_size
== id_to_widget
.used
)
2886 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
2888 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
2889 sizeof (GtkWidget
*)*new_size
);
2891 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
2892 id_to_widget
.widgets
[i
] = 0;
2893 id_to_widget
.max_size
= new_size
;
2896 /* Just loop over the array and find a free place. After all,
2897 how many scroll bars are we creating? Should be a small number.
2898 The check above guarantees we will find a free place. */
2899 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
2901 if (! id_to_widget
.widgets
[i
])
2903 id_to_widget
.widgets
[i
] = w
;
2904 ++id_to_widget
.used
;
2910 /* Should never end up here */
2914 /* Remove pointer at IDX from id_to_widget.
2915 Called when scroll bar is destroyed. */
2918 xg_remove_widget_from_map (int idx
)
2920 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2922 id_to_widget
.widgets
[idx
] = 0;
2923 --id_to_widget
.used
;
2927 /* Get the widget pointer at IDX from id_to_widget. */
2930 xg_get_widget_from_map (int idx
)
2932 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2933 return id_to_widget
.widgets
[idx
];
2938 /* Return the scrollbar id for X Window WID on display DPY.
2939 Return -1 if WID not in id_to_widget. */
2942 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
2947 w
= xg_win_to_widget (dpy
, wid
);
2951 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
2952 if (id_to_widget
.widgets
[idx
] == w
)
2959 /* Callback invoked when scroll bar WIDGET is destroyed.
2960 DATA is the index into id_to_widget for WIDGET.
2961 We free pointer to last scroll bar values here and remove the index. */
2964 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
2966 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
2967 xg_remove_widget_from_map (id
);
2970 /* Create a scroll bar widget for frame F. Store the scroll bar
2972 SCROLL_CALLBACK is the callback to invoke when the value of the
2974 END_CALLBACK is the callback to invoke when scrolling ends.
2975 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
2976 to set resources for the widget. */
2979 xg_create_scroll_bar (FRAME_PTR f
, struct scroll_bar
*bar
, GCallback scroll_callback
, GCallback end_callback
, char *scroll_bar_name
)
2986 /* Page, step increment values are not so important here, they
2987 will be corrected in x_set_toolkit_scroll_bar_thumb. */
2988 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
2991 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
2992 webox
= gtk_event_box_new ();
2993 gtk_widget_set_name (wscroll
, scroll_bar_name
);
2994 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
2995 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
2997 scroll_id
= xg_store_widget_in_map (wscroll
);
2999 /* The EMACS_INT cast avoids a warning. */
3000 g_signal_connect (G_OBJECT (wscroll
),
3002 G_CALLBACK (xg_gtk_scroll_destroy
),
3003 (gpointer
) (EMACS_INT
) scroll_id
);
3004 g_signal_connect (G_OBJECT (wscroll
),
3008 g_signal_connect (G_OBJECT (wscroll
),
3009 "button-release-event",
3013 /* The scroll bar widget does not draw on a window of its own. Instead
3014 it draws on the parent window, in this case the edit widget. So
3015 whenever the edit widget is cleared, the scroll bar needs to redraw
3016 also, which causes flicker. Put an event box between the edit widget
3017 and the scroll bar, so the scroll bar instead draws itself on the
3018 event box window. */
3019 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3020 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3023 /* Set the cursor to an arrow. */
3024 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3026 bar
->x_window
= scroll_id
;
3029 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3032 xg_remove_scroll_bar (FRAME_PTR f
, int scrollbar_id
)
3034 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3037 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3038 gtk_widget_destroy (w
);
3039 gtk_widget_destroy (wparent
);
3040 SET_FRAME_GARBAGED (f
);
3044 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3046 TOP/LEFT are the new pixel positions where the bar shall appear.
3047 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3050 xg_update_scrollbar_pos (FRAME_PTR f
, int scrollbar_id
, int top
, int left
, int width
, int height
)
3053 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3057 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3058 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3061 /* Clear out old position. */
3062 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3063 if (gtk_widget_get_parent (wparent
) == wfixed
)
3065 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3066 "x", &oldx
, "y", &oldy
, NULL
);
3067 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3070 /* Move and resize to new values. */
3071 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3072 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3075 /* No room. Hide scroll bar as some themes output a warning if
3076 the height is less than the min size. */
3077 gtk_widget_hide (wparent
);
3078 gtk_widget_hide (wscroll
);
3082 gtk_widget_show_all (wparent
);
3083 gtk_widget_set_size_request (wscroll
, width
, height
);
3085 gtk_widget_queue_draw (wfixed
);
3086 gdk_window_process_all_updates ();
3087 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3089 /* Clear under old scroll bar position. This must be done after
3090 the gtk_widget_queue_draw and gdk_window_process_all_updates
3092 x_clear_area (FRAME_X_DISPLAY (f
),
3094 oldx
, oldy
, oldw
, oldh
, 0);
3097 /* GTK does not redraw until the main loop is entered again, but
3098 if there are no X events pending we will not enter it. So we sync
3099 here to get some events. */
3102 SET_FRAME_GARBAGED (f
);
3103 cancel_mouse_face (f
);
3107 /* Set the thumb size and position of scroll bar BAR. We are currently
3108 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3111 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
3113 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3115 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3117 if (wscroll
&& NILP (bar
->dragging
))
3126 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3128 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3129 rather than the real portion value. This makes the thumb less likely
3130 to resize and that looks better. */
3131 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3132 /* When the thumb is at the bottom, position == whole.
3133 So we need to increase `whole' to make space for the thumb. */
3140 top
= (gdouble
) position
/ whole
;
3141 shown
= (gdouble
) portion
/ whole
;
3144 size
= shown
* XG_SB_RANGE
;
3145 size
= min (size
, XG_SB_RANGE
);
3146 size
= max (size
, 1);
3148 value
= top
* XG_SB_RANGE
;
3149 value
= min (value
, XG_SB_MAX
- size
);
3150 value
= max (value
, XG_SB_MIN
);
3152 /* Assume all lines are of equal size. */
3153 new_step
= size
/ max (1, FRAME_LINES (f
));
3155 if ((int) gtk_adjustment_get_page_size (adj
) != size
3156 || (int) gtk_adjustment_get_step_increment (adj
) != new_step
)
3158 gtk_adjustment_set_page_size (adj
, size
);
3159 gtk_adjustment_set_step_increment (adj
, new_step
);
3160 /* Assume a page increment is about 95% of the page size */
3161 gtk_adjustment_set_page_increment (adj
,(int) (0.95*size
));
3165 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3169 /* gtk_range_set_value invokes the callback. Set
3170 ignore_gtk_scrollbar to make the callback do nothing */
3171 xg_ignore_gtk_scrollbar
= 1;
3173 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3174 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3176 gtk_adjustment_changed (adj
);
3178 xg_ignore_gtk_scrollbar
= 0;
3185 /* Return non-zero if EVENT is for a scroll bar in frame F.
3186 When the same X window is used for several Gtk+ widgets, we cannot
3187 say for sure based on the X window alone if an event is for the
3188 frame. This function does additional checks.
3190 Return non-zero if the event is for a scroll bar, zero otherwise. */
3193 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3197 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3199 /* Check if press occurred outside the edit widget. */
3200 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3201 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3202 != gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3205 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3206 || event
->type
== MotionNotify
))
3208 /* If we are releasing or moving the scroll bar, it has the grab. */
3209 GtkWidget
*w
= gtk_grab_get_current ();
3210 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3218 /***********************************************************************
3220 ***********************************************************************/
3221 /* The key for the data we put in the GtkImage widgets. The data is
3222 the image used by Emacs. We use this to see if we need to update
3223 the GtkImage with a new image. */
3224 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3226 /* The key for storing the latest modifiers so the activate callback can
3228 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3230 /* The key for storing the button widget in its proxy menu item. */
3231 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3233 /* The key for the data we put in the GtkImage widgets. The data is
3234 the stock name used by Emacs. We use this to see if we need to update
3235 the GtkImage with a new image. */
3236 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3238 /* As above, but this is used for named theme widgets, as opposed to
3240 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3242 /* Callback function invoked when a tool bar item is pressed.
3243 W is the button widget in the tool bar that got pressed,
3244 CLIENT_DATA is an integer that is the index of the button in the
3245 tool bar. 0 is the first button. */
3248 xg_tool_bar_button_cb (GtkWidget
*widget
, GdkEventButton
*event
, gpointer user_data
)
3250 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3251 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3252 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3257 /* Callback function invoked when a tool bar item is pressed.
3258 W is the button widget in the tool bar that got pressed,
3259 CLIENT_DATA is an integer that is the index of the button in the
3260 tool bar. 0 is the first button. */
3263 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3265 /* The EMACS_INT cast avoids a warning. */
3266 int idx
= (int) (EMACS_INT
) client_data
;
3267 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3268 XG_TOOL_BAR_LAST_MODIFIER
);
3270 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3271 Lisp_Object key
, frame
;
3272 struct input_event event
;
3275 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3278 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3280 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3281 XSETFRAME (frame
, f
);
3283 /* We generate two events here. The first one is to set the prefix
3284 to `(tool_bar)', see keyboard.c. */
3285 event
.kind
= TOOL_BAR_EVENT
;
3286 event
.frame_or_window
= frame
;
3288 kbd_buffer_store_event (&event
);
3290 event
.kind
= TOOL_BAR_EVENT
;
3291 event
.frame_or_window
= frame
;
3293 /* Convert between the modifier bits GDK uses and the modifier bits
3294 Emacs uses. This assumes GDK and X masks are the same, which they are when
3296 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3297 kbd_buffer_store_event (&event
);
3299 /* Return focus to the frame after we have clicked on a detached
3301 Fx_focus_frame (frame
);
3304 /* Callback function invoked when a tool bar item is pressed in a detached
3305 tool bar or the overflow drop down menu.
3306 We just call xg_tool_bar_callback.
3307 W is the menu item widget that got pressed,
3308 CLIENT_DATA is an integer that is the index of the button in the
3309 tool bar. 0 is the first button. */
3312 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3314 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3315 XG_TOOL_BAR_PROXY_BUTTON
));
3316 xg_tool_bar_callback (wbutton
, client_data
);
3321 xg_tool_bar_help_callback (GtkWidget
*w
,
3322 GdkEventCrossing
*event
,
3323 gpointer client_data
);
3325 /* This callback is called when a help is to be shown for an item in
3326 the detached tool bar when the detached tool bar it is not expanded. */
3329 xg_tool_bar_proxy_help_callback (GtkWidget
*w
, GdkEventCrossing
*event
, gpointer client_data
)
3331 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3332 XG_TOOL_BAR_PROXY_BUTTON
));
3334 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3338 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3340 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3341 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3342 GtkWidget
*c2
= (GtkWidget
*) clist
->next
->data
;
3343 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3344 g_list_free (clist
);
3345 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3349 /* This callback is called when a tool item should create a proxy item,
3350 such as for the overflow menu. Also called when the tool bar is detached.
3351 If we don't create a proxy menu item, the detached tool bar will be
3355 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3357 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (toolitem
));
3358 GtkButton
*wbutton
= GTK_BUTTON (gtk_bin_get_child (GTK_BIN (weventbox
)));
3359 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
3361 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3362 GtkImage
*wimage
= GTK_IMAGE (c1
);
3363 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3364 (gtk_label_get_text (wlbl
));
3365 GtkWidget
*wmenuimage
;
3368 if (gtk_button_get_use_stock (wbutton
))
3369 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3370 GTK_ICON_SIZE_MENU
);
3373 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3374 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3376 if (store_type
== GTK_IMAGE_STOCK
)
3379 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3380 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3382 else if (store_type
== GTK_IMAGE_ICON_SET
)
3384 GtkIconSet
*icon_set
;
3385 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3386 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3387 GTK_ICON_SIZE_MENU
);
3389 else if (store_type
== GTK_IMAGE_PIXBUF
)
3394 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3397 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3399 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3400 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3401 GDK_INTERP_BILINEAR
);
3403 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3407 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3411 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3413 const gchar
*icon_name
;
3414 GtkIconSize icon_size
;
3416 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3417 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3418 GTK_ICON_SIZE_MENU
);
3422 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3427 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3429 g_signal_connect (G_OBJECT (wmenuitem
),
3431 G_CALLBACK (xg_tool_bar_proxy_callback
),
3435 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3436 (gpointer
) wbutton
);
3437 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3438 gtk_widget_set_sensitive (wmenuitem
,
3439 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
3441 /* Use enter/leave notify to show help. We use the events
3442 rather than the GtkButton specific signals "enter" and
3443 "leave", so we can have only one callback. The event
3444 will tell us what kind of event it is. */
3445 g_signal_connect (G_OBJECT (wmenuitem
),
3446 "enter-notify-event",
3447 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3449 g_signal_connect (G_OBJECT (wmenuitem
),
3450 "leave-notify-event",
3451 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3457 /* This callback is called when a tool bar is detached. We must set
3458 the height of the tool bar to zero when this happens so frame sizes
3459 are correctly calculated.
3460 WBOX is the handle box widget that enables detach/attach of the tool bar.
3461 W is the tool bar widget.
3462 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3465 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
, GtkWidget
*w
, gpointer client_data
)
3467 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3468 extern int x_gtk_whole_detached_tool_bar
;
3470 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3475 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3477 /* When detaching a tool bar, not everything dissapear. There are
3478 a few pixels left that are used to drop the tool bar back into
3480 FRAME_TOOLBAR_HEIGHT (f
) = 4;
3481 xg_height_changed (f
);
3485 /* This callback is called when a tool bar is reattached. We must set
3486 the height of the tool bar when this happens so frame sizes
3487 are correctly calculated.
3488 WBOX is the handle box widget that enables detach/attach of the tool bar.
3489 W is the tool bar widget.
3490 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3493 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
, GtkWidget
*w
, gpointer client_data
)
3495 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3496 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3502 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3504 gtk_widget_size_request (w
, &req
);
3505 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3506 xg_height_changed (f
);
3510 /* This callback is called when the mouse enters or leaves a tool bar item.
3511 It is used for displaying and hiding the help text.
3512 W is the tool bar item, a button.
3513 EVENT is either an enter event or leave event.
3514 CLIENT_DATA is an integer that is the index of the button in the
3515 tool bar. 0 is the first button.
3517 Returns FALSE to tell GTK to keep processing this event. */
3520 xg_tool_bar_help_callback (GtkWidget
*w
, GdkEventCrossing
*event
, gpointer client_data
)
3522 /* The EMACS_INT cast avoids a warning. */
3523 int idx
= (int) (EMACS_INT
) client_data
;
3524 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3525 Lisp_Object help
, frame
;
3527 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3530 if (event
->type
== GDK_ENTER_NOTIFY
)
3532 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3533 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3536 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3541 XSETFRAME (frame
, f
);
3542 kbd_buffer_store_help_event (frame
, help
);
3548 /* This callback is called when a tool bar item shall be redrawn.
3549 It modifies the expose event so that the GtkImage widget redraws the
3550 whole image. This to overcome a bug that makes GtkImage draw the image
3551 in the wrong place when it tries to redraw just a part of the image.
3552 W is the GtkImage to be redrawn.
3553 EVENT is the expose event for W.
3554 CLIENT_DATA is unused.
3556 Returns FALSE to tell GTK to keep processing this event. */
3559 xg_tool_bar_item_expose_callback (GtkWidget
*w
, GdkEventExpose
*event
, gpointer client_data
)
3563 gdk_drawable_get_size (event
->window
, &width
, &height
);
3565 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3566 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3568 event
->area
.x
= max (0, event
->area
.x
);
3569 event
->area
.y
= max (0, event
->area
.y
);
3571 event
->area
.width
= max (width
, event
->area
.width
);
3572 event
->area
.height
= max (height
, event
->area
.height
);
3577 /* Attach a tool bar to frame F. */
3580 xg_pack_tool_bar (FRAME_PTR f
)
3582 struct x_output
*x
= f
->output_data
.x
;
3583 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3585 x
->handlebox_widget
= gtk_handle_box_new ();
3586 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3587 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3588 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3589 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3591 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3594 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3597 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3600 gtk_widget_show (x
->toolbar_widget
);
3601 gtk_widget_show (x
->handlebox_widget
);
3604 /* Create a tool bar for frame F. */
3605 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
3606 #define toolbar_set_orientation(w, o) \
3607 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
3609 #define toolbar_set_orientation(w, o) \
3610 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
3614 xg_create_tool_bar (FRAME_PTR f
)
3616 struct x_output
*x
= f
->output_data
.x
;
3618 x
->toolbar_widget
= gtk_toolbar_new ();
3619 x
->toolbar_detached
= 0;
3621 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3623 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3624 toolbar_set_orientation (x
->toolbar_widget
,
3625 GTK_ORIENTATION_HORIZONTAL
);
3629 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3631 /* Find the right-to-left image named by RTL in the tool bar images for F.
3632 Returns IMAGE if RTL is not found. */
3635 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
3638 Lisp_Object file
, rtl_name
;
3639 struct gcpro gcpro1
, gcpro2
;
3640 GCPRO2 (file
, rtl_name
);
3642 rtl_name
= Ffile_name_nondirectory (rtl
);
3644 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3646 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3647 if (!NILP (file
= file_for_image (rtl_image
)))
3649 file
= call1 (intern ("file-name-sans-extension"),
3650 Ffile_name_nondirectory (file
));
3651 if (EQ (Fequal (file
, rtl_name
), Qt
))
3662 static GtkToolItem
*
3663 xg_make_tool_item (FRAME_PTR f
,
3665 GtkWidget
**wbutton
,
3669 GtkToolItem
*ti
= gtk_tool_item_new ();
3670 GtkWidget
*vb
= EQ (Vtool_bar_style
, Qboth_horiz
)
3671 ? gtk_hbox_new (FALSE
, 0) : gtk_vbox_new (FALSE
, 0);
3672 GtkWidget
*wb
= gtk_button_new ();
3673 GtkWidget
*weventbox
= gtk_event_box_new ();
3676 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
3678 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
3679 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
3680 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
3681 gtk_container_add (GTK_CONTAINER (wb
), vb
);
3682 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
3683 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
3687 /* The EMACS_INT cast avoids a warning. */
3688 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
3689 G_CALLBACK (xg_tool_bar_menu_proxy
),
3690 (gpointer
) (EMACS_INT
) i
);
3692 g_signal_connect (G_OBJECT (wb
), "clicked",
3693 G_CALLBACK (xg_tool_bar_callback
),
3694 (gpointer
) (EMACS_INT
) i
);
3696 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
3698 /* Catch expose events to overcome an annoying redraw bug, see
3699 comment for xg_tool_bar_item_expose_callback. */
3700 g_signal_connect (G_OBJECT (ti
),
3702 G_CALLBACK (xg_tool_bar_item_expose_callback
),
3705 gtk_tool_item_set_homogeneous (ti
, FALSE
);
3707 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
3708 no distinction based on modifiers in the activate callback,
3709 so we have to do it ourselves. */
3710 g_signal_connect (wb
, "button-release-event",
3711 G_CALLBACK (xg_tool_bar_button_cb
),
3714 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
3716 /* Use enter/leave notify to show help. We use the events
3717 rather than the GtkButton specific signals "enter" and
3718 "leave", so we can have only one callback. The event
3719 will tell us what kind of event it is. */
3720 /* The EMACS_INT cast avoids a warning. */
3721 g_signal_connect (G_OBJECT (weventbox
),
3722 "enter-notify-event",
3723 G_CALLBACK (xg_tool_bar_help_callback
),
3724 (gpointer
) (EMACS_INT
) i
);
3725 g_signal_connect (G_OBJECT (weventbox
),
3726 "leave-notify-event",
3727 G_CALLBACK (xg_tool_bar_help_callback
),
3728 (gpointer
) (EMACS_INT
) i
);
3731 if (wbutton
) *wbutton
= wb
;
3737 xg_show_toolbar_item (GtkToolItem
*ti
)
3739 Lisp_Object style
= Ftool_bar_get_system_style ();
3741 int show_label
= EQ (style
, Qboth
)
3742 || EQ (style
, Qboth_horiz
) || EQ (style
, Qtext
);
3743 int show_image
= ! EQ (style
, Qtext
);
3744 int horiz
= EQ (style
, Qboth_horiz
);
3746 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3747 GtkWidget
*wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3748 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
3750 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
3751 GtkWidget
*new_box
= NULL
;
3753 if (GTK_IS_VBOX (vb
) && horiz
)
3754 new_box
= gtk_hbox_new (FALSE
, 0);
3755 else if (GTK_IS_HBOX (vb
) && !horiz
&& show_label
&& show_image
)
3756 new_box
= gtk_vbox_new (FALSE
, 0);
3759 g_object_ref (G_OBJECT (wimage
));
3760 g_object_ref (G_OBJECT (wlbl
));
3761 gtk_container_remove (GTK_CONTAINER (vb
), wimage
);
3762 gtk_container_remove (GTK_CONTAINER (vb
), wlbl
);
3763 gtk_widget_destroy (GTK_WIDGET (vb
));
3764 gtk_box_pack_start (GTK_BOX (new_box
), wimage
, TRUE
, TRUE
, 0);
3765 gtk_box_pack_start (GTK_BOX (new_box
), wlbl
, TRUE
, TRUE
, 0);
3766 gtk_container_add (GTK_CONTAINER (wbutton
), new_box
);
3767 g_object_unref (G_OBJECT (wimage
));
3768 g_object_unref (G_OBJECT (wlbl
));
3772 if (show_label
) gtk_widget_show (wlbl
);
3773 else gtk_widget_hide (wlbl
);
3774 if (show_image
) gtk_widget_show (wimage
);
3775 else gtk_widget_hide (wimage
);
3776 gtk_widget_show (GTK_WIDGET (weventbox
));
3777 gtk_widget_show (GTK_WIDGET (vb
));
3778 gtk_widget_show (GTK_WIDGET (wbutton
));
3779 gtk_widget_show (GTK_WIDGET (ti
));
3783 /* Update the tool bar for frame F. Add new buttons and remove old. */
3785 extern Lisp_Object Qx_gtk_map_stock
;
3788 update_frame_tool_bar (FRAME_PTR f
)
3791 GtkRequisition old_req
, new_req
;
3792 struct x_output
*x
= f
->output_data
.x
;
3793 int hmargin
= 0, vmargin
= 0;
3794 GtkToolbar
*wtoolbar
;
3796 GtkTextDirection dir
;
3797 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
3799 if (! FRAME_GTK_WIDGET (f
))
3804 if (INTEGERP (Vtool_bar_button_margin
)
3805 && XINT (Vtool_bar_button_margin
) > 0)
3807 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3808 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3810 else if (CONSP (Vtool_bar_button_margin
))
3812 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3813 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3814 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3816 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3817 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3818 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3821 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3822 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3823 i.e. zero. This means that margins less than
3824 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3825 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3826 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3828 if (! x
->toolbar_widget
)
3829 xg_create_tool_bar (f
);
3831 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
3832 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &old_req
);
3833 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
3835 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3837 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3838 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3842 struct image
*img
= NULL
;
3844 Lisp_Object stock
= Qnil
;
3845 GtkStockItem stock_item
;
3846 char *stock_name
= NULL
;
3847 char *icon_name
= NULL
;
3849 GtkWidget
*wbutton
= NULL
;
3850 GtkWidget
*weventbox
;
3851 Lisp_Object specified_file
;
3852 Lisp_Object lbl
= PROP (TOOL_BAR_ITEM_LABEL
);
3853 char *label
= SSDATA (PROP (TOOL_BAR_ITEM_LABEL
));
3855 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), i
);
3859 weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3860 wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3864 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3866 /* Ignore invalid image specifications. */
3867 if (!valid_image_p (image
))
3869 if (wbutton
) gtk_widget_hide (wbutton
);
3873 specified_file
= file_for_image (image
);
3874 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
3875 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
3877 if (STRINGP (stock
))
3879 stock_name
= SSDATA (stock
);
3880 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
3882 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
3883 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
3885 icon_name
= stock_name
+ 2;
3889 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
3892 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3894 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
3895 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3903 if (stock_name
== NULL
&& icon_name
== NULL
)
3905 /* No stock image, or stock item not known. Try regular image. */
3907 /* If image is a vector, choose the image according to the
3909 if (dir
== GTK_TEXT_DIR_RTL
3910 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
3913 image
= find_rtl_image (f
, image
, rtl
);
3916 if (VECTORP (image
))
3920 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3921 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3924 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3925 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3927 xassert (ASIZE (image
) >= idx
);
3928 image
= AREF (image
, idx
);
3933 img_id
= lookup_image (f
, image
);
3934 img
= IMAGE_FROM_ID (f
, img_id
);
3935 prepare_image_for_display (f
, img
);
3937 if (img
->load_failed_p
|| img
->pixmap
== None
)
3940 gtk_widget_hide_all (GTK_WIDGET (ti
));
3943 /* Insert an empty (non-image) button */
3944 ti
= xg_make_tool_item (f
, NULL
, NULL
, "", i
);
3945 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, -1);
3956 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
3957 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
3958 (gpointer
) xstrdup (stock_name
),
3959 (GDestroyNotify
) xfree
);
3963 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
3964 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
3965 (gpointer
) xstrdup (icon_name
),
3966 (GDestroyNotify
) xfree
);
3970 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
3971 /* Save the image so we can see if an update is needed when
3972 this function is called again. */
3973 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
3974 (gpointer
)img
->pixmap
);
3977 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
3978 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
);
3979 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, -1);
3980 gtk_widget_set_sensitive (wbutton
, enabled_p
);
3984 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
3986 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
3988 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
3989 XG_TOOL_BAR_IMAGE_DATA
);
3990 gpointer old_stock_name
= g_object_get_data (G_OBJECT (wimage
),
3991 XG_TOOL_BAR_STOCK_NAME
);
3992 gpointer old_icon_name
= g_object_get_data (G_OBJECT (wimage
),
3993 XG_TOOL_BAR_ICON_NAME
);
3994 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
3996 (! old_stock_name
|| strcmp (old_stock_name
, stock_name
) != 0))
3998 gtk_image_set_from_stock (GTK_IMAGE (wimage
),
3999 stock_name
, icon_size
);
4000 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4001 (gpointer
) xstrdup (stock_name
),
4002 (GDestroyNotify
) xfree
);
4003 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4005 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4008 else if (icon_name
&&
4009 (! old_icon_name
|| strcmp (old_icon_name
, icon_name
) != 0))
4011 gtk_image_set_from_icon_name (GTK_IMAGE (wimage
),
4012 icon_name
, icon_size
);
4013 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4014 (gpointer
) xstrdup (icon_name
),
4015 (GDestroyNotify
) xfree
);
4016 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4018 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4021 else if (img
&& old_img
!= img
->pixmap
)
4023 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
4024 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4025 (gpointer
)img
->pixmap
);
4027 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4029 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4033 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
4035 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4037 xg_show_toolbar_item (ti
);
4042 /* Remove buttons not longer needed. We just hide them so they
4043 can be reused later on. */
4046 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), i
++);
4047 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
4048 } while (ti
!= NULL
);
4051 if (pack_tool_bar
&& f
->n_tool_bar_items
!= 0)
4052 xg_pack_tool_bar (f
);
4055 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &new_req
);
4056 if (old_req
.height
!= new_req
.height
4057 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
4059 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
4060 xg_height_changed (f
);
4065 /* Deallocate all resources for the tool bar on frame F.
4066 Remove the tool bar. */
4069 free_frame_tool_bar (FRAME_PTR f
)
4071 struct x_output
*x
= f
->output_data
.x
;
4073 if (x
->toolbar_widget
)
4075 int is_packed
= x
->handlebox_widget
!= 0;
4077 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4078 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4080 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4081 x
->handlebox_widget
);
4083 gtk_widget_destroy (x
->toolbar_widget
);
4085 x
->toolbar_widget
= 0;
4086 x
->handlebox_widget
= 0;
4087 FRAME_TOOLBAR_HEIGHT (f
) = 0;
4088 xg_height_changed (f
);
4096 /***********************************************************************
4098 ***********************************************************************/
4100 xg_initialize (void)
4102 GtkBindingSet
*binding_set
;
4105 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4106 we keep it permanently linked in. */
4111 xg_ignore_gtk_scrollbar
= 0;
4112 xg_detached_menus
= 0;
4113 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4114 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4116 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4117 id_to_widget
.widgets
= 0;
4119 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4120 bindings. It doesn't seem to be any way to remove properties,
4121 so we set it to VoidSymbol which in X means "no key". */
4122 gtk_settings_set_string_property (gtk_settings_get_default (),
4123 "gtk-menu-bar-accel",
4127 /* Make GTK text input widgets use Emacs style keybindings. This is
4129 gtk_settings_set_string_property (gtk_settings_get_default (),
4130 "gtk-key-theme-name",
4134 /* Make dialogs close on C-g. Since file dialog inherits from
4135 dialog, this works for them also. */
4136 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4137 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4140 /* Make menus close on C-g. */
4141 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4142 (GTK_TYPE_MENU_SHELL
));
4143 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4147 #endif /* USE_GTK */
4149 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
4150 (do not change this comment) */