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
,
239 GdkPixbuf
*icon_buf
, *tmp_buf
;
241 gdk_drawable_get_size (gpix
, &width
, &height
);
242 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
243 0, 0, 0, 0, width
, height
);
244 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
245 g_object_unref (G_OBJECT (tmp_buf
));
249 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
254 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
255 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
256 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
257 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
260 for (y
= 0; y
< height
; ++y
)
262 guchar
*iconptr
, *maskptr
;
265 iconptr
= pixels
+ y
* rowstride
;
266 maskptr
= mask_pixels
+ y
* mask_rowstride
;
268 for (x
= 0; x
< width
; ++x
)
270 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
271 just R is sufficient. */
273 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
275 iconptr
+= rowstride
/width
;
276 maskptr
+= mask_rowstride
/width
;
280 g_object_unref (G_OBJECT (mask_buf
));
287 file_for_image (Lisp_Object image
)
289 Lisp_Object specified_file
= Qnil
;
291 extern Lisp_Object QCfile
;
293 for (tail
= XCDR (image
);
294 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
295 tail
= XCDR (XCDR (tail
)))
296 if (EQ (XCAR (tail
), QCfile
))
297 specified_file
= XCAR (XCDR (tail
));
299 return specified_file
;
302 /* For the image defined in IMG, make and return a GtkImage. For displays with
303 8 planes or less we must make a GdkPixbuf and apply the mask manually.
304 Otherwise the highlightning and dimming the tool bar code in GTK does
305 will look bad. For display with more than 8 planes we just use the
306 pixmap and mask directly. For monochrome displays, GTK doesn't seem
307 able to use external pixmaps, it looks bad whatever we do.
308 The image is defined on the display where frame F is.
309 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
310 If OLD_WIDGET is NULL, a new widget is constructed and returned.
311 If OLD_WIDGET is not NULL, that widget is modified. */
314 xg_get_image_for_pixmap (FRAME_PTR f
,
317 GtkImage
*old_widget
)
325 /* If we have a file, let GTK do all the image handling.
326 This seems to be the only way to make insensitive and activated icons
327 look good in all cases. */
328 Lisp_Object specified_file
= file_for_image (img
->spec
);
331 /* We already loaded the image once before calling this
332 function, so this only fails if the image file has been removed.
333 In that case, use the pixmap already loaded. */
335 if (STRINGP (specified_file
)
336 && STRINGP (file
= x_find_image_file (specified_file
)))
339 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
341 gtk_image_set_from_file (old_widget
, SSDATA (file
));
343 return GTK_WIDGET (old_widget
);
346 /* No file, do the image handling ourselves. This will look very bad
347 on a monochrome display, and sometimes bad on all displays with
350 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
351 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
352 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
354 /* This is a workaround to make icons look good on pseudo color
355 displays. Apparently GTK expects the images to have an alpha
356 channel. If they don't, insensitive and activated icons will
357 look bad. This workaround does not work on monochrome displays,
358 and is strictly not needed on true color/static color displays (i.e.
359 16 bits and higher). But we do it anyway so we get a pixbuf that is
360 not associated with the img->pixmap. The img->pixmap may be removed
361 by clearing the image cache and then the tool bar redraw fails, since
362 Gtk+ assumes the pixmap is always there. */
363 cmap
= gtk_widget_get_colormap (widget
);
364 icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
367 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
369 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
371 g_object_unref (G_OBJECT (icon_buf
));
373 g_object_unref (G_OBJECT (gpix
));
374 if (gmask
) g_object_unref (G_OBJECT (gmask
));
376 return GTK_WIDGET (old_widget
);
380 /* Set CURSOR on W and all widgets W contain. We must do like this
381 for scroll bars and menu because they create widgets internally,
382 and it is those widgets that are visible. */
385 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
387 GdkWindow
*window
= gtk_widget_get_window(w
);
388 GList
*children
= gdk_window_peek_children (window
);
390 gdk_window_set_cursor (window
, cursor
);
392 /* The scroll bar widget has more than one GDK window (had to look at
393 the source to figure this out), and there is no way to set cursor
394 on widgets in GTK. So we must set the cursor for all GDK windows.
397 for ( ; children
; children
= g_list_next (children
))
398 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
401 /* Insert NODE into linked LIST. */
404 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
406 xg_list_node
*list_start
= list
->next
;
408 if (list_start
) list_start
->prev
= node
;
409 node
->next
= list_start
;
414 /* Remove NODE from linked LIST. */
417 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
419 xg_list_node
*list_start
= list
->next
;
420 if (node
== list_start
)
422 list
->next
= node
->next
;
423 if (list
->next
) list
->next
->prev
= 0;
427 node
->prev
->next
= node
->next
;
428 if (node
->next
) node
->next
->prev
= node
->prev
;
432 /* Allocate and return a utf8 version of STR. If STR is already
433 utf8 or NULL, just return STR.
434 If not, a new string is allocated and the caller must free the result
438 get_utf8_string (char *str
)
440 char *utf8_str
= str
;
442 if (!str
) return NULL
;
444 /* If not UTF-8, try current locale. */
445 if (!g_utf8_validate (str
, -1, NULL
))
446 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
450 /* Probably some control characters in str. Escape them. */
454 unsigned char *p
= (unsigned char *)str
;
456 GError
*error
= NULL
;
458 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
459 &bytes_written
, &error
))
460 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
463 p
+= bytes_written
+1;
464 g_error_free (error
);
470 g_error_free (error
);
475 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
476 p
= (unsigned char *)str
;
478 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
479 &bytes_written
, &error
))
480 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
482 strncpy (up
, (char *)p
, bytes_written
);
483 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
484 up
[bytes_written
+4] = '\0';
485 up
+= bytes_written
+4;
486 p
+= bytes_written
+1;
487 g_error_free (error
);
493 strcat (utf8_str
, cp
);
498 g_error_free (error
);
507 /***********************************************************************
508 General functions for creating widgets, resizing, events, e.t.c.
509 ***********************************************************************/
511 /* Make a geometry string and pass that to GTK. It seems this is the
512 only way to get geometry position right if the user explicitly
513 asked for a position when starting Emacs.
514 F is the frame we shall set geometry for. */
517 xg_set_geometry (FRAME_PTR f
)
519 if (f
->size_hint_flags
& (USPosition
| PPosition
))
521 int left
= f
->left_pos
;
522 int xneg
= f
->size_hint_flags
& XNegative
;
523 int top
= f
->top_pos
;
524 int yneg
= f
->size_hint_flags
& YNegative
;
532 sprintf (geom_str
, "=%dx%d%c%d%c%d",
533 FRAME_PIXEL_WIDTH (f
),
534 FRAME_PIXEL_HEIGHT (f
),
535 (xneg
? '-' : '+'), left
,
536 (yneg
? '-' : '+'), top
);
538 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
540 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
544 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
545 and use a GtkFixed widget, this doesn't happen automatically. */
548 xg_clear_under_internal_border (FRAME_PTR f
)
550 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
552 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
553 gtk_widget_queue_draw (wfixed
);
554 gdk_window_process_all_updates ();
555 x_clear_area (FRAME_X_DISPLAY (f
),
558 FRAME_PIXEL_WIDTH (f
),
559 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
560 x_clear_area (FRAME_X_DISPLAY (f
),
563 FRAME_INTERNAL_BORDER_WIDTH (f
),
564 FRAME_PIXEL_HEIGHT (f
), 0);
565 x_clear_area (FRAME_X_DISPLAY (f
),
567 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
568 FRAME_PIXEL_WIDTH (f
),
569 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
570 x_clear_area (FRAME_X_DISPLAY (f
),
572 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
574 FRAME_INTERNAL_BORDER_WIDTH (f
),
575 FRAME_PIXEL_HEIGHT (f
), 0);
579 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
580 and a Gtk+ menu bar, we get resize events for the edit part of the
581 frame only. We let Gtk+ deal with the Gtk+ parts.
582 F is the frame to resize.
583 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
586 xg_frame_resized (FRAME_PTR f
, int pixelwidth
, int pixelheight
)
590 if (pixelwidth
== -1 && pixelheight
== -1)
592 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
593 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
595 &pixelwidth
, &pixelheight
, 0);
600 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
601 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
603 if (columns
!= FRAME_COLS (f
)
604 || rows
!= FRAME_LINES (f
)
605 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
606 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
608 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
609 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
611 xg_clear_under_internal_border (f
);
612 change_frame_size (f
, rows
, columns
, 0, 1, 0);
613 SET_FRAME_GARBAGED (f
);
614 cancel_mouse_face (f
);
618 /* Resize the outer window of frame F after chainging the height.
619 COLUMNS/ROWS is the size the edit area shall have after the resize. */
622 xg_frame_set_char_size (FRAME_PTR f
, int cols
, int rows
)
624 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
625 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
628 if (FRAME_PIXEL_HEIGHT (f
) == 0)
631 /* Take into account the size of the scroll bar. Always use the
632 number of columns occupied by the scroll bar here otherwise we
633 might end up with a frame width that is not a multiple of the
634 frame's character width which is bad for vertically split
636 f
->scroll_bar_actual_width
637 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
639 compute_fringe_widths (f
, 0);
641 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
642 after calculating that value. */
643 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
646 /* Do this before resize, as we don't know yet if we will be resized. */
647 xg_clear_under_internal_border (f
);
649 /* Must resize our top level widget. Font size may have changed,
650 but not rows/cols. */
651 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
652 pixelwidth
, pixelheight
);
653 x_wm_set_size_hint (f
, 0, 0);
655 SET_FRAME_GARBAGED (f
);
656 cancel_mouse_face (f
);
658 /* We can not call change_frame_size for a mapped frame,
659 we can not set pixel width/height either. The window manager may
660 override our resize request, XMonad does this all the time.
661 The best we can do is try to sync, so lisp code sees the updated
662 size as fast as possible.
663 For unmapped windows, we can set rows/cols. When
664 the frame is mapped again we will (hopefully) get the correct size. */
665 if (f
->async_visible
)
667 /* Must call this to flush out events */
668 (void)gtk_events_pending ();
670 x_wait_for_event (f
, ConfigureNotify
);
674 change_frame_size (f
, rows
, cols
, 0, 1, 0);
675 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
676 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
680 /* Handle height changes (i.e. add/remove menu/toolbar).
681 The policy is to keep the number of editable lines. */
684 xg_height_changed (FRAME_PTR f
)
686 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
687 FRAME_PIXEL_WIDTH (f
), FRAME_TOTAL_PIXEL_HEIGHT (f
));
688 f
->output_data
.x
->hint_flags
= 0;
689 x_wm_set_size_hint (f
, 0, 0);
692 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
693 Must be done like this, because GtkWidget:s can have "hidden"
694 X Window that aren't accessible.
696 Return 0 if no widget match WDESC. */
699 xg_win_to_widget (Display
*dpy
, Window wdesc
)
702 GtkWidget
*gwdesc
= 0;
706 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
711 event
.any
.window
= gdkwin
;
712 gwdesc
= gtk_get_event_widget (&event
);
719 /* Fill in the GdkColor C so that it represents PIXEL.
720 W is the widget that color will be used for. Used to find colormap. */
723 xg_pix_to_gcolor (GtkWidget
*w
, long unsigned int pixel
, GdkColor
*c
)
725 GdkColormap
*map
= gtk_widget_get_colormap (w
);
726 gdk_colormap_query_color (map
, pixel
, c
);
729 /* Create and set up the GTK widgets for frame F.
730 Return 0 if creation failed, non-zero otherwise. */
733 xg_create_frame_widgets (FRAME_PTR f
)
744 if (FRAME_X_EMBEDDED_P (f
))
745 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
747 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
749 xg_set_screen (wtop
, f
);
751 wvbox
= gtk_vbox_new (FALSE
, 0);
752 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
754 if (! wtop
|| ! wvbox
|| ! wfixed
)
756 if (wtop
) gtk_widget_destroy (wtop
);
757 if (wvbox
) gtk_widget_destroy (wvbox
);
758 if (wfixed
) gtk_widget_destroy (wfixed
);
764 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
765 gtk_widget_set_name (wtop
, EMACS_CLASS
);
766 gtk_widget_set_name (wvbox
, "pane");
767 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
769 /* If this frame has a title or name, set it in the title bar. */
770 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
771 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
773 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
775 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
776 FRAME_GTK_WIDGET (f
) = wfixed
;
777 f
->output_data
.x
->vbox_widget
= wvbox
;
779 gtk_widget_set_has_window (wfixed
, TRUE
);
781 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
782 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
784 if (FRAME_EXTERNAL_TOOL_BAR (f
))
785 update_frame_tool_bar (f
);
787 /* We don't want this widget double buffered, because we draw on it
788 with regular X drawing primitives, so from a GTK/GDK point of
789 view, the widget is totally blank. When an expose comes, this
790 will make the widget blank, and then Emacs redraws it. This flickers
791 a lot, so we turn off double buffering. */
792 gtk_widget_set_double_buffered (wfixed
, FALSE
);
794 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
795 SSDATA (Vx_resource_name
),
796 SSDATA (Vx_resource_class
));
798 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
799 GTK is to destroy the widget. We want Emacs to do that instead. */
800 g_signal_connect (G_OBJECT (wtop
), "delete-event",
801 G_CALLBACK (gtk_true
), 0);
803 /* Convert our geometry parameters into a geometry string
805 GTK will itself handle calculating the real position this way. */
808 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
810 gtk_widget_add_events (wfixed
,
811 GDK_POINTER_MOTION_MASK
813 | GDK_BUTTON_PRESS_MASK
814 | GDK_BUTTON_RELEASE_MASK
816 | GDK_ENTER_NOTIFY_MASK
817 | GDK_LEAVE_NOTIFY_MASK
818 | GDK_FOCUS_CHANGE_MASK
820 | GDK_VISIBILITY_NOTIFY_MASK
);
822 /* Must realize the windows so the X window gets created. It is used
823 by callers of this function. */
824 gtk_widget_realize (wfixed
);
825 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
827 /* Since GTK clears its window by filling with the background color,
828 we must keep X and GTK background in sync. */
829 xg_pix_to_gcolor (wfixed
, FRAME_BACKGROUND_PIXEL (f
), &bg
);
830 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
832 /* Also, do not let any background pixmap to be set, this looks very
833 bad as Emacs overwrites the background pixmap with its own idea
834 of background color. */
835 style
= gtk_widget_get_modifier_style (wfixed
);
837 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
838 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
839 gtk_widget_modify_style (wfixed
, style
);
841 /* GTK does not set any border, and they look bad with GTK. */
842 /* That they look bad is no excuse for imposing this here. --Stef
843 It should be done by providing the proper default in Fx_create_Frame.
845 f->internal_border_width = 0; */
852 /* Set the normal size hints for the window manager, for frame F.
853 FLAGS is the flags word to use--or 0 meaning preserve the flags
854 that the window now has.
855 If USER_POSITION is nonzero, we set the User Position
856 flag (this is useful when FLAGS is 0). */
859 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
861 /* Must use GTK routines here, otherwise GTK resets the size hints
862 to its own defaults. */
863 GdkGeometry size_hints
;
865 int base_width
, base_height
;
866 int min_rows
= 0, min_cols
= 0;
867 int win_gravity
= f
->win_gravity
;
869 /* Don't set size hints during initialization; that apparently leads
870 to a race condition. See the thread at
871 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
872 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
877 memset (&size_hints
, 0, sizeof (size_hints
));
878 f
->output_data
.x
->size_hints
= size_hints
;
879 f
->output_data
.x
->hint_flags
= hint_flags
;
882 flags
= f
->size_hint_flags
;
884 size_hints
= f
->output_data
.x
->size_hints
;
885 hint_flags
= f
->output_data
.x
->hint_flags
;
887 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
888 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
889 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
891 hint_flags
|= GDK_HINT_BASE_SIZE
;
892 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
893 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
894 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
896 check_frame_size (f
, &min_rows
, &min_cols
);
898 size_hints
.base_width
= base_width
;
899 size_hints
.base_height
= base_height
;
900 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
901 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
903 /* These currently have a one to one mapping with the X values, but I
904 don't think we should rely on that. */
905 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
906 size_hints
.win_gravity
= 0;
907 if (win_gravity
== NorthWestGravity
)
908 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
909 else if (win_gravity
== NorthGravity
)
910 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
911 else if (win_gravity
== NorthEastGravity
)
912 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
913 else if (win_gravity
== WestGravity
)
914 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
915 else if (win_gravity
== CenterGravity
)
916 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
917 else if (win_gravity
== EastGravity
)
918 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
919 else if (win_gravity
== SouthWestGravity
)
920 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
921 else if (win_gravity
== SouthGravity
)
922 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
923 else if (win_gravity
== SouthEastGravity
)
924 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
925 else if (win_gravity
== StaticGravity
)
926 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
930 hint_flags
&= ~GDK_HINT_POS
;
931 hint_flags
|= GDK_HINT_USER_POS
;
934 if (hint_flags
!= f
->output_data
.x
->hint_flags
935 || memcmp (&size_hints
,
936 &f
->output_data
.x
->size_hints
,
937 sizeof (size_hints
)) != 0)
940 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
941 NULL
, &size_hints
, hint_flags
);
942 f
->output_data
.x
->size_hints
= size_hints
;
943 f
->output_data
.x
->hint_flags
= hint_flags
;
948 /* Change background color of a frame.
949 Since GTK uses the background color to clear the window, we must
950 keep the GTK and X colors in sync.
951 F is the frame to change,
952 BG is the pixel value to change to. */
955 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
957 if (FRAME_GTK_WIDGET (f
))
962 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
963 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
969 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
970 functions so GTK does not overwrite the icon. */
973 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
975 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
976 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
977 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
978 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
980 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
985 /***********************************************************************
987 ***********************************************************************/
988 /* Return the dialog title to use for a dialog of type KEY.
989 This is the encoding used by lwlib. We use the same for GTK. */
992 get_dialog_title (char key
)
1002 title
= "Information";
1021 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1022 the dialog, but return TRUE so the event does not propagate further
1023 in GTK. This prevents GTK from destroying the dialog widget automatically
1024 and we can always destrou the widget manually, regardles of how
1025 it was popped down (button press or WM_DELETE_WINDOW).
1026 W is the dialog widget.
1027 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1028 user_data is NULL (not used).
1030 Returns TRUE to end propagation of event. */
1033 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1035 gtk_widget_unmap (w
);
1039 /* Create a popup dialog window. See also xg_create_widget below.
1040 WV is a widget_value describing the dialog.
1041 SELECT_CB is the callback to use when a button has been pressed.
1042 DEACTIVATE_CB is the callback to use when the dialog pops down.
1044 Returns the GTK dialog widget. */
1047 create_dialog (widget_value
*wv
,
1048 GCallback select_cb
,
1049 GCallback deactivate_cb
)
1051 char *title
= get_dialog_title (wv
->name
[0]);
1052 int total_buttons
= wv
->name
[1] - '0';
1053 int right_buttons
= wv
->name
[4] - '0';
1056 int button_spacing
= 10;
1057 GtkWidget
*wdialog
= gtk_dialog_new ();
1058 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1059 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1062 GtkWidget
*whbox_up
;
1063 GtkWidget
*whbox_down
;
1065 /* If the number of buttons is greater than 4, make two rows of buttons
1066 instead. This looks better. */
1067 int make_two_rows
= total_buttons
> 4;
1069 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1070 left_buttons
= total_buttons
- right_buttons
;
1072 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1073 gtk_widget_set_name (wdialog
, "emacs-dialog");
1078 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1079 whbox_up
= gtk_hbox_new (FALSE
, 0);
1080 whbox_down
= gtk_hbox_new (FALSE
, 0);
1082 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1083 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1084 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1086 cur_box
= GTK_BOX (whbox_up
);
1089 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1090 G_CALLBACK (dialog_delete_callback
), 0);
1094 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1095 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1098 for (item
= wv
->contents
; item
; item
= item
->next
)
1100 char *utf8_label
= get_utf8_string (item
->value
);
1104 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1106 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1107 /* This is the text part of the dialog. */
1108 w
= gtk_label_new (utf8_label
);
1109 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1110 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1111 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1113 /* Try to make dialog look better. Must realize first so
1114 the widget can calculate the size it needs. */
1115 gtk_widget_realize (w
);
1116 gtk_widget_size_request (w
, &req
);
1117 gtk_box_set_spacing (wvbox
, req
.height
);
1118 if (item
->value
&& strlen (item
->value
) > 0)
1119 button_spacing
= 2*req
.width
/strlen (item
->value
);
1123 /* This is one button to add to the dialog. */
1124 w
= gtk_button_new_with_label (utf8_label
);
1125 if (! item
->enabled
)
1126 gtk_widget_set_sensitive (w
, FALSE
);
1128 g_signal_connect (G_OBJECT (w
), "clicked",
1129 select_cb
, item
->call_data
);
1131 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1132 if (++button_nr
== left_buttons
)
1135 cur_box
= GTK_BOX (whbox_down
);
1137 gtk_box_pack_start (cur_box
,
1144 if (utf8_label
&& utf8_label
!= item
->value
)
1145 g_free (utf8_label
);
1151 struct xg_dialog_data
1159 /* Function that is called when the file or font dialogs pop down.
1160 W is the dialog widget, RESPONSE is the response code.
1161 USER_DATA is what we passed in to g_signal_connect. */
1164 xg_dialog_response_cb (GtkDialog
*w
,
1168 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1169 dd
->response
= response
;
1170 g_main_loop_quit (dd
->loop
);
1174 /* Destroy the dialog. This makes it pop down. */
1177 pop_down_dialog (Lisp_Object arg
)
1179 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1180 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1183 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1184 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1186 g_main_loop_quit (dd
->loop
);
1187 g_main_loop_unref (dd
->loop
);
1194 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1195 We pass in DATA as gpointer* so we can use this as a callback. */
1198 xg_maybe_add_timer (gpointer data
)
1200 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1201 EMACS_TIME next_time
= timer_check (1);
1202 long secs
= EMACS_SECS (next_time
);
1203 long usecs
= EMACS_USECS (next_time
);
1207 if (secs
>= 0 && usecs
>= 0 && secs
< ((guint
)-1)/1000)
1209 dd
->timerid
= g_timeout_add (secs
* 1000 + usecs
/1000,
1217 /* Pops up a modal dialog W and waits for response.
1218 We don't use gtk_dialog_run because we want to process emacs timers.
1219 The dialog W is not destroyed when this function returns. */
1222 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1224 int count
= SPECPDL_INDEX ();
1225 struct xg_dialog_data dd
;
1227 xg_set_screen (w
, f
);
1228 gtk_window_set_transient_for (GTK_WINDOW (w
),
1229 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1230 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1231 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1233 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1234 dd
.response
= GTK_RESPONSE_CANCEL
;
1238 g_signal_connect (G_OBJECT (w
),
1240 G_CALLBACK (xg_dialog_response_cb
),
1242 /* Don't destroy the widget if closed by the window manager close button. */
1243 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1244 gtk_widget_show (w
);
1246 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1248 (void) xg_maybe_add_timer (&dd
);
1249 g_main_loop_run (dd
.loop
);
1252 unbind_to (count
, Qnil
);
1258 /***********************************************************************
1259 File dialog functions
1260 ***********************************************************************/
1261 /* Return non-zero if the old file selection dialog is being used.
1262 Return zero if not. */
1265 xg_uses_old_file_dialog (void)
1267 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1268 extern int x_gtk_use_old_file_dialog
;
1269 return x_gtk_use_old_file_dialog
;
1276 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1278 /* Return the selected file for file chooser dialog W.
1279 The returned string must be free:d. */
1282 xg_get_file_name_from_chooser (GtkWidget
*w
)
1284 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1287 /* Callback called when the "Show hidden files" toggle is pressed.
1288 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1291 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1293 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1295 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1296 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1300 /* Callback called when a property changes in a file chooser.
1301 GOBJECT is the file chooser dialog, ARG1 describes the property.
1302 USER_DATA is the toggle widget in the file chooser dialog.
1303 We use this to update the "Show hidden files" toggle when the user
1304 changes that property by right clicking in the file list. */
1307 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1309 extern int x_gtk_show_hidden_files
;
1311 if (strcmp (arg1
->name
, "show-hidden") == 0)
1313 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1314 gboolean visible
, toggle_on
;
1316 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1317 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1319 if (!!visible
!= !!toggle_on
)
1321 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1322 G_CALLBACK (xg_toggle_visibility_cb
),
1324 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1325 g_signal_handlers_unblock_by_func
1326 (G_OBJECT (wtoggle
),
1327 G_CALLBACK (xg_toggle_visibility_cb
),
1330 x_gtk_show_hidden_files
= visible
;
1334 /* Read a file name from the user using a file chooser dialog.
1335 F is the current frame.
1336 PROMPT is a prompt to show to the user. May not be NULL.
1337 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1338 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1339 file. *FUNC is set to a function that can be used to retrieve the
1340 selected file name from the returned widget.
1342 Returns the created widget. */
1345 xg_get_file_with_chooser (FRAME_PTR f
,
1347 char *default_filename
,
1348 int mustmatch_p
, int only_dir_p
,
1349 xg_get_file_func
*func
)
1353 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1354 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1355 GtkFileChooserAction action
= (mustmatch_p
?
1356 GTK_FILE_CHOOSER_ACTION_OPEN
:
1357 GTK_FILE_CHOOSER_ACTION_SAVE
);
1358 extern int x_gtk_show_hidden_files
;
1359 extern int x_gtk_file_dialog_help_text
;
1363 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1365 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1366 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1367 (mustmatch_p
|| only_dir_p
?
1368 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1371 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1373 wbox
= gtk_vbox_new (FALSE
, 0);
1374 gtk_widget_show (wbox
);
1375 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1377 if (x_gtk_show_hidden_files
)
1379 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1380 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1382 gtk_widget_show (wtoggle
);
1383 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1384 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1385 g_signal_connect (G_OBJECT (filewin
), "notify",
1386 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1388 if (x_gtk_file_dialog_help_text
)
1391 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1392 Show the C-l help text only for versions < 2.10. */
1393 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1394 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1395 strcat (message
, "\nIf you don't like this file selector, use the "
1396 "corresponding\nkey binding or customize "
1397 "use-file-dialog to turn it off.");
1399 wmessage
= gtk_label_new (message
);
1400 gtk_widget_show (wmessage
);
1403 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1404 if (x_gtk_file_dialog_help_text
)
1405 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1406 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1408 if (default_filename
)
1411 struct gcpro gcpro1
;
1412 char *utf8_filename
;
1415 file
= build_string (default_filename
);
1417 /* File chooser does not understand ~/... in the file name. It must be
1418 an absolute name starting with /. */
1419 if (default_filename
[0] != '/')
1420 file
= Fexpand_file_name (file
, Qnil
);
1422 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1423 if (! NILP (Ffile_directory_p (file
)))
1424 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1428 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1430 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1432 char *cp
= strrchr (utf8_filename
, '/');
1434 else cp
= utf8_filename
;
1435 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1442 *func
= xg_get_file_name_from_chooser
;
1446 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1448 /* Return the selected file for file selector dialog W.
1449 The returned string must be free:d. */
1452 xg_get_file_name_from_selector (GtkWidget
*w
)
1454 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1455 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1458 /* Create a file selection dialog.
1459 F is the current frame.
1460 PROMPT is a prompt to show to the user. May not be NULL.
1461 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1462 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1463 file. *FUNC is set to a function that can be used to retrieve the
1464 selected file name from the returned widget.
1466 Returns the created widget. */
1469 xg_get_file_with_selection (FRAME_PTR f
,
1471 char *default_filename
,
1472 int mustmatch_p
, int only_dir_p
,
1473 xg_get_file_func
*func
)
1476 GtkFileSelection
*filesel
;
1478 filewin
= gtk_file_selection_new (prompt
);
1479 filesel
= GTK_FILE_SELECTION (filewin
);
1481 if (default_filename
)
1482 gtk_file_selection_set_filename (filesel
, default_filename
);
1486 /* The selection_entry part of filesel is not documented. */
1487 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1488 gtk_file_selection_hide_fileop_buttons (filesel
);
1491 *func
= xg_get_file_name_from_selector
;
1495 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1497 /* Read a file name from the user using a file dialog, either the old
1498 file selection dialog, or the new file chooser dialog. Which to use
1499 depends on what the GTK version used has, and what the value of
1500 gtk-use-old-file-dialog.
1501 F is the current frame.
1502 PROMPT is a prompt to show to the user. May not be NULL.
1503 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1504 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1507 Returns a file name or NULL if no file was selected.
1508 The returned string must be freed by the caller. */
1511 xg_get_file_name (FRAME_PTR f
,
1513 char *default_filename
,
1519 int filesel_done
= 0;
1520 xg_get_file_func func
;
1522 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1523 /* I really don't know why this is needed, but without this the GLIBC add on
1524 library linuxthreads hangs when the Gnome file chooser backend creates
1526 sigblock (sigmask (__SIGRTMIN
));
1527 #endif /* HAVE_GTK_AND_PTHREAD */
1529 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1531 if (xg_uses_old_file_dialog ())
1532 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1533 mustmatch_p
, only_dir_p
, &func
);
1535 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1536 mustmatch_p
, only_dir_p
, &func
);
1538 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1539 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1540 mustmatch_p
, only_dir_p
, &func
);
1541 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1543 gtk_widget_set_name (w
, "emacs-filedialog");
1545 filesel_done
= xg_dialog_run (f
, w
);
1547 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1548 sigunblock (sigmask (__SIGRTMIN
));
1551 if (filesel_done
== GTK_RESPONSE_OK
)
1554 gtk_widget_destroy (w
);
1558 #ifdef HAVE_FREETYPE
1559 /* Pop up a GTK font selector and return the name of the font the user
1560 selects, as a C string. The returned font name follows GTK's own
1563 `FAMILY [VALUE1 VALUE2] SIZE'
1565 This can be parsed using font_parse_fcname in font.c.
1566 DEFAULT_NAME, if non-zero, is the default font name. */
1569 xg_get_font_name (FRAME_PTR f
, char *default_name
)
1572 char *fontname
= NULL
;
1575 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1576 sigblock (sigmask (__SIGRTMIN
));
1577 #endif /* HAVE_GTK_AND_PTHREAD */
1579 w
= gtk_font_selection_dialog_new ("Pick a font");
1581 default_name
= "Monospace 10";
1582 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1585 gtk_widget_set_name (w
, "emacs-fontdialog");
1587 done
= xg_dialog_run (f
, w
);
1589 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1590 sigunblock (sigmask (__SIGRTMIN
));
1593 if (done
== GTK_RESPONSE_OK
)
1594 fontname
= gtk_font_selection_dialog_get_font_name
1595 (GTK_FONT_SELECTION_DIALOG (w
));
1597 gtk_widget_destroy (w
);
1600 #endif /* HAVE_FREETYPE */
1604 /***********************************************************************
1606 ***********************************************************************/
1608 /* The name of menu items that can be used for customization. Since GTK
1609 RC files are very crude and primitive, we have to set this on all
1610 menu item names so a user can easily customize menu items. */
1612 #define MENU_ITEM_NAME "emacs-menuitem"
1615 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1616 during GC. The next member points to the items. */
1617 static xg_list_node xg_menu_cb_list
;
1619 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1620 during GC. The next member points to the items. */
1621 static xg_list_node xg_menu_item_cb_list
;
1623 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1624 F is the frame CL_DATA will be initialized for.
1625 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1627 The menu bar and all sub menus under the menu bar in a frame
1628 share the same structure, hence the reference count.
1630 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1631 allocated xg_menu_cb_data if CL_DATA is NULL. */
1633 static xg_menu_cb_data
*
1634 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
1638 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1640 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1641 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1642 cl_data
->highlight_cb
= highlight_cb
;
1643 cl_data
->ref_count
= 0;
1645 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1648 cl_data
->ref_count
++;
1653 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1654 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1656 When the menu bar is updated, menu items may have been added and/or
1657 removed, so menu_bar_vector and menu_bar_items_used change. We must
1658 then update CL_DATA since it is used to determine which menu
1659 item that is invoked in the menu.
1660 HIGHLIGHT_CB could change, there is no check that the same
1661 function is given when modifying a menu bar as was given when
1662 creating the menu bar. */
1665 update_cl_data (xg_menu_cb_data
*cl_data
,
1667 GCallback highlight_cb
)
1672 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1673 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1674 cl_data
->highlight_cb
= highlight_cb
;
1678 /* Decrease reference count for CL_DATA.
1679 If reference count is zero, free CL_DATA. */
1682 unref_cl_data (xg_menu_cb_data
*cl_data
)
1684 if (cl_data
&& cl_data
->ref_count
> 0)
1686 cl_data
->ref_count
--;
1687 if (cl_data
->ref_count
== 0)
1689 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1695 /* Function that marks all lisp data during GC. */
1702 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1703 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1705 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1707 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1709 if (! NILP (cb_data
->help
))
1710 mark_object (cb_data
->help
);
1715 /* Callback called when a menu item is destroyed. Used to free data.
1716 W is the widget that is being destroyed (not used).
1717 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1720 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
1724 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1725 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1730 /* Callback called when the pointer enters/leaves a menu item.
1731 W is the parent of the menu item.
1732 EVENT is either an enter event or leave event.
1733 CLIENT_DATA is not used.
1735 Returns FALSE to tell GTK to keep processing this event. */
1738 menuitem_highlight_callback (GtkWidget
*w
,
1739 GdkEventCrossing
*event
,
1740 gpointer client_data
)
1743 GtkWidget
*subwidget
;
1744 xg_menu_item_cb_data
*data
;
1746 ev
.crossing
= *event
;
1747 subwidget
= gtk_get_event_widget (&ev
);
1748 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
1752 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1754 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
1755 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1756 (*func
) (subwidget
, call_data
);
1763 /* Callback called when a menu is destroyed. Used to free data.
1764 W is the widget that is being destroyed (not used).
1765 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1768 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
1770 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1773 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1774 must be non-NULL) and can be inserted into a menu item.
1776 Returns the GtkHBox. */
1779 make_widget_for_menu_item (char *utf8_label
, char *utf8_key
)
1785 wbox
= gtk_hbox_new (FALSE
, 0);
1786 wlbl
= gtk_label_new (utf8_label
);
1787 wkey
= gtk_label_new (utf8_key
);
1789 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1790 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1792 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1793 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1795 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1796 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1797 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1802 /* Make and return a menu item widget with the key to the right.
1803 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1804 UTF8_KEY is the text representing the key binding.
1805 ITEM is the widget_value describing the menu item.
1807 GROUP is an in/out parameter. If the menu item to be created is not
1808 part of any radio menu group, *GROUP contains NULL on entry and exit.
1809 If the menu item to be created is part of a radio menu group, on entry
1810 *GROUP contains the group to use, or NULL if this is the first item
1811 in the group. On exit, *GROUP contains the radio item group.
1813 Unfortunately, keys don't line up as nicely as in Motif,
1814 but the MacOS X version doesn't either, so I guess that is OK. */
1817 make_menu_item (char *utf8_label
,
1823 GtkWidget
*wtoadd
= 0;
1825 /* It has been observed that some menu items have a NULL name field.
1826 This will lead to this function being called with a NULL utf8_label.
1827 GTK crashes on that so we set a blank label. Why there is a NULL
1828 name remains to be investigated. */
1829 if (! utf8_label
) utf8_label
= " ";
1832 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1834 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1837 if (utf8_key
) w
= gtk_check_menu_item_new ();
1838 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1839 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1841 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1843 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1844 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1845 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1847 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1852 if (utf8_key
) w
= gtk_menu_item_new ();
1853 else w
= gtk_menu_item_new_with_label (utf8_label
);
1856 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1857 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1862 /* Return non-zero if LABEL specifies a separator (GTK only has one
1865 static const char* separator_names
[] = {
1870 "single-dashed-line",
1871 "double-dashed-line",
1873 "shadow-etched-out",
1874 "shadow-etched-in-dash",
1875 "shadow-etched-out-dash",
1876 "shadow-double-etched-in",
1877 "shadow-double-etched-out",
1878 "shadow-double-etched-in-dash",
1879 "shadow-double-etched-out-dash",
1884 xg_separator_p (char *label
)
1886 if (! label
) return 0;
1887 else if (strlen (label
) > 3
1888 && strncmp (label
, "--", 2) == 0
1894 for (i
= 0; separator_names
[i
]; ++i
)
1895 if (strcmp (label
, separator_names
[i
]) == 0)
1900 /* Old-style separator, maybe. It's a separator if it contains
1902 while (*label
== '-')
1904 if (*label
== 0) return 1;
1910 static int xg_detached_menus
;
1912 /* Returns non-zero if there are detached menus. */
1915 xg_have_tear_offs (void)
1917 return xg_detached_menus
> 0;
1920 /* Callback invoked when a detached menu window is removed. Here we
1921 decrease the xg_detached_menus count.
1922 WIDGET is the top level window that is removed (the parent of the menu).
1923 CLIENT_DATA is not used. */
1926 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
1928 if (xg_detached_menus
> 0) --xg_detached_menus
;
1931 /* Callback invoked when a menu is detached. It increases the
1932 xg_detached_menus count.
1933 WIDGET is the GtkTearoffMenuItem.
1934 CLIENT_DATA is not used. */
1937 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
1939 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
1940 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
1942 ++xg_detached_menus
;
1943 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
1945 G_CALLBACK (tearoff_remove
), 0);
1950 /* Create a menu item widget, and connect the callbacks.
1951 ITEM decribes the menu item.
1952 F is the frame the created menu belongs to.
1953 SELECT_CB is the callback to use when a menu item is selected.
1954 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1955 CL_DATA points to the callback data to be used for this menu.
1956 GROUP is an in/out parameter. If the menu item to be created is not
1957 part of any radio menu group, *GROUP contains NULL on entry and exit.
1958 If the menu item to be created is part of a radio menu group, on entry
1959 *GROUP contains the group to use, or NULL if this is the first item
1960 in the group. On exit, *GROUP contains the radio item group.
1962 Returns the created GtkWidget. */
1965 xg_create_one_menuitem (widget_value
*item
,
1967 GCallback select_cb
,
1968 GCallback highlight_cb
,
1969 xg_menu_cb_data
*cl_data
,
1975 xg_menu_item_cb_data
*cb_data
;
1977 utf8_label
= get_utf8_string (item
->name
);
1978 utf8_key
= get_utf8_string (item
->key
);
1980 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
1982 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
1983 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
1985 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
1987 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
1989 cb_data
->select_id
= 0;
1990 cb_data
->help
= item
->help
;
1991 cb_data
->cl_data
= cl_data
;
1992 cb_data
->call_data
= item
->call_data
;
1994 g_signal_connect (G_OBJECT (w
),
1996 G_CALLBACK (menuitem_destroy_callback
),
1999 /* Put cb_data in widget, so we can get at it when modifying menubar */
2000 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2002 /* final item, not a submenu */
2003 if (item
->call_data
&& ! item
->contents
)
2007 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2013 /* Create a full menu tree specified by DATA.
2014 F is the frame the created menu belongs to.
2015 SELECT_CB is the callback to use when a menu item is selected.
2016 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2017 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2018 POP_UP_P is non-zero if we shall create a popup menu.
2019 MENU_BAR_P is non-zero if we shall create a menu bar.
2020 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2021 if MENU_BAR_P is non-zero.
2022 TOPMENU is the topmost GtkWidget that others shall be placed under.
2023 It may be NULL, in that case we create the appropriate widget
2024 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2025 CL_DATA is the callback data we shall use for this menu, or NULL
2026 if we haven't set the first callback yet.
2027 NAME is the name to give to the top level menu if this function
2028 creates it. May be NULL to not set any name.
2030 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2033 This function calls itself to create submenus. */
2036 create_menus (widget_value
*data
,
2038 GCallback select_cb
,
2039 GCallback deactivate_cb
,
2040 GCallback highlight_cb
,
2045 xg_menu_cb_data
*cl_data
,
2049 GtkWidget
*wmenu
= topmenu
;
2050 GSList
*group
= NULL
;
2056 wmenu
= gtk_menu_new ();
2057 xg_set_screen (wmenu
, f
);
2058 /* Connect this to the menu instead of items so we get enter/leave for
2059 disabled items also. TODO: Still does not get enter/leave for
2060 disabled items in detached menus. */
2061 g_signal_connect (G_OBJECT (wmenu
),
2062 "enter-notify-event",
2063 G_CALLBACK (menuitem_highlight_callback
),
2065 g_signal_connect (G_OBJECT (wmenu
),
2066 "leave-notify-event",
2067 G_CALLBACK (menuitem_highlight_callback
),
2072 wmenu
= gtk_menu_bar_new ();
2073 /* Set width of menu bar to a small value so it doesn't enlarge
2074 a small initial frame size. The width will be set to the
2075 width of the frame later on when it is added to a container.
2076 height -1: Natural height. */
2077 gtk_widget_set_size_request (wmenu
, 1, -1);
2080 /* Put cl_data on the top menu for easier access. */
2081 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2082 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2083 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2084 G_CALLBACK (menu_destroy_callback
), cl_data
);
2087 gtk_widget_set_name (wmenu
, name
);
2090 g_signal_connect (G_OBJECT (wmenu
),
2091 "selection-done", deactivate_cb
, 0);
2094 if (! menu_bar_p
&& add_tearoff_p
)
2096 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2097 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2099 g_signal_connect (G_OBJECT (tearoff
), "activate",
2100 G_CALLBACK (tearoff_activate
), 0);
2103 for (item
= data
; item
; item
= item
->next
)
2107 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2108 && !xg_separator_p (item
->name
))
2111 /* A title for a popup. We do the same as GTK does when
2112 creating titles, but it does not look good. */
2114 utf8_label
= get_utf8_string (item
->name
);
2116 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2117 w
= gtk_menu_item_new_with_label (utf8_label
);
2118 gtk_widget_set_sensitive (w
, FALSE
);
2119 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2121 else if (xg_separator_p (item
->name
))
2124 /* GTK only have one separator type. */
2125 w
= gtk_separator_menu_item_new ();
2129 w
= xg_create_one_menuitem (item
,
2131 item
->contents
? 0 : select_cb
,
2136 /* Create a possibly empty submenu for menu bar items, since some
2137 themes don't highlight items correctly without it. */
2138 if (item
->contents
|| menu_bar_p
)
2140 GtkWidget
*submenu
= create_menus (item
->contents
,
2151 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2155 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2156 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2162 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2163 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2164 with some text and buttons.
2165 F is the frame the created item belongs to.
2166 NAME is the name to use for the top widget.
2167 VAL is a widget_value structure describing items to be created.
2168 SELECT_CB is the callback to use when a menu item is selected or
2169 a dialog button is pressed.
2170 DEACTIVATE_CB is the callback to use when an item is deactivated.
2171 For a menu, when a sub menu is not shown anymore, for a dialog it is
2172 called when the dialog is popped down.
2173 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2175 Returns the widget created. */
2178 xg_create_widget (char *type
, char *name
, FRAME_PTR f
, widget_value
*val
,
2179 GCallback select_cb
, GCallback deactivate_cb
,
2180 GCallback highlight_cb
)
2183 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2184 int pop_up_p
= strcmp (type
, "popup") == 0;
2186 if (strcmp (type
, "dialog") == 0)
2188 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2189 xg_set_screen (w
, f
);
2190 gtk_window_set_transient_for (GTK_WINDOW (w
),
2191 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2192 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2193 gtk_widget_set_name (w
, "emacs-dialog");
2194 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2196 else if (menu_bar_p
|| pop_up_p
)
2198 w
= create_menus (val
->contents
,
2210 /* Set the cursor to an arrow for popup menus when they are mapped.
2211 This is done by default for menu bar menus. */
2214 /* Must realize so the GdkWindow inside the widget is created. */
2215 gtk_widget_realize (w
);
2216 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2221 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2228 /* Return the label for menu item WITEM. */
2231 xg_get_menu_item_label (GtkMenuItem
*witem
)
2233 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2234 return gtk_label_get_label (wlabel
);
2237 /* Return non-zero if the menu item WITEM has the text LABEL. */
2240 xg_item_label_same_p (GtkMenuItem
*witem
, char *label
)
2243 char *utf8_label
= get_utf8_string (label
);
2244 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2246 if (! old_label
&& ! utf8_label
)
2248 else if (old_label
&& utf8_label
)
2249 is_same
= strcmp (utf8_label
, old_label
) == 0;
2251 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2256 /* Destroy widgets in LIST. */
2259 xg_destroy_widgets (GList
*list
)
2263 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2265 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2267 /* Destroying the widget will remove it from the container it is in. */
2268 gtk_widget_destroy (w
);
2272 /* Update the top level names in MENUBAR (i.e. not submenus).
2273 F is the frame the menu bar belongs to.
2274 *LIST is a list with the current menu bar names (menu item widgets).
2275 ITER is the item within *LIST that shall be updated.
2276 POS is the numerical position, starting at 0, of ITER in *LIST.
2277 VAL describes what the menu bar shall look like after the update.
2278 SELECT_CB is the callback to use when a menu item is selected.
2279 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2280 CL_DATA points to the callback data to be used for this menu bar.
2282 This function calls itself to walk through the menu bar names. */
2285 xg_update_menubar (GtkWidget
*menubar
,
2291 GCallback select_cb
,
2292 GCallback deactivate_cb
,
2293 GCallback highlight_cb
,
2294 xg_menu_cb_data
*cl_data
)
2296 if (! iter
&& ! val
)
2298 else if (iter
&& ! val
)
2300 /* Item(s) have been removed. Remove all remaining items. */
2301 xg_destroy_widgets (iter
);
2303 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2304 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2305 gtk_menu_item_new_with_label (""),
2311 else if (! iter
&& val
)
2313 /* Item(s) added. Add all new items in one call. */
2314 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2315 0, 1, 0, menubar
, cl_data
, 0);
2321 /* Below this neither iter or val is NULL */
2322 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2324 /* This item is still the same, check next item. */
2326 iter
= g_list_next (iter
);
2329 else /* This item is changed. */
2331 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2332 GtkMenuItem
*witem2
= 0;
2333 int val_in_menubar
= 0;
2334 int iter_in_new_menubar
= 0;
2338 /* See if the changed entry (val) is present later in the menu bar */
2340 iter2
&& ! val_in_menubar
;
2341 iter2
= g_list_next (iter2
))
2343 witem2
= GTK_MENU_ITEM (iter2
->data
);
2344 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2347 /* See if the current entry (iter) is present later in the
2348 specification for the new menu bar. */
2349 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2350 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2352 if (val_in_menubar
&& ! iter_in_new_menubar
)
2356 /* This corresponds to:
2361 g_object_ref (G_OBJECT (witem
));
2362 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2363 gtk_widget_destroy (GTK_WIDGET (witem
));
2365 /* Must get new list since the old changed. */
2366 g_list_free (*list
);
2367 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2368 while (nr
-- > 0) iter
= g_list_next (iter
);
2370 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2372 /* This corresponds to:
2375 Rename B to X. This might seem to be a strange thing to do,
2376 since if there is a menu under B it will be totally wrong for X.
2377 But consider editing a C file. Then there is a C-mode menu
2378 (corresponds to B above).
2379 If then doing C-x C-f the minibuf menu (X above) replaces the
2380 C-mode menu. When returning from the minibuffer, we get
2381 back the C-mode menu. Thus we do:
2382 Rename B to X (C-mode to minibuf menu)
2383 Rename X to B (minibuf to C-mode menu).
2384 If the X menu hasn't been invoked, the menu under B
2385 is up to date when leaving the minibuffer. */
2386 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2387 char *utf8_label
= get_utf8_string (val
->name
);
2388 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2390 gtk_label_set_text (wlabel
, utf8_label
);
2392 /* If this item has a submenu that has been detached, change
2393 the title in the WM decorations also. */
2394 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2395 /* Set the title of the detached window. */
2396 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2398 iter
= g_list_next (iter
);
2402 else if (! val_in_menubar
&& iter_in_new_menubar
)
2404 /* This corresponds to:
2411 GtkWidget
*w
= xg_create_one_menuitem (val
,
2418 /* Create a possibly empty submenu for menu bar items, since some
2419 themes don't highlight items correctly without it. */
2420 GtkWidget
*submenu
= create_menus (NULL
, f
,
2421 select_cb
, deactivate_cb
,
2423 0, 0, 0, 0, cl_data
, 0);
2424 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2425 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2426 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2428 g_list_free (*list
);
2429 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2430 while (nr
-- > 0) iter
= g_list_next (iter
);
2431 iter
= g_list_next (iter
);
2435 else /* if (val_in_menubar && iter_in_new_menubar) */
2438 /* This corresponds to:
2443 g_object_ref (G_OBJECT (witem2
));
2444 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2445 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2446 GTK_WIDGET (witem2
), pos
);
2447 g_object_unref (G_OBJECT (witem2
));
2449 g_list_free (*list
);
2450 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2451 while (nr
-- > 0) iter
= g_list_next (iter
);
2452 if (iter
) iter
= g_list_next (iter
);
2458 /* Update the rest of the menu bar. */
2459 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2460 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2463 /* Update the menu item W so it corresponds to VAL.
2464 SELECT_CB is the callback to use when a menu item is selected.
2465 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2466 CL_DATA is the data to set in the widget for menu invocation. */
2469 xg_update_menu_item (widget_value
*val
,
2471 GCallback select_cb
,
2472 GCallback highlight_cb
,
2473 xg_menu_cb_data
*cl_data
)
2480 const char *old_label
= 0;
2481 const char *old_key
= 0;
2482 xg_menu_item_cb_data
*cb_data
;
2484 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2485 utf8_label
= get_utf8_string (val
->name
);
2486 utf8_key
= get_utf8_string (val
->key
);
2488 /* See if W is a menu item with a key. See make_menu_item above. */
2489 if (GTK_IS_HBOX (wchild
))
2491 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2493 wlbl
= GTK_LABEL (list
->data
);
2494 wkey
= GTK_LABEL (list
->next
->data
);
2499 /* Remove the key and keep just the label. */
2500 g_object_ref (G_OBJECT (wlbl
));
2501 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2502 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2503 g_object_unref (G_OBJECT (wlbl
));
2508 else /* Just a label. */
2510 wlbl
= GTK_LABEL (wchild
);
2512 /* Check if there is now a key. */
2515 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2516 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2518 wlbl
= GTK_LABEL (list
->data
);
2519 wkey
= GTK_LABEL (list
->next
->data
);
2522 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2523 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2528 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2529 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2531 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2532 gtk_label_set_text (wkey
, utf8_key
);
2534 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2535 gtk_label_set_text (wlbl
, utf8_label
);
2537 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2538 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2540 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2541 gtk_widget_set_sensitive (w
, FALSE
);
2542 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2543 gtk_widget_set_sensitive (w
, TRUE
);
2545 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2549 cb_data
->call_data
= val
->call_data
;
2550 cb_data
->help
= val
->help
;
2551 cb_data
->cl_data
= cl_data
;
2553 /* We assume the callback functions don't change. */
2554 if (val
->call_data
&& ! val
->contents
)
2556 /* This item shall have a select callback. */
2557 if (! cb_data
->select_id
)
2559 = g_signal_connect (G_OBJECT (w
), "activate",
2560 select_cb
, cb_data
);
2562 else if (cb_data
->select_id
)
2564 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2565 cb_data
->select_id
= 0;
2570 /* Update the toggle menu item W so it corresponds to VAL. */
2573 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
2575 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2578 /* Update the radio menu item W so it corresponds to VAL. */
2581 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
2583 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2586 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2587 SUBMENU may be NULL, in that case a new menu is created.
2588 F is the frame the menu bar belongs to.
2589 VAL describes the contents of the menu bar.
2590 SELECT_CB is the callback to use when a menu item is selected.
2591 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2592 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2593 CL_DATA is the call back data to use for any newly created items.
2595 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2599 xg_update_submenu (GtkWidget
*submenu
,
2602 GCallback select_cb
,
2603 GCallback deactivate_cb
,
2604 GCallback highlight_cb
,
2605 xg_menu_cb_data
*cl_data
)
2607 GtkWidget
*newsub
= submenu
;
2611 int has_tearoff_p
= 0;
2612 GList
*first_radio
= 0;
2615 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2617 for (cur
= val
, iter
= list
;
2619 iter
= g_list_next (iter
), cur
= cur
->next
)
2621 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2623 /* Skip tearoff items, they have no counterpart in val. */
2624 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2627 iter
= g_list_next (iter
);
2628 if (iter
) w
= GTK_WIDGET (iter
->data
);
2632 /* Remember first radio button in a group. If we get a mismatch in
2633 a radio group we must rebuild the whole group so that the connections
2634 in GTK becomes correct. */
2635 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2637 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2638 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2641 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2643 if (! xg_separator_p (cur
->name
))
2646 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2648 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2650 xg_update_toggle_item (cur
, w
);
2651 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2653 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2655 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2657 xg_update_radio_item (cur
, w
);
2658 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2660 else if (GTK_IS_MENU_ITEM (w
))
2662 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2665 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2666 xg_separator_p (cur
->name
))
2669 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2671 sub
= gtk_menu_item_get_submenu (witem
);
2672 if (sub
&& ! cur
->contents
)
2674 /* Not a submenu anymore. */
2675 g_object_ref (G_OBJECT (sub
));
2676 remove_submenu (witem
);
2677 gtk_widget_destroy (sub
);
2679 else if (cur
->contents
)
2683 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2684 select_cb
, deactivate_cb
,
2685 highlight_cb
, cl_data
);
2687 /* If this item just became a submenu, we must set it. */
2689 gtk_menu_item_set_submenu (witem
, nsub
);
2694 /* Structural difference. Remove everything from here and down
2700 /* Remove widgets from first structual change. */
2703 /* If we are adding new menu items below, we must remove from
2704 first radio button so that radio groups become correct. */
2705 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2706 else xg_destroy_widgets (iter
);
2711 /* More items added. Create them. */
2712 newsub
= create_menus (cur
,
2725 if (list
) g_list_free (list
);
2730 /* Update the MENUBAR.
2731 F is the frame the menu bar belongs to.
2732 VAL describes the contents of the menu bar.
2733 If DEEP_P is non-zero, rebuild all but the top level menu names in
2734 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2735 SELECT_CB is the callback to use when a menu item is selected.
2736 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2737 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2740 xg_modify_menubar_widgets (GtkWidget
*menubar
, FRAME_PTR f
, widget_value
*val
,
2742 GCallback select_cb
, GCallback deactivate_cb
,
2743 GCallback highlight_cb
)
2745 xg_menu_cb_data
*cl_data
;
2746 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2750 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2753 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2754 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2760 /* Update all sub menus.
2761 We must keep the submenus (GTK menu item widgets) since the
2762 X Window in the XEvent that activates the menu are those widgets. */
2764 /* Update cl_data, menu_item things in F may have changed. */
2765 update_cl_data (cl_data
, f
, highlight_cb
);
2767 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2772 GtkMenuItem
*witem
= 0;
2774 /* Find sub menu that corresponds to val and update it. */
2775 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2777 witem
= GTK_MENU_ITEM (iter
->data
);
2778 if (xg_item_label_same_p (witem
, cur
->name
))
2780 sub
= gtk_menu_item_get_submenu (witem
);
2785 newsub
= xg_update_submenu (sub
,
2792 /* sub may still be NULL. If we just updated non deep and added
2793 a new menu bar item, it has no sub menu yet. So we set the
2794 newly created sub menu under witem. */
2795 if (newsub
!= sub
&& witem
!= 0)
2797 xg_set_screen (newsub
, f
);
2798 gtk_menu_item_set_submenu (witem
, newsub
);
2804 gtk_widget_show_all (menubar
);
2807 /* Recompute all the widgets of frame F, when the menu bar has been
2808 changed. Value is non-zero if widgets were updated. */
2811 xg_update_frame_menubar (FRAME_PTR f
)
2813 struct x_output
*x
= f
->output_data
.x
;
2816 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
2819 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
2820 return 0; /* Already done this, happens for frames created invisible. */
2824 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2826 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2828 gtk_widget_show_all (x
->menubar_widget
);
2829 gtk_widget_size_request (x
->menubar_widget
, &req
);
2830 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2831 xg_height_changed (f
);
2837 /* Get rid of the menu bar of frame F, and free its storage.
2838 This is used when deleting a frame, and when turning off the menu bar. */
2841 free_frame_menubar (FRAME_PTR f
)
2843 struct x_output
*x
= f
->output_data
.x
;
2845 if (x
->menubar_widget
)
2849 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2850 /* The menubar and its children shall be deleted when removed from
2852 x
->menubar_widget
= 0;
2853 FRAME_MENUBAR_HEIGHT (f
) = 0;
2854 xg_height_changed (f
);
2861 /***********************************************************************
2862 Scroll bar functions
2863 ***********************************************************************/
2866 /* Setting scroll bar values invokes the callback. Use this variable
2867 to indicate that callback should do nothing. */
2869 int xg_ignore_gtk_scrollbar
;
2871 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
2872 may be larger than 32 bits. Keep a mapping from integer index to widget
2873 pointers to get around the 32 bit limitation. */
2877 GtkWidget
**widgets
;
2882 /* Grow this much every time we need to allocate more */
2884 #define ID_TO_WIDGET_INCR 32
2886 /* Store the widget pointer W in id_to_widget and return the integer index. */
2889 xg_store_widget_in_map (GtkWidget
*w
)
2893 if (id_to_widget
.max_size
== id_to_widget
.used
)
2895 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
2897 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
2898 sizeof (GtkWidget
*)*new_size
);
2900 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
2901 id_to_widget
.widgets
[i
] = 0;
2902 id_to_widget
.max_size
= new_size
;
2905 /* Just loop over the array and find a free place. After all,
2906 how many scroll bars are we creating? Should be a small number.
2907 The check above guarantees we will find a free place. */
2908 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
2910 if (! id_to_widget
.widgets
[i
])
2912 id_to_widget
.widgets
[i
] = w
;
2913 ++id_to_widget
.used
;
2919 /* Should never end up here */
2923 /* Remove pointer at IDX from id_to_widget.
2924 Called when scroll bar is destroyed. */
2927 xg_remove_widget_from_map (int idx
)
2929 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2931 id_to_widget
.widgets
[idx
] = 0;
2932 --id_to_widget
.used
;
2936 /* Get the widget pointer at IDX from id_to_widget. */
2939 xg_get_widget_from_map (int idx
)
2941 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2942 return id_to_widget
.widgets
[idx
];
2947 /* Return the scrollbar id for X Window WID on display DPY.
2948 Return -1 if WID not in id_to_widget. */
2951 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
2956 w
= xg_win_to_widget (dpy
, wid
);
2960 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
2961 if (id_to_widget
.widgets
[idx
] == w
)
2968 /* Callback invoked when scroll bar WIDGET is destroyed.
2969 DATA is the index into id_to_widget for WIDGET.
2970 We free pointer to last scroll bar values here and remove the index. */
2973 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
2975 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
2976 xg_remove_widget_from_map (id
);
2979 /* Create a scroll bar widget for frame F. Store the scroll bar
2981 SCROLL_CALLBACK is the callback to invoke when the value of the
2983 END_CALLBACK is the callback to invoke when scrolling ends.
2984 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
2985 to set resources for the widget. */
2988 xg_create_scroll_bar (FRAME_PTR f
,
2989 struct scroll_bar
*bar
,
2990 GCallback scroll_callback
,
2991 GCallback end_callback
,
2992 char *scroll_bar_name
)
2999 /* Page, step increment values are not so important here, they
3000 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3001 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3004 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3005 webox
= gtk_event_box_new ();
3006 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3007 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3008 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3010 scroll_id
= xg_store_widget_in_map (wscroll
);
3012 /* The EMACS_INT cast avoids a warning. */
3013 g_signal_connect (G_OBJECT (wscroll
),
3015 G_CALLBACK (xg_gtk_scroll_destroy
),
3016 (gpointer
) (EMACS_INT
) scroll_id
);
3017 g_signal_connect (G_OBJECT (wscroll
),
3021 g_signal_connect (G_OBJECT (wscroll
),
3022 "button-release-event",
3026 /* The scroll bar widget does not draw on a window of its own. Instead
3027 it draws on the parent window, in this case the edit widget. So
3028 whenever the edit widget is cleared, the scroll bar needs to redraw
3029 also, which causes flicker. Put an event box between the edit widget
3030 and the scroll bar, so the scroll bar instead draws itself on the
3031 event box window. */
3032 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3033 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3036 /* Set the cursor to an arrow. */
3037 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3039 bar
->x_window
= scroll_id
;
3042 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3045 xg_remove_scroll_bar (FRAME_PTR f
, int scrollbar_id
)
3047 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3050 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3051 gtk_widget_destroy (w
);
3052 gtk_widget_destroy (wparent
);
3053 SET_FRAME_GARBAGED (f
);
3057 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3059 TOP/LEFT are the new pixel positions where the bar shall appear.
3060 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3063 xg_update_scrollbar_pos (FRAME_PTR f
,
3071 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3075 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3076 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3079 /* Clear out old position. */
3080 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3081 if (gtk_widget_get_parent (wparent
) == wfixed
)
3083 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3084 "x", &oldx
, "y", &oldy
, NULL
);
3085 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3088 /* Move and resize to new values. */
3089 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3090 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3093 /* No room. Hide scroll bar as some themes output a warning if
3094 the height is less than the min size. */
3095 gtk_widget_hide (wparent
);
3096 gtk_widget_hide (wscroll
);
3100 gtk_widget_show_all (wparent
);
3101 gtk_widget_set_size_request (wscroll
, width
, height
);
3103 gtk_widget_queue_draw (wfixed
);
3104 gdk_window_process_all_updates ();
3105 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3107 /* Clear under old scroll bar position. This must be done after
3108 the gtk_widget_queue_draw and gdk_window_process_all_updates
3110 x_clear_area (FRAME_X_DISPLAY (f
),
3112 oldx
, oldy
, oldw
, oldh
, 0);
3115 /* GTK does not redraw until the main loop is entered again, but
3116 if there are no X events pending we will not enter it. So we sync
3117 here to get some events. */
3120 SET_FRAME_GARBAGED (f
);
3121 cancel_mouse_face (f
);
3125 /* Set the thumb size and position of scroll bar BAR. We are currently
3126 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3129 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3134 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3136 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3138 if (wscroll
&& NILP (bar
->dragging
))
3147 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3149 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3150 rather than the real portion value. This makes the thumb less likely
3151 to resize and that looks better. */
3152 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3153 /* When the thumb is at the bottom, position == whole.
3154 So we need to increase `whole' to make space for the thumb. */
3161 top
= (gdouble
) position
/ whole
;
3162 shown
= (gdouble
) portion
/ whole
;
3165 size
= shown
* XG_SB_RANGE
;
3166 size
= min (size
, XG_SB_RANGE
);
3167 size
= max (size
, 1);
3169 value
= top
* XG_SB_RANGE
;
3170 value
= min (value
, XG_SB_MAX
- size
);
3171 value
= max (value
, XG_SB_MIN
);
3173 /* Assume all lines are of equal size. */
3174 new_step
= size
/ max (1, FRAME_LINES (f
));
3176 if ((int) gtk_adjustment_get_page_size (adj
) != size
3177 || (int) gtk_adjustment_get_step_increment (adj
) != new_step
)
3179 gtk_adjustment_set_page_size (adj
, size
);
3180 gtk_adjustment_set_step_increment (adj
, new_step
);
3181 /* Assume a page increment is about 95% of the page size */
3182 gtk_adjustment_set_page_increment (adj
,(int) (0.95*size
));
3186 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3190 /* gtk_range_set_value invokes the callback. Set
3191 ignore_gtk_scrollbar to make the callback do nothing */
3192 xg_ignore_gtk_scrollbar
= 1;
3194 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3195 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3197 gtk_adjustment_changed (adj
);
3199 xg_ignore_gtk_scrollbar
= 0;
3206 /* Return non-zero if EVENT is for a scroll bar in frame F.
3207 When the same X window is used for several Gtk+ widgets, we cannot
3208 say for sure based on the X window alone if an event is for the
3209 frame. This function does additional checks.
3211 Return non-zero if the event is for a scroll bar, zero otherwise. */
3214 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3218 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3220 /* Check if press occurred outside the edit widget. */
3221 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3222 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3223 != gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3226 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3227 || event
->type
== MotionNotify
))
3229 /* If we are releasing or moving the scroll bar, it has the grab. */
3230 GtkWidget
*w
= gtk_grab_get_current ();
3231 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3239 /***********************************************************************
3241 ***********************************************************************/
3242 /* The key for the data we put in the GtkImage widgets. The data is
3243 the image used by Emacs. We use this to see if we need to update
3244 the GtkImage with a new image. */
3245 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3247 /* The key for storing the latest modifiers so the activate callback can
3249 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3251 /* The key for storing the button widget in its proxy menu item. */
3252 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3254 /* The key for the data we put in the GtkImage widgets. The data is
3255 the stock name used by Emacs. We use this to see if we need to update
3256 the GtkImage with a new image. */
3257 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3259 /* As above, but this is used for named theme widgets, as opposed to
3261 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3263 /* Callback function invoked when a tool bar item is pressed.
3264 W is the button widget in the tool bar that got pressed,
3265 CLIENT_DATA is an integer that is the index of the button in the
3266 tool bar. 0 is the first button. */
3269 xg_tool_bar_button_cb (GtkWidget
*widget
,
3270 GdkEventButton
*event
,
3273 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3274 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3275 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3280 /* Callback function invoked when a tool bar item is pressed.
3281 W is the button widget in the tool bar that got pressed,
3282 CLIENT_DATA is an integer that is the index of the button in the
3283 tool bar. 0 is the first button. */
3286 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3288 /* The EMACS_INT cast avoids a warning. */
3289 int idx
= (int) (EMACS_INT
) client_data
;
3290 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3291 XG_TOOL_BAR_LAST_MODIFIER
);
3293 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3294 Lisp_Object key
, frame
;
3295 struct input_event event
;
3298 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3301 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3303 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3304 XSETFRAME (frame
, f
);
3306 /* We generate two events here. The first one is to set the prefix
3307 to `(tool_bar)', see keyboard.c. */
3308 event
.kind
= TOOL_BAR_EVENT
;
3309 event
.frame_or_window
= frame
;
3311 kbd_buffer_store_event (&event
);
3313 event
.kind
= TOOL_BAR_EVENT
;
3314 event
.frame_or_window
= frame
;
3316 /* Convert between the modifier bits GDK uses and the modifier bits
3317 Emacs uses. This assumes GDK and X masks are the same, which they are when
3319 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3320 kbd_buffer_store_event (&event
);
3322 /* Return focus to the frame after we have clicked on a detached
3324 Fx_focus_frame (frame
);
3327 /* Callback function invoked when a tool bar item is pressed in a detached
3328 tool bar or the overflow drop down menu.
3329 We just call xg_tool_bar_callback.
3330 W is the menu item widget that got pressed,
3331 CLIENT_DATA is an integer that is the index of the button in the
3332 tool bar. 0 is the first button. */
3335 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3337 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3338 XG_TOOL_BAR_PROXY_BUTTON
));
3339 xg_tool_bar_callback (wbutton
, client_data
);
3344 xg_tool_bar_help_callback (GtkWidget
*w
,
3345 GdkEventCrossing
*event
,
3346 gpointer client_data
);
3348 /* This callback is called when a help is to be shown for an item in
3349 the detached tool bar when the detached tool bar it is not expanded. */
3352 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3353 GdkEventCrossing
*event
,
3354 gpointer client_data
)
3356 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3357 XG_TOOL_BAR_PROXY_BUTTON
));
3359 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3363 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3365 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3366 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3367 GtkWidget
*c2
= (GtkWidget
*) clist
->next
->data
;
3368 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3369 g_list_free (clist
);
3370 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3374 /* This callback is called when a tool item should create a proxy item,
3375 such as for the overflow menu. Also called when the tool bar is detached.
3376 If we don't create a proxy menu item, the detached tool bar will be
3380 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3382 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (toolitem
));
3383 GtkButton
*wbutton
= GTK_BUTTON (gtk_bin_get_child (GTK_BIN (weventbox
)));
3384 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
3386 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3387 GtkImage
*wimage
= GTK_IMAGE (c1
);
3388 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3389 (gtk_label_get_text (wlbl
));
3390 GtkWidget
*wmenuimage
;
3393 if (gtk_button_get_use_stock (wbutton
))
3394 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3395 GTK_ICON_SIZE_MENU
);
3398 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3399 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3401 if (store_type
== GTK_IMAGE_STOCK
)
3404 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3405 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3407 else if (store_type
== GTK_IMAGE_ICON_SET
)
3409 GtkIconSet
*icon_set
;
3410 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3411 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3412 GTK_ICON_SIZE_MENU
);
3414 else if (store_type
== GTK_IMAGE_PIXBUF
)
3419 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3422 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3424 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3425 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3426 GDK_INTERP_BILINEAR
);
3428 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3432 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3436 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3438 const gchar
*icon_name
;
3439 GtkIconSize icon_size
;
3441 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3442 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3443 GTK_ICON_SIZE_MENU
);
3447 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3452 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3454 g_signal_connect (G_OBJECT (wmenuitem
),
3456 G_CALLBACK (xg_tool_bar_proxy_callback
),
3460 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3461 (gpointer
) wbutton
);
3462 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3463 gtk_widget_set_sensitive (wmenuitem
,
3464 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
3466 /* Use enter/leave notify to show help. We use the events
3467 rather than the GtkButton specific signals "enter" and
3468 "leave", so we can have only one callback. The event
3469 will tell us what kind of event it is. */
3470 g_signal_connect (G_OBJECT (wmenuitem
),
3471 "enter-notify-event",
3472 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3474 g_signal_connect (G_OBJECT (wmenuitem
),
3475 "leave-notify-event",
3476 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3482 /* This callback is called when a tool bar is detached. We must set
3483 the height of the tool bar to zero when this happens so frame sizes
3484 are correctly calculated.
3485 WBOX is the handle box widget that enables detach/attach of the tool bar.
3486 W is the tool bar widget.
3487 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3490 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
3492 gpointer client_data
)
3494 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3495 extern int x_gtk_whole_detached_tool_bar
;
3497 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3502 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3504 /* When detaching a tool bar, not everything dissapear. There are
3505 a few pixels left that are used to drop the tool bar back into
3507 FRAME_TOOLBAR_HEIGHT (f
) = 4;
3508 xg_height_changed (f
);
3512 /* This callback is called when a tool bar is reattached. We must set
3513 the height of the tool bar when this happens so frame sizes
3514 are correctly calculated.
3515 WBOX is the handle box widget that enables detach/attach of the tool bar.
3516 W is the tool bar widget.
3517 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3520 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
3522 gpointer client_data
)
3524 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3525 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3531 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3533 gtk_widget_size_request (w
, &req
);
3534 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3535 xg_height_changed (f
);
3539 /* This callback is called when the mouse enters or leaves a tool bar item.
3540 It is used for displaying and hiding the help text.
3541 W is the tool bar item, a button.
3542 EVENT is either an enter event or leave event.
3543 CLIENT_DATA is an integer that is the index of the button in the
3544 tool bar. 0 is the first button.
3546 Returns FALSE to tell GTK to keep processing this event. */
3549 xg_tool_bar_help_callback (GtkWidget
*w
,
3550 GdkEventCrossing
*event
,
3551 gpointer client_data
)
3553 /* The EMACS_INT cast avoids a warning. */
3554 int idx
= (int) (EMACS_INT
) client_data
;
3555 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3556 Lisp_Object help
, frame
;
3558 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3561 if (event
->type
== GDK_ENTER_NOTIFY
)
3563 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3564 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3567 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3572 XSETFRAME (frame
, f
);
3573 kbd_buffer_store_help_event (frame
, help
);
3579 /* This callback is called when a tool bar item shall be redrawn.
3580 It modifies the expose event so that the GtkImage widget redraws the
3581 whole image. This to overcome a bug that makes GtkImage draw the image
3582 in the wrong place when it tries to redraw just a part of the image.
3583 W is the GtkImage to be redrawn.
3584 EVENT is the expose event for W.
3585 CLIENT_DATA is unused.
3587 Returns FALSE to tell GTK to keep processing this event. */
3590 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
3591 GdkEventExpose
*event
,
3592 gpointer client_data
)
3596 gdk_drawable_get_size (event
->window
, &width
, &height
);
3598 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3599 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3601 event
->area
.x
= max (0, event
->area
.x
);
3602 event
->area
.y
= max (0, event
->area
.y
);
3604 event
->area
.width
= max (width
, event
->area
.width
);
3605 event
->area
.height
= max (height
, event
->area
.height
);
3610 /* Attach a tool bar to frame F. */
3613 xg_pack_tool_bar (FRAME_PTR f
)
3615 struct x_output
*x
= f
->output_data
.x
;
3616 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3618 x
->handlebox_widget
= gtk_handle_box_new ();
3619 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3620 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3621 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3622 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3624 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3627 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3630 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3633 gtk_widget_show (x
->toolbar_widget
);
3634 gtk_widget_show (x
->handlebox_widget
);
3637 /* Create a tool bar for frame F. */
3638 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
3639 #define toolbar_set_orientation(w, o) \
3640 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
3642 #define toolbar_set_orientation(w, o) \
3643 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
3647 xg_create_tool_bar (FRAME_PTR f
)
3649 struct x_output
*x
= f
->output_data
.x
;
3651 x
->toolbar_widget
= gtk_toolbar_new ();
3652 x
->toolbar_detached
= 0;
3654 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3656 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3657 toolbar_set_orientation (x
->toolbar_widget
,
3658 GTK_ORIENTATION_HORIZONTAL
);
3662 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3664 /* Find the right-to-left image named by RTL in the tool bar images for F.
3665 Returns IMAGE if RTL is not found. */
3668 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
3671 Lisp_Object file
, rtl_name
;
3672 struct gcpro gcpro1
, gcpro2
;
3673 GCPRO2 (file
, rtl_name
);
3675 rtl_name
= Ffile_name_nondirectory (rtl
);
3677 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3679 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3680 if (!NILP (file
= file_for_image (rtl_image
)))
3682 file
= call1 (intern ("file-name-sans-extension"),
3683 Ffile_name_nondirectory (file
));
3684 if (EQ (Fequal (file
, rtl_name
), Qt
))
3695 static GtkToolItem
*
3696 xg_make_tool_item (FRAME_PTR f
,
3698 GtkWidget
**wbutton
,
3702 GtkToolItem
*ti
= gtk_tool_item_new ();
3703 GtkWidget
*vb
= EQ (Vtool_bar_style
, Qboth_horiz
)
3704 ? gtk_hbox_new (FALSE
, 0) : gtk_vbox_new (FALSE
, 0);
3705 GtkWidget
*wb
= gtk_button_new ();
3706 GtkWidget
*weventbox
= gtk_event_box_new ();
3709 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
3711 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
3712 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
3713 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
3714 gtk_container_add (GTK_CONTAINER (wb
), vb
);
3715 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
3716 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
3720 /* The EMACS_INT cast avoids a warning. */
3721 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
3722 G_CALLBACK (xg_tool_bar_menu_proxy
),
3723 (gpointer
) (EMACS_INT
) i
);
3725 g_signal_connect (G_OBJECT (wb
), "clicked",
3726 G_CALLBACK (xg_tool_bar_callback
),
3727 (gpointer
) (EMACS_INT
) i
);
3729 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
3731 /* Catch expose events to overcome an annoying redraw bug, see
3732 comment for xg_tool_bar_item_expose_callback. */
3733 g_signal_connect (G_OBJECT (ti
),
3735 G_CALLBACK (xg_tool_bar_item_expose_callback
),
3738 gtk_tool_item_set_homogeneous (ti
, FALSE
);
3740 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
3741 no distinction based on modifiers in the activate callback,
3742 so we have to do it ourselves. */
3743 g_signal_connect (wb
, "button-release-event",
3744 G_CALLBACK (xg_tool_bar_button_cb
),
3747 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
3749 /* Use enter/leave notify to show help. We use the events
3750 rather than the GtkButton specific signals "enter" and
3751 "leave", so we can have only one callback. The event
3752 will tell us what kind of event it is. */
3753 /* The EMACS_INT cast avoids a warning. */
3754 g_signal_connect (G_OBJECT (weventbox
),
3755 "enter-notify-event",
3756 G_CALLBACK (xg_tool_bar_help_callback
),
3757 (gpointer
) (EMACS_INT
) i
);
3758 g_signal_connect (G_OBJECT (weventbox
),
3759 "leave-notify-event",
3760 G_CALLBACK (xg_tool_bar_help_callback
),
3761 (gpointer
) (EMACS_INT
) i
);
3764 if (wbutton
) *wbutton
= wb
;
3770 xg_show_toolbar_item (GtkToolItem
*ti
)
3772 Lisp_Object style
= Ftool_bar_get_system_style ();
3774 int show_label
= EQ (style
, Qboth
)
3775 || EQ (style
, Qboth_horiz
) || EQ (style
, Qtext
);
3776 int show_image
= ! EQ (style
, Qtext
);
3777 int horiz
= EQ (style
, Qboth_horiz
);
3779 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3780 GtkWidget
*wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3781 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
3783 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
3784 GtkWidget
*new_box
= NULL
;
3786 if (GTK_IS_VBOX (vb
) && horiz
)
3787 new_box
= gtk_hbox_new (FALSE
, 0);
3788 else if (GTK_IS_HBOX (vb
) && !horiz
&& show_label
&& show_image
)
3789 new_box
= gtk_vbox_new (FALSE
, 0);
3792 g_object_ref (G_OBJECT (wimage
));
3793 g_object_ref (G_OBJECT (wlbl
));
3794 gtk_container_remove (GTK_CONTAINER (vb
), wimage
);
3795 gtk_container_remove (GTK_CONTAINER (vb
), wlbl
);
3796 gtk_widget_destroy (GTK_WIDGET (vb
));
3797 gtk_box_pack_start (GTK_BOX (new_box
), wimage
, TRUE
, TRUE
, 0);
3798 gtk_box_pack_start (GTK_BOX (new_box
), wlbl
, TRUE
, TRUE
, 0);
3799 gtk_container_add (GTK_CONTAINER (wbutton
), new_box
);
3800 g_object_unref (G_OBJECT (wimage
));
3801 g_object_unref (G_OBJECT (wlbl
));
3805 if (show_label
) gtk_widget_show (wlbl
);
3806 else gtk_widget_hide (wlbl
);
3807 if (show_image
) gtk_widget_show (wimage
);
3808 else gtk_widget_hide (wimage
);
3809 gtk_widget_show (GTK_WIDGET (weventbox
));
3810 gtk_widget_show (GTK_WIDGET (vb
));
3811 gtk_widget_show (GTK_WIDGET (wbutton
));
3812 gtk_widget_show (GTK_WIDGET (ti
));
3816 /* Update the tool bar for frame F. Add new buttons and remove old. */
3818 extern Lisp_Object Qx_gtk_map_stock
;
3821 update_frame_tool_bar (FRAME_PTR f
)
3824 GtkRequisition old_req
, new_req
;
3825 struct x_output
*x
= f
->output_data
.x
;
3826 int hmargin
= 0, vmargin
= 0;
3827 GtkToolbar
*wtoolbar
;
3829 GtkTextDirection dir
;
3830 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
3832 if (! FRAME_GTK_WIDGET (f
))
3837 if (INTEGERP (Vtool_bar_button_margin
)
3838 && XINT (Vtool_bar_button_margin
) > 0)
3840 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3841 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3843 else if (CONSP (Vtool_bar_button_margin
))
3845 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3846 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3847 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3849 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3850 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3851 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3854 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3855 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3856 i.e. zero. This means that margins less than
3857 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3858 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3859 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3861 if (! x
->toolbar_widget
)
3862 xg_create_tool_bar (f
);
3864 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
3865 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &old_req
);
3866 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
3868 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3870 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3871 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3875 struct image
*img
= NULL
;
3877 Lisp_Object stock
= Qnil
;
3878 GtkStockItem stock_item
;
3879 char *stock_name
= NULL
;
3880 char *icon_name
= NULL
;
3882 GtkWidget
*wbutton
= NULL
;
3883 GtkWidget
*weventbox
;
3884 Lisp_Object specified_file
;
3885 char *label
= SSDATA (PROP (TOOL_BAR_ITEM_LABEL
));
3887 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), i
);
3891 weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3892 wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3896 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3898 /* Ignore invalid image specifications. */
3899 if (!valid_image_p (image
))
3901 if (wbutton
) gtk_widget_hide (wbutton
);
3905 specified_file
= file_for_image (image
);
3906 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
3907 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
3909 if (STRINGP (stock
))
3911 stock_name
= SSDATA (stock
);
3912 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
3914 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
3915 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
3917 icon_name
= stock_name
+ 2;
3921 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
3924 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3926 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
3927 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3935 if (stock_name
== NULL
&& icon_name
== NULL
)
3937 /* No stock image, or stock item not known. Try regular image. */
3939 /* If image is a vector, choose the image according to the
3941 if (dir
== GTK_TEXT_DIR_RTL
3942 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
3945 image
= find_rtl_image (f
, image
, rtl
);
3948 if (VECTORP (image
))
3952 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3953 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3956 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3957 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3959 xassert (ASIZE (image
) >= idx
);
3960 image
= AREF (image
, idx
);
3965 img_id
= lookup_image (f
, image
);
3966 img
= IMAGE_FROM_ID (f
, img_id
);
3967 prepare_image_for_display (f
, img
);
3969 if (img
->load_failed_p
|| img
->pixmap
== None
)
3972 gtk_widget_hide_all (GTK_WIDGET (ti
));
3975 /* Insert an empty (non-image) button */
3976 ti
= xg_make_tool_item (f
, NULL
, NULL
, "", i
);
3977 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, -1);
3988 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
3989 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
3990 (gpointer
) xstrdup (stock_name
),
3991 (GDestroyNotify
) xfree
);
3995 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
3996 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
3997 (gpointer
) xstrdup (icon_name
),
3998 (GDestroyNotify
) xfree
);
4002 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4003 /* Save the image so we can see if an update is needed when
4004 this function is called again. */
4005 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4006 (gpointer
)img
->pixmap
);
4009 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4010 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
);
4011 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, -1);
4012 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4016 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
4018 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4020 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
4021 XG_TOOL_BAR_IMAGE_DATA
);
4022 gpointer old_stock_name
= g_object_get_data (G_OBJECT (wimage
),
4023 XG_TOOL_BAR_STOCK_NAME
);
4024 gpointer old_icon_name
= g_object_get_data (G_OBJECT (wimage
),
4025 XG_TOOL_BAR_ICON_NAME
);
4026 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4028 (! old_stock_name
|| strcmp (old_stock_name
, stock_name
) != 0))
4030 gtk_image_set_from_stock (GTK_IMAGE (wimage
),
4031 stock_name
, icon_size
);
4032 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4033 (gpointer
) xstrdup (stock_name
),
4034 (GDestroyNotify
) xfree
);
4035 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4037 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4040 else if (icon_name
&&
4041 (! old_icon_name
|| strcmp (old_icon_name
, icon_name
) != 0))
4043 gtk_image_set_from_icon_name (GTK_IMAGE (wimage
),
4044 icon_name
, icon_size
);
4045 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4046 (gpointer
) xstrdup (icon_name
),
4047 (GDestroyNotify
) xfree
);
4048 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4050 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4053 else if (img
&& old_img
!= img
->pixmap
)
4055 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
,
4056 GTK_IMAGE (wimage
));
4057 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4058 (gpointer
)img
->pixmap
);
4060 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4062 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4066 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
4068 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4070 xg_show_toolbar_item (ti
);
4075 /* Remove buttons not longer needed. We just hide them so they
4076 can be reused later on. */
4079 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), i
++);
4080 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
4081 } while (ti
!= NULL
);
4084 if (pack_tool_bar
&& f
->n_tool_bar_items
!= 0)
4085 xg_pack_tool_bar (f
);
4088 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &new_req
);
4089 if (old_req
.height
!= new_req
.height
4090 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
4092 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
4093 xg_height_changed (f
);
4098 /* Deallocate all resources for the tool bar on frame F.
4099 Remove the tool bar. */
4102 free_frame_tool_bar (FRAME_PTR f
)
4104 struct x_output
*x
= f
->output_data
.x
;
4106 if (x
->toolbar_widget
)
4108 int is_packed
= x
->handlebox_widget
!= 0;
4110 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4111 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4113 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4114 x
->handlebox_widget
);
4116 gtk_widget_destroy (x
->toolbar_widget
);
4118 x
->toolbar_widget
= 0;
4119 x
->handlebox_widget
= 0;
4120 FRAME_TOOLBAR_HEIGHT (f
) = 0;
4121 xg_height_changed (f
);
4129 /***********************************************************************
4131 ***********************************************************************/
4133 xg_initialize (void)
4135 GtkBindingSet
*binding_set
;
4138 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4139 we keep it permanently linked in. */
4144 xg_ignore_gtk_scrollbar
= 0;
4145 xg_detached_menus
= 0;
4146 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4147 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4149 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4150 id_to_widget
.widgets
= 0;
4152 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4153 bindings. It doesn't seem to be any way to remove properties,
4154 so we set it to VoidSymbol which in X means "no key". */
4155 gtk_settings_set_string_property (gtk_settings_get_default (),
4156 "gtk-menu-bar-accel",
4160 /* Make GTK text input widgets use Emacs style keybindings. This is
4162 gtk_settings_set_string_property (gtk_settings_get_default (),
4163 "gtk-key-theme-name",
4167 /* Make dialogs close on C-g. Since file dialog inherits from
4168 dialog, this works for them also. */
4169 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4170 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4173 /* Make menus close on C-g. */
4174 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4175 (GTK_TYPE_MENU_SHELL
));
4176 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4180 #endif /* USE_GTK */
4182 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
4183 (do not change this comment) */