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 (type
, name
, f
, val
,
2179 select_cb
, deactivate_cb
, highlight_cb
)
2184 GCallback select_cb
;
2185 GCallback deactivate_cb
;
2186 GCallback highlight_cb
;
2189 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2190 int pop_up_p
= strcmp (type
, "popup") == 0;
2192 if (strcmp (type
, "dialog") == 0)
2194 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2195 xg_set_screen (w
, f
);
2196 gtk_window_set_transient_for (GTK_WINDOW (w
),
2197 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2198 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2199 gtk_widget_set_name (w
, "emacs-dialog");
2200 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2202 else if (menu_bar_p
|| pop_up_p
)
2204 w
= create_menus (val
->contents
,
2216 /* Set the cursor to an arrow for popup menus when they are mapped.
2217 This is done by default for menu bar menus. */
2220 /* Must realize so the GdkWindow inside the widget is created. */
2221 gtk_widget_realize (w
);
2222 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2227 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2234 /* Return the label for menu item WITEM. */
2237 xg_get_menu_item_label (GtkMenuItem
*witem
)
2239 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2240 return gtk_label_get_label (wlabel
);
2243 /* Return non-zero if the menu item WITEM has the text LABEL. */
2246 xg_item_label_same_p (GtkMenuItem
*witem
, char *label
)
2249 char *utf8_label
= get_utf8_string (label
);
2250 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2252 if (! old_label
&& ! utf8_label
)
2254 else if (old_label
&& utf8_label
)
2255 is_same
= strcmp (utf8_label
, old_label
) == 0;
2257 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2262 /* Destroy widgets in LIST. */
2265 xg_destroy_widgets (GList
*list
)
2269 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2271 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2273 /* Destroying the widget will remove it from the container it is in. */
2274 gtk_widget_destroy (w
);
2278 /* Update the top level names in MENUBAR (i.e. not submenus).
2279 F is the frame the menu bar belongs to.
2280 *LIST is a list with the current menu bar names (menu item widgets).
2281 ITER is the item within *LIST that shall be updated.
2282 POS is the numerical position, starting at 0, of ITER in *LIST.
2283 VAL describes what the menu bar shall look like after the update.
2284 SELECT_CB is the callback to use when a menu item is selected.
2285 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2286 CL_DATA points to the callback data to be used for this menu bar.
2288 This function calls itself to walk through the menu bar names. */
2291 xg_update_menubar (GtkWidget
*menubar
,
2297 GCallback select_cb
,
2298 GCallback deactivate_cb
,
2299 GCallback highlight_cb
,
2300 xg_menu_cb_data
*cl_data
)
2302 if (! iter
&& ! val
)
2304 else if (iter
&& ! val
)
2306 /* Item(s) have been removed. Remove all remaining items. */
2307 xg_destroy_widgets (iter
);
2309 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2310 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2311 gtk_menu_item_new_with_label (""),
2317 else if (! iter
&& val
)
2319 /* Item(s) added. Add all new items in one call. */
2320 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2321 0, 1, 0, menubar
, cl_data
, 0);
2327 /* Below this neither iter or val is NULL */
2328 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2330 /* This item is still the same, check next item. */
2332 iter
= g_list_next (iter
);
2335 else /* This item is changed. */
2337 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2338 GtkMenuItem
*witem2
= 0;
2339 int val_in_menubar
= 0;
2340 int iter_in_new_menubar
= 0;
2344 /* See if the changed entry (val) is present later in the menu bar */
2346 iter2
&& ! val_in_menubar
;
2347 iter2
= g_list_next (iter2
))
2349 witem2
= GTK_MENU_ITEM (iter2
->data
);
2350 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2353 /* See if the current entry (iter) is present later in the
2354 specification for the new menu bar. */
2355 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2356 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2358 if (val_in_menubar
&& ! iter_in_new_menubar
)
2362 /* This corresponds to:
2367 g_object_ref (G_OBJECT (witem
));
2368 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2369 gtk_widget_destroy (GTK_WIDGET (witem
));
2371 /* Must get new list since the old changed. */
2372 g_list_free (*list
);
2373 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2374 while (nr
-- > 0) iter
= g_list_next (iter
);
2376 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2378 /* This corresponds to:
2381 Rename B to X. This might seem to be a strange thing to do,
2382 since if there is a menu under B it will be totally wrong for X.
2383 But consider editing a C file. Then there is a C-mode menu
2384 (corresponds to B above).
2385 If then doing C-x C-f the minibuf menu (X above) replaces the
2386 C-mode menu. When returning from the minibuffer, we get
2387 back the C-mode menu. Thus we do:
2388 Rename B to X (C-mode to minibuf menu)
2389 Rename X to B (minibuf to C-mode menu).
2390 If the X menu hasn't been invoked, the menu under B
2391 is up to date when leaving the minibuffer. */
2392 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2393 char *utf8_label
= get_utf8_string (val
->name
);
2394 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2396 gtk_label_set_text (wlabel
, utf8_label
);
2398 /* If this item has a submenu that has been detached, change
2399 the title in the WM decorations also. */
2400 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2401 /* Set the title of the detached window. */
2402 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2404 iter
= g_list_next (iter
);
2408 else if (! val_in_menubar
&& iter_in_new_menubar
)
2410 /* This corresponds to:
2417 GtkWidget
*w
= xg_create_one_menuitem (val
,
2424 /* Create a possibly empty submenu for menu bar items, since some
2425 themes don't highlight items correctly without it. */
2426 GtkWidget
*submenu
= create_menus (NULL
, f
,
2427 select_cb
, deactivate_cb
,
2429 0, 0, 0, 0, cl_data
, 0);
2430 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2431 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2432 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2434 g_list_free (*list
);
2435 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2436 while (nr
-- > 0) iter
= g_list_next (iter
);
2437 iter
= g_list_next (iter
);
2441 else /* if (val_in_menubar && iter_in_new_menubar) */
2444 /* This corresponds to:
2449 g_object_ref (G_OBJECT (witem2
));
2450 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2451 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2452 GTK_WIDGET (witem2
), pos
);
2453 g_object_unref (G_OBJECT (witem2
));
2455 g_list_free (*list
);
2456 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2457 while (nr
-- > 0) iter
= g_list_next (iter
);
2458 if (iter
) iter
= g_list_next (iter
);
2464 /* Update the rest of the menu bar. */
2465 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2466 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2469 /* Update the menu item W so it corresponds to VAL.
2470 SELECT_CB is the callback to use when a menu item is selected.
2471 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2472 CL_DATA is the data to set in the widget for menu invocation. */
2475 xg_update_menu_item (widget_value
*val
,
2477 GCallback select_cb
,
2478 GCallback highlight_cb
,
2479 xg_menu_cb_data
*cl_data
)
2486 const char *old_label
= 0;
2487 const char *old_key
= 0;
2488 xg_menu_item_cb_data
*cb_data
;
2490 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2491 utf8_label
= get_utf8_string (val
->name
);
2492 utf8_key
= get_utf8_string (val
->key
);
2494 /* See if W is a menu item with a key. See make_menu_item above. */
2495 if (GTK_IS_HBOX (wchild
))
2497 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2499 wlbl
= GTK_LABEL (list
->data
);
2500 wkey
= GTK_LABEL (list
->next
->data
);
2505 /* Remove the key and keep just the label. */
2506 g_object_ref (G_OBJECT (wlbl
));
2507 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2508 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2509 g_object_unref (G_OBJECT (wlbl
));
2514 else /* Just a label. */
2516 wlbl
= GTK_LABEL (wchild
);
2518 /* Check if there is now a key. */
2521 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2522 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2524 wlbl
= GTK_LABEL (list
->data
);
2525 wkey
= GTK_LABEL (list
->next
->data
);
2528 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2529 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2534 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2535 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2537 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2538 gtk_label_set_text (wkey
, utf8_key
);
2540 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2541 gtk_label_set_text (wlbl
, utf8_label
);
2543 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2544 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2546 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2547 gtk_widget_set_sensitive (w
, FALSE
);
2548 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2549 gtk_widget_set_sensitive (w
, TRUE
);
2551 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2555 cb_data
->call_data
= val
->call_data
;
2556 cb_data
->help
= val
->help
;
2557 cb_data
->cl_data
= cl_data
;
2559 /* We assume the callback functions don't change. */
2560 if (val
->call_data
&& ! val
->contents
)
2562 /* This item shall have a select callback. */
2563 if (! cb_data
->select_id
)
2565 = g_signal_connect (G_OBJECT (w
), "activate",
2566 select_cb
, cb_data
);
2568 else if (cb_data
->select_id
)
2570 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2571 cb_data
->select_id
= 0;
2576 /* Update the toggle menu item W so it corresponds to VAL. */
2579 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
2581 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2584 /* Update the radio menu item W so it corresponds to VAL. */
2587 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
2589 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2592 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2593 SUBMENU may be NULL, in that case a new menu is created.
2594 F is the frame the menu bar belongs to.
2595 VAL describes the contents of the menu bar.
2596 SELECT_CB is the callback to use when a menu item is selected.
2597 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2598 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2599 CL_DATA is the call back data to use for any newly created items.
2601 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2605 xg_update_submenu (GtkWidget
*submenu
,
2608 GCallback select_cb
,
2609 GCallback deactivate_cb
,
2610 GCallback highlight_cb
,
2611 xg_menu_cb_data
*cl_data
)
2613 GtkWidget
*newsub
= submenu
;
2617 int has_tearoff_p
= 0;
2618 GList
*first_radio
= 0;
2621 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2623 for (cur
= val
, iter
= list
;
2625 iter
= g_list_next (iter
), cur
= cur
->next
)
2627 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2629 /* Skip tearoff items, they have no counterpart in val. */
2630 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2633 iter
= g_list_next (iter
);
2634 if (iter
) w
= GTK_WIDGET (iter
->data
);
2638 /* Remember first radio button in a group. If we get a mismatch in
2639 a radio group we must rebuild the whole group so that the connections
2640 in GTK becomes correct. */
2641 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2643 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2644 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2647 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2649 if (! xg_separator_p (cur
->name
))
2652 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2654 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2656 xg_update_toggle_item (cur
, w
);
2657 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2659 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2661 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2663 xg_update_radio_item (cur
, w
);
2664 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2666 else if (GTK_IS_MENU_ITEM (w
))
2668 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2671 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2672 xg_separator_p (cur
->name
))
2675 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2677 sub
= gtk_menu_item_get_submenu (witem
);
2678 if (sub
&& ! cur
->contents
)
2680 /* Not a submenu anymore. */
2681 g_object_ref (G_OBJECT (sub
));
2682 remove_submenu (witem
);
2683 gtk_widget_destroy (sub
);
2685 else if (cur
->contents
)
2689 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2690 select_cb
, deactivate_cb
,
2691 highlight_cb
, cl_data
);
2693 /* If this item just became a submenu, we must set it. */
2695 gtk_menu_item_set_submenu (witem
, nsub
);
2700 /* Structural difference. Remove everything from here and down
2706 /* Remove widgets from first structual change. */
2709 /* If we are adding new menu items below, we must remove from
2710 first radio button so that radio groups become correct. */
2711 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2712 else xg_destroy_widgets (iter
);
2717 /* More items added. Create them. */
2718 newsub
= create_menus (cur
,
2731 if (list
) g_list_free (list
);
2736 /* Update the MENUBAR.
2737 F is the frame the menu bar belongs to.
2738 VAL describes the contents of the menu bar.
2739 If DEEP_P is non-zero, rebuild all but the top level menu names in
2740 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2741 SELECT_CB is the callback to use when a menu item is selected.
2742 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2743 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2746 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2747 select_cb
, deactivate_cb
, highlight_cb
)
2752 GCallback select_cb
;
2753 GCallback deactivate_cb
;
2754 GCallback highlight_cb
;
2756 xg_menu_cb_data
*cl_data
;
2757 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2761 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2764 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2765 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2771 /* Update all sub menus.
2772 We must keep the submenus (GTK menu item widgets) since the
2773 X Window in the XEvent that activates the menu are those widgets. */
2775 /* Update cl_data, menu_item things in F may have changed. */
2776 update_cl_data (cl_data
, f
, highlight_cb
);
2778 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2783 GtkMenuItem
*witem
= 0;
2785 /* Find sub menu that corresponds to val and update it. */
2786 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2788 witem
= GTK_MENU_ITEM (iter
->data
);
2789 if (xg_item_label_same_p (witem
, cur
->name
))
2791 sub
= gtk_menu_item_get_submenu (witem
);
2796 newsub
= xg_update_submenu (sub
,
2803 /* sub may still be NULL. If we just updated non deep and added
2804 a new menu bar item, it has no sub menu yet. So we set the
2805 newly created sub menu under witem. */
2806 if (newsub
!= sub
&& witem
!= 0)
2808 xg_set_screen (newsub
, f
);
2809 gtk_menu_item_set_submenu (witem
, newsub
);
2815 gtk_widget_show_all (menubar
);
2818 /* Recompute all the widgets of frame F, when the menu bar has been
2819 changed. Value is non-zero if widgets were updated. */
2822 xg_update_frame_menubar (FRAME_PTR f
)
2824 struct x_output
*x
= f
->output_data
.x
;
2827 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
2830 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
2831 return 0; /* Already done this, happens for frames created invisible. */
2835 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2837 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2839 gtk_widget_show_all (x
->menubar_widget
);
2840 gtk_widget_size_request (x
->menubar_widget
, &req
);
2841 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2842 xg_height_changed (f
);
2848 /* Get rid of the menu bar of frame F, and free its storage.
2849 This is used when deleting a frame, and when turning off the menu bar. */
2852 free_frame_menubar (FRAME_PTR f
)
2854 struct x_output
*x
= f
->output_data
.x
;
2856 if (x
->menubar_widget
)
2860 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2861 /* The menubar and its children shall be deleted when removed from
2863 x
->menubar_widget
= 0;
2864 FRAME_MENUBAR_HEIGHT (f
) = 0;
2865 xg_height_changed (f
);
2872 /***********************************************************************
2873 Scroll bar functions
2874 ***********************************************************************/
2877 /* Setting scroll bar values invokes the callback. Use this variable
2878 to indicate that callback should do nothing. */
2880 int xg_ignore_gtk_scrollbar
;
2882 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
2883 may be larger than 32 bits. Keep a mapping from integer index to widget
2884 pointers to get around the 32 bit limitation. */
2888 GtkWidget
**widgets
;
2893 /* Grow this much every time we need to allocate more */
2895 #define ID_TO_WIDGET_INCR 32
2897 /* Store the widget pointer W in id_to_widget and return the integer index. */
2900 xg_store_widget_in_map (GtkWidget
*w
)
2904 if (id_to_widget
.max_size
== id_to_widget
.used
)
2906 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
2908 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
2909 sizeof (GtkWidget
*)*new_size
);
2911 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
2912 id_to_widget
.widgets
[i
] = 0;
2913 id_to_widget
.max_size
= new_size
;
2916 /* Just loop over the array and find a free place. After all,
2917 how many scroll bars are we creating? Should be a small number.
2918 The check above guarantees we will find a free place. */
2919 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
2921 if (! id_to_widget
.widgets
[i
])
2923 id_to_widget
.widgets
[i
] = w
;
2924 ++id_to_widget
.used
;
2930 /* Should never end up here */
2934 /* Remove pointer at IDX from id_to_widget.
2935 Called when scroll bar is destroyed. */
2938 xg_remove_widget_from_map (int idx
)
2940 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2942 id_to_widget
.widgets
[idx
] = 0;
2943 --id_to_widget
.used
;
2947 /* Get the widget pointer at IDX from id_to_widget. */
2950 xg_get_widget_from_map (int idx
)
2952 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2953 return id_to_widget
.widgets
[idx
];
2958 /* Return the scrollbar id for X Window WID on display DPY.
2959 Return -1 if WID not in id_to_widget. */
2962 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
2967 w
= xg_win_to_widget (dpy
, wid
);
2971 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
2972 if (id_to_widget
.widgets
[idx
] == w
)
2979 /* Callback invoked when scroll bar WIDGET is destroyed.
2980 DATA is the index into id_to_widget for WIDGET.
2981 We free pointer to last scroll bar values here and remove the index. */
2984 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
2986 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
2987 xg_remove_widget_from_map (id
);
2990 /* Create a scroll bar widget for frame F. Store the scroll bar
2992 SCROLL_CALLBACK is the callback to invoke when the value of the
2994 END_CALLBACK is the callback to invoke when scrolling ends.
2995 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
2996 to set resources for the widget. */
2999 xg_create_scroll_bar (FRAME_PTR f
,
3000 struct scroll_bar
*bar
,
3001 GCallback scroll_callback
,
3002 GCallback end_callback
,
3003 char *scroll_bar_name
)
3010 /* Page, step increment values are not so important here, they
3011 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3012 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3015 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3016 webox
= gtk_event_box_new ();
3017 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3018 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3019 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3021 scroll_id
= xg_store_widget_in_map (wscroll
);
3023 /* The EMACS_INT cast avoids a warning. */
3024 g_signal_connect (G_OBJECT (wscroll
),
3026 G_CALLBACK (xg_gtk_scroll_destroy
),
3027 (gpointer
) (EMACS_INT
) scroll_id
);
3028 g_signal_connect (G_OBJECT (wscroll
),
3032 g_signal_connect (G_OBJECT (wscroll
),
3033 "button-release-event",
3037 /* The scroll bar widget does not draw on a window of its own. Instead
3038 it draws on the parent window, in this case the edit widget. So
3039 whenever the edit widget is cleared, the scroll bar needs to redraw
3040 also, which causes flicker. Put an event box between the edit widget
3041 and the scroll bar, so the scroll bar instead draws itself on the
3042 event box window. */
3043 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3044 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3047 /* Set the cursor to an arrow. */
3048 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3050 bar
->x_window
= scroll_id
;
3053 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3056 xg_remove_scroll_bar (FRAME_PTR f
, int scrollbar_id
)
3058 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3061 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3062 gtk_widget_destroy (w
);
3063 gtk_widget_destroy (wparent
);
3064 SET_FRAME_GARBAGED (f
);
3068 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3070 TOP/LEFT are the new pixel positions where the bar shall appear.
3071 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3074 xg_update_scrollbar_pos (FRAME_PTR f
,
3082 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3086 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3087 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3090 /* Clear out old position. */
3091 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3092 if (gtk_widget_get_parent (wparent
) == wfixed
)
3094 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3095 "x", &oldx
, "y", &oldy
, NULL
);
3096 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3099 /* Move and resize to new values. */
3100 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3101 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3104 /* No room. Hide scroll bar as some themes output a warning if
3105 the height is less than the min size. */
3106 gtk_widget_hide (wparent
);
3107 gtk_widget_hide (wscroll
);
3111 gtk_widget_show_all (wparent
);
3112 gtk_widget_set_size_request (wscroll
, width
, height
);
3114 gtk_widget_queue_draw (wfixed
);
3115 gdk_window_process_all_updates ();
3116 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3118 /* Clear under old scroll bar position. This must be done after
3119 the gtk_widget_queue_draw and gdk_window_process_all_updates
3121 x_clear_area (FRAME_X_DISPLAY (f
),
3123 oldx
, oldy
, oldw
, oldh
, 0);
3126 /* GTK does not redraw until the main loop is entered again, but
3127 if there are no X events pending we will not enter it. So we sync
3128 here to get some events. */
3131 SET_FRAME_GARBAGED (f
);
3132 cancel_mouse_face (f
);
3136 /* Set the thumb size and position of scroll bar BAR. We are currently
3137 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3140 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3145 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3147 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3149 if (wscroll
&& NILP (bar
->dragging
))
3158 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3160 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3161 rather than the real portion value. This makes the thumb less likely
3162 to resize and that looks better. */
3163 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3164 /* When the thumb is at the bottom, position == whole.
3165 So we need to increase `whole' to make space for the thumb. */
3172 top
= (gdouble
) position
/ whole
;
3173 shown
= (gdouble
) portion
/ whole
;
3176 size
= shown
* XG_SB_RANGE
;
3177 size
= min (size
, XG_SB_RANGE
);
3178 size
= max (size
, 1);
3180 value
= top
* XG_SB_RANGE
;
3181 value
= min (value
, XG_SB_MAX
- size
);
3182 value
= max (value
, XG_SB_MIN
);
3184 /* Assume all lines are of equal size. */
3185 new_step
= size
/ max (1, FRAME_LINES (f
));
3187 if ((int) gtk_adjustment_get_page_size (adj
) != size
3188 || (int) gtk_adjustment_get_step_increment (adj
) != new_step
)
3190 gtk_adjustment_set_page_size (adj
, size
);
3191 gtk_adjustment_set_step_increment (adj
, new_step
);
3192 /* Assume a page increment is about 95% of the page size */
3193 gtk_adjustment_set_page_increment (adj
,(int) (0.95*size
));
3197 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3201 /* gtk_range_set_value invokes the callback. Set
3202 ignore_gtk_scrollbar to make the callback do nothing */
3203 xg_ignore_gtk_scrollbar
= 1;
3205 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3206 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3208 gtk_adjustment_changed (adj
);
3210 xg_ignore_gtk_scrollbar
= 0;
3217 /* Return non-zero if EVENT is for a scroll bar in frame F.
3218 When the same X window is used for several Gtk+ widgets, we cannot
3219 say for sure based on the X window alone if an event is for the
3220 frame. This function does additional checks.
3222 Return non-zero if the event is for a scroll bar, zero otherwise. */
3225 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3229 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3231 /* Check if press occurred outside the edit widget. */
3232 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3233 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3234 != gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3237 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3238 || event
->type
== MotionNotify
))
3240 /* If we are releasing or moving the scroll bar, it has the grab. */
3241 GtkWidget
*w
= gtk_grab_get_current ();
3242 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3250 /***********************************************************************
3252 ***********************************************************************/
3253 /* The key for the data we put in the GtkImage widgets. The data is
3254 the image used by Emacs. We use this to see if we need to update
3255 the GtkImage with a new image. */
3256 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3258 /* The key for storing the latest modifiers so the activate callback can
3260 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3262 /* The key for storing the button widget in its proxy menu item. */
3263 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3265 /* The key for the data we put in the GtkImage widgets. The data is
3266 the stock name used by Emacs. We use this to see if we need to update
3267 the GtkImage with a new image. */
3268 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3270 /* As above, but this is used for named theme widgets, as opposed to
3272 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3274 /* Callback function invoked when a tool bar item is pressed.
3275 W is the button widget in the tool bar that got pressed,
3276 CLIENT_DATA is an integer that is the index of the button in the
3277 tool bar. 0 is the first button. */
3280 xg_tool_bar_button_cb (GtkWidget
*widget
,
3281 GdkEventButton
*event
,
3284 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3285 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3286 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3291 /* Callback function invoked when a tool bar item is pressed.
3292 W is the button widget in the tool bar that got pressed,
3293 CLIENT_DATA is an integer that is the index of the button in the
3294 tool bar. 0 is the first button. */
3297 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3299 /* The EMACS_INT cast avoids a warning. */
3300 int idx
= (int) (EMACS_INT
) client_data
;
3301 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3302 XG_TOOL_BAR_LAST_MODIFIER
);
3304 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3305 Lisp_Object key
, frame
;
3306 struct input_event event
;
3309 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3312 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3314 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3315 XSETFRAME (frame
, f
);
3317 /* We generate two events here. The first one is to set the prefix
3318 to `(tool_bar)', see keyboard.c. */
3319 event
.kind
= TOOL_BAR_EVENT
;
3320 event
.frame_or_window
= frame
;
3322 kbd_buffer_store_event (&event
);
3324 event
.kind
= TOOL_BAR_EVENT
;
3325 event
.frame_or_window
= frame
;
3327 /* Convert between the modifier bits GDK uses and the modifier bits
3328 Emacs uses. This assumes GDK and X masks are the same, which they are when
3330 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3331 kbd_buffer_store_event (&event
);
3333 /* Return focus to the frame after we have clicked on a detached
3335 Fx_focus_frame (frame
);
3338 /* Callback function invoked when a tool bar item is pressed in a detached
3339 tool bar or the overflow drop down menu.
3340 We just call xg_tool_bar_callback.
3341 W is the menu item widget that got pressed,
3342 CLIENT_DATA is an integer that is the index of the button in the
3343 tool bar. 0 is the first button. */
3346 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3348 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3349 XG_TOOL_BAR_PROXY_BUTTON
));
3350 xg_tool_bar_callback (wbutton
, client_data
);
3355 xg_tool_bar_help_callback (GtkWidget
*w
,
3356 GdkEventCrossing
*event
,
3357 gpointer client_data
);
3359 /* This callback is called when a help is to be shown for an item in
3360 the detached tool bar when the detached tool bar it is not expanded. */
3363 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3364 GdkEventCrossing
*event
,
3365 gpointer client_data
)
3367 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3368 XG_TOOL_BAR_PROXY_BUTTON
));
3370 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3374 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3376 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3377 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3378 GtkWidget
*c2
= (GtkWidget
*) clist
->next
->data
;
3379 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3380 g_list_free (clist
);
3381 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3385 /* This callback is called when a tool item should create a proxy item,
3386 such as for the overflow menu. Also called when the tool bar is detached.
3387 If we don't create a proxy menu item, the detached tool bar will be
3391 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3393 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (toolitem
));
3394 GtkButton
*wbutton
= GTK_BUTTON (gtk_bin_get_child (GTK_BIN (weventbox
)));
3395 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
3397 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3398 GtkImage
*wimage
= GTK_IMAGE (c1
);
3399 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3400 (gtk_label_get_text (wlbl
));
3401 GtkWidget
*wmenuimage
;
3404 if (gtk_button_get_use_stock (wbutton
))
3405 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3406 GTK_ICON_SIZE_MENU
);
3409 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3410 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3412 if (store_type
== GTK_IMAGE_STOCK
)
3415 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3416 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3418 else if (store_type
== GTK_IMAGE_ICON_SET
)
3420 GtkIconSet
*icon_set
;
3421 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3422 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3423 GTK_ICON_SIZE_MENU
);
3425 else if (store_type
== GTK_IMAGE_PIXBUF
)
3430 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3433 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3435 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3436 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3437 GDK_INTERP_BILINEAR
);
3439 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3443 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3447 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3449 const gchar
*icon_name
;
3450 GtkIconSize icon_size
;
3452 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3453 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3454 GTK_ICON_SIZE_MENU
);
3458 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3463 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3465 g_signal_connect (G_OBJECT (wmenuitem
),
3467 G_CALLBACK (xg_tool_bar_proxy_callback
),
3471 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3472 (gpointer
) wbutton
);
3473 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3474 gtk_widget_set_sensitive (wmenuitem
,
3475 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
3477 /* Use enter/leave notify to show help. We use the events
3478 rather than the GtkButton specific signals "enter" and
3479 "leave", so we can have only one callback. The event
3480 will tell us what kind of event it is. */
3481 g_signal_connect (G_OBJECT (wmenuitem
),
3482 "enter-notify-event",
3483 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3485 g_signal_connect (G_OBJECT (wmenuitem
),
3486 "leave-notify-event",
3487 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3493 /* This callback is called when a tool bar is detached. We must set
3494 the height of the tool bar to zero when this happens so frame sizes
3495 are correctly calculated.
3496 WBOX is the handle box widget that enables detach/attach of the tool bar.
3497 W is the tool bar widget.
3498 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3501 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
3503 gpointer client_data
)
3505 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3506 extern int x_gtk_whole_detached_tool_bar
;
3508 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3513 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3515 /* When detaching a tool bar, not everything dissapear. There are
3516 a few pixels left that are used to drop the tool bar back into
3518 FRAME_TOOLBAR_HEIGHT (f
) = 4;
3519 xg_height_changed (f
);
3523 /* This callback is called when a tool bar is reattached. We must set
3524 the height of the tool bar when this happens so frame sizes
3525 are correctly calculated.
3526 WBOX is the handle box widget that enables detach/attach of the tool bar.
3527 W is the tool bar widget.
3528 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3531 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
3533 gpointer client_data
)
3535 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3536 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3542 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3544 gtk_widget_size_request (w
, &req
);
3545 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3546 xg_height_changed (f
);
3550 /* This callback is called when the mouse enters or leaves a tool bar item.
3551 It is used for displaying and hiding the help text.
3552 W is the tool bar item, a button.
3553 EVENT is either an enter event or leave event.
3554 CLIENT_DATA is an integer that is the index of the button in the
3555 tool bar. 0 is the first button.
3557 Returns FALSE to tell GTK to keep processing this event. */
3560 xg_tool_bar_help_callback (GtkWidget
*w
,
3561 GdkEventCrossing
*event
,
3562 gpointer client_data
)
3564 /* The EMACS_INT cast avoids a warning. */
3565 int idx
= (int) (EMACS_INT
) client_data
;
3566 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3567 Lisp_Object help
, frame
;
3569 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3572 if (event
->type
== GDK_ENTER_NOTIFY
)
3574 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3575 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3578 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3583 XSETFRAME (frame
, f
);
3584 kbd_buffer_store_help_event (frame
, help
);
3590 /* This callback is called when a tool bar item shall be redrawn.
3591 It modifies the expose event so that the GtkImage widget redraws the
3592 whole image. This to overcome a bug that makes GtkImage draw the image
3593 in the wrong place when it tries to redraw just a part of the image.
3594 W is the GtkImage to be redrawn.
3595 EVENT is the expose event for W.
3596 CLIENT_DATA is unused.
3598 Returns FALSE to tell GTK to keep processing this event. */
3601 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
3602 GdkEventExpose
*event
,
3603 gpointer client_data
)
3607 gdk_drawable_get_size (event
->window
, &width
, &height
);
3609 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3610 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3612 event
->area
.x
= max (0, event
->area
.x
);
3613 event
->area
.y
= max (0, event
->area
.y
);
3615 event
->area
.width
= max (width
, event
->area
.width
);
3616 event
->area
.height
= max (height
, event
->area
.height
);
3621 /* Attach a tool bar to frame F. */
3624 xg_pack_tool_bar (FRAME_PTR f
)
3626 struct x_output
*x
= f
->output_data
.x
;
3627 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3629 x
->handlebox_widget
= gtk_handle_box_new ();
3630 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3631 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3632 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3633 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3635 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3638 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3641 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3644 gtk_widget_show (x
->toolbar_widget
);
3645 gtk_widget_show (x
->handlebox_widget
);
3648 /* Create a tool bar for frame F. */
3649 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
3650 #define toolbar_set_orientation(w, o) \
3651 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
3653 #define toolbar_set_orientation(w, o) \
3654 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
3658 xg_create_tool_bar (FRAME_PTR f
)
3660 struct x_output
*x
= f
->output_data
.x
;
3662 x
->toolbar_widget
= gtk_toolbar_new ();
3663 x
->toolbar_detached
= 0;
3665 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3667 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3668 toolbar_set_orientation (x
->toolbar_widget
,
3669 GTK_ORIENTATION_HORIZONTAL
);
3673 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3675 /* Find the right-to-left image named by RTL in the tool bar images for F.
3676 Returns IMAGE if RTL is not found. */
3679 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
3682 Lisp_Object file
, rtl_name
;
3683 struct gcpro gcpro1
, gcpro2
;
3684 GCPRO2 (file
, rtl_name
);
3686 rtl_name
= Ffile_name_nondirectory (rtl
);
3688 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3690 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3691 if (!NILP (file
= file_for_image (rtl_image
)))
3693 file
= call1 (intern ("file-name-sans-extension"),
3694 Ffile_name_nondirectory (file
));
3695 if (EQ (Fequal (file
, rtl_name
), Qt
))
3706 static GtkToolItem
*
3707 xg_make_tool_item (FRAME_PTR f
,
3709 GtkWidget
**wbutton
,
3713 GtkToolItem
*ti
= gtk_tool_item_new ();
3714 GtkWidget
*vb
= EQ (Vtool_bar_style
, Qboth_horiz
)
3715 ? gtk_hbox_new (FALSE
, 0) : gtk_vbox_new (FALSE
, 0);
3716 GtkWidget
*wb
= gtk_button_new ();
3717 GtkWidget
*weventbox
= gtk_event_box_new ();
3720 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
3722 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
3723 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
3724 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
3725 gtk_container_add (GTK_CONTAINER (wb
), vb
);
3726 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
3727 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
3731 /* The EMACS_INT cast avoids a warning. */
3732 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
3733 G_CALLBACK (xg_tool_bar_menu_proxy
),
3734 (gpointer
) (EMACS_INT
) i
);
3736 g_signal_connect (G_OBJECT (wb
), "clicked",
3737 G_CALLBACK (xg_tool_bar_callback
),
3738 (gpointer
) (EMACS_INT
) i
);
3740 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
3742 /* Catch expose events to overcome an annoying redraw bug, see
3743 comment for xg_tool_bar_item_expose_callback. */
3744 g_signal_connect (G_OBJECT (ti
),
3746 G_CALLBACK (xg_tool_bar_item_expose_callback
),
3749 gtk_tool_item_set_homogeneous (ti
, FALSE
);
3751 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
3752 no distinction based on modifiers in the activate callback,
3753 so we have to do it ourselves. */
3754 g_signal_connect (wb
, "button-release-event",
3755 G_CALLBACK (xg_tool_bar_button_cb
),
3758 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
3760 /* Use enter/leave notify to show help. We use the events
3761 rather than the GtkButton specific signals "enter" and
3762 "leave", so we can have only one callback. The event
3763 will tell us what kind of event it is. */
3764 /* The EMACS_INT cast avoids a warning. */
3765 g_signal_connect (G_OBJECT (weventbox
),
3766 "enter-notify-event",
3767 G_CALLBACK (xg_tool_bar_help_callback
),
3768 (gpointer
) (EMACS_INT
) i
);
3769 g_signal_connect (G_OBJECT (weventbox
),
3770 "leave-notify-event",
3771 G_CALLBACK (xg_tool_bar_help_callback
),
3772 (gpointer
) (EMACS_INT
) i
);
3775 if (wbutton
) *wbutton
= wb
;
3781 xg_show_toolbar_item (GtkToolItem
*ti
)
3783 Lisp_Object style
= Ftool_bar_get_system_style ();
3785 int show_label
= EQ (style
, Qboth
)
3786 || EQ (style
, Qboth_horiz
) || EQ (style
, Qtext
);
3787 int show_image
= ! EQ (style
, Qtext
);
3788 int horiz
= EQ (style
, Qboth_horiz
);
3790 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3791 GtkWidget
*wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3792 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
3794 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
3795 GtkWidget
*new_box
= NULL
;
3797 if (GTK_IS_VBOX (vb
) && horiz
)
3798 new_box
= gtk_hbox_new (FALSE
, 0);
3799 else if (GTK_IS_HBOX (vb
) && !horiz
&& show_label
&& show_image
)
3800 new_box
= gtk_vbox_new (FALSE
, 0);
3803 g_object_ref (G_OBJECT (wimage
));
3804 g_object_ref (G_OBJECT (wlbl
));
3805 gtk_container_remove (GTK_CONTAINER (vb
), wimage
);
3806 gtk_container_remove (GTK_CONTAINER (vb
), wlbl
);
3807 gtk_widget_destroy (GTK_WIDGET (vb
));
3808 gtk_box_pack_start (GTK_BOX (new_box
), wimage
, TRUE
, TRUE
, 0);
3809 gtk_box_pack_start (GTK_BOX (new_box
), wlbl
, TRUE
, TRUE
, 0);
3810 gtk_container_add (GTK_CONTAINER (wbutton
), new_box
);
3811 g_object_unref (G_OBJECT (wimage
));
3812 g_object_unref (G_OBJECT (wlbl
));
3816 if (show_label
) gtk_widget_show (wlbl
);
3817 else gtk_widget_hide (wlbl
);
3818 if (show_image
) gtk_widget_show (wimage
);
3819 else gtk_widget_hide (wimage
);
3820 gtk_widget_show (GTK_WIDGET (weventbox
));
3821 gtk_widget_show (GTK_WIDGET (vb
));
3822 gtk_widget_show (GTK_WIDGET (wbutton
));
3823 gtk_widget_show (GTK_WIDGET (ti
));
3827 /* Update the tool bar for frame F. Add new buttons and remove old. */
3829 extern Lisp_Object Qx_gtk_map_stock
;
3832 update_frame_tool_bar (FRAME_PTR f
)
3835 GtkRequisition old_req
, new_req
;
3836 struct x_output
*x
= f
->output_data
.x
;
3837 int hmargin
= 0, vmargin
= 0;
3838 GtkToolbar
*wtoolbar
;
3840 GtkTextDirection dir
;
3841 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
3843 if (! FRAME_GTK_WIDGET (f
))
3848 if (INTEGERP (Vtool_bar_button_margin
)
3849 && XINT (Vtool_bar_button_margin
) > 0)
3851 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3852 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3854 else if (CONSP (Vtool_bar_button_margin
))
3856 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3857 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3858 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3860 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3861 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3862 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3865 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3866 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3867 i.e. zero. This means that margins less than
3868 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3869 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3870 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3872 if (! x
->toolbar_widget
)
3873 xg_create_tool_bar (f
);
3875 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
3876 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &old_req
);
3877 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
3879 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3881 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3882 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3886 struct image
*img
= NULL
;
3888 Lisp_Object stock
= Qnil
;
3889 GtkStockItem stock_item
;
3890 char *stock_name
= NULL
;
3891 char *icon_name
= NULL
;
3893 GtkWidget
*wbutton
= NULL
;
3894 GtkWidget
*weventbox
;
3895 Lisp_Object specified_file
;
3896 char *label
= SSDATA (PROP (TOOL_BAR_ITEM_LABEL
));
3898 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), i
);
3902 weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3903 wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3907 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3909 /* Ignore invalid image specifications. */
3910 if (!valid_image_p (image
))
3912 if (wbutton
) gtk_widget_hide (wbutton
);
3916 specified_file
= file_for_image (image
);
3917 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
3918 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
3920 if (STRINGP (stock
))
3922 stock_name
= SSDATA (stock
);
3923 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
3925 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
3926 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
3928 icon_name
= stock_name
+ 2;
3932 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
3935 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3937 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
3938 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3946 if (stock_name
== NULL
&& icon_name
== NULL
)
3948 /* No stock image, or stock item not known. Try regular image. */
3950 /* If image is a vector, choose the image according to the
3952 if (dir
== GTK_TEXT_DIR_RTL
3953 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
3956 image
= find_rtl_image (f
, image
, rtl
);
3959 if (VECTORP (image
))
3963 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3964 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3967 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3968 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3970 xassert (ASIZE (image
) >= idx
);
3971 image
= AREF (image
, idx
);
3976 img_id
= lookup_image (f
, image
);
3977 img
= IMAGE_FROM_ID (f
, img_id
);
3978 prepare_image_for_display (f
, img
);
3980 if (img
->load_failed_p
|| img
->pixmap
== None
)
3983 gtk_widget_hide_all (GTK_WIDGET (ti
));
3986 /* Insert an empty (non-image) button */
3987 ti
= xg_make_tool_item (f
, NULL
, NULL
, "", i
);
3988 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, -1);
3999 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4000 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4001 (gpointer
) xstrdup (stock_name
),
4002 (GDestroyNotify
) xfree
);
4006 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4007 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4008 (gpointer
) xstrdup (icon_name
),
4009 (GDestroyNotify
) xfree
);
4013 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4014 /* Save the image so we can see if an update is needed when
4015 this function is called again. */
4016 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4017 (gpointer
)img
->pixmap
);
4020 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4021 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
);
4022 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, -1);
4023 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4027 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
4029 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4031 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
4032 XG_TOOL_BAR_IMAGE_DATA
);
4033 gpointer old_stock_name
= g_object_get_data (G_OBJECT (wimage
),
4034 XG_TOOL_BAR_STOCK_NAME
);
4035 gpointer old_icon_name
= g_object_get_data (G_OBJECT (wimage
),
4036 XG_TOOL_BAR_ICON_NAME
);
4037 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4039 (! old_stock_name
|| strcmp (old_stock_name
, stock_name
) != 0))
4041 gtk_image_set_from_stock (GTK_IMAGE (wimage
),
4042 stock_name
, icon_size
);
4043 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4044 (gpointer
) xstrdup (stock_name
),
4045 (GDestroyNotify
) xfree
);
4046 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4048 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4051 else if (icon_name
&&
4052 (! old_icon_name
|| strcmp (old_icon_name
, icon_name
) != 0))
4054 gtk_image_set_from_icon_name (GTK_IMAGE (wimage
),
4055 icon_name
, icon_size
);
4056 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4057 (gpointer
) xstrdup (icon_name
),
4058 (GDestroyNotify
) xfree
);
4059 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4061 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4064 else if (img
&& old_img
!= img
->pixmap
)
4066 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
,
4067 GTK_IMAGE (wimage
));
4068 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4069 (gpointer
)img
->pixmap
);
4071 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4073 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4077 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
4079 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4081 xg_show_toolbar_item (ti
);
4086 /* Remove buttons not longer needed. We just hide them so they
4087 can be reused later on. */
4090 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), i
++);
4091 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
4092 } while (ti
!= NULL
);
4095 if (pack_tool_bar
&& f
->n_tool_bar_items
!= 0)
4096 xg_pack_tool_bar (f
);
4099 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &new_req
);
4100 if (old_req
.height
!= new_req
.height
4101 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
4103 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
4104 xg_height_changed (f
);
4109 /* Deallocate all resources for the tool bar on frame F.
4110 Remove the tool bar. */
4113 free_frame_tool_bar (FRAME_PTR f
)
4115 struct x_output
*x
= f
->output_data
.x
;
4117 if (x
->toolbar_widget
)
4119 int is_packed
= x
->handlebox_widget
!= 0;
4121 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4122 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4124 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4125 x
->handlebox_widget
);
4127 gtk_widget_destroy (x
->toolbar_widget
);
4129 x
->toolbar_widget
= 0;
4130 x
->handlebox_widget
= 0;
4131 FRAME_TOOLBAR_HEIGHT (f
) = 0;
4132 xg_height_changed (f
);
4140 /***********************************************************************
4142 ***********************************************************************/
4144 xg_initialize (void)
4146 GtkBindingSet
*binding_set
;
4149 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4150 we keep it permanently linked in. */
4155 xg_ignore_gtk_scrollbar
= 0;
4156 xg_detached_menus
= 0;
4157 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4158 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4160 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4161 id_to_widget
.widgets
= 0;
4163 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4164 bindings. It doesn't seem to be any way to remove properties,
4165 so we set it to VoidSymbol which in X means "no key". */
4166 gtk_settings_set_string_property (gtk_settings_get_default (),
4167 "gtk-menu-bar-accel",
4171 /* Make GTK text input widgets use Emacs style keybindings. This is
4173 gtk_settings_set_string_property (gtk_settings_get_default (),
4174 "gtk-key-theme-name",
4178 /* Make dialogs close on C-g. Since file dialog inherits from
4179 dialog, this works for them also. */
4180 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4181 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4184 /* Make menus close on C-g. */
4185 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4186 (GTK_TYPE_MENU_SHELL
));
4187 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4191 #endif /* USE_GTK */
4193 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
4194 (do not change this comment) */