1 /* Functions for creating and updating GTK widgets.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
29 #include "blockinput.h"
30 #include "syssignal.h"
33 #include "termhooks.h"
37 #include <gdk/gdkkeysyms.h>
38 #include "xsettings.h"
41 #include <X11/Xft/Xft.h>
44 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
45 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
47 /* Avoid "differ in sign" warnings */
48 #define SSDATA(x) ((char *) SDATA (x))
50 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
51 #define gtk_widget_set_has_window(w, b) \
52 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
54 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
55 #define gtk_dialog_get_action_area(w) ((w)->action_area)
56 #define gtk_dialog_get_content_area(w) ((w)->vbox)
58 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
59 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
61 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
62 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
63 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
64 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
65 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
67 #if GTK_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 11
68 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
70 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
74 /***********************************************************************
75 Display handling functions
76 ***********************************************************************/
78 /* Keep track of the default display, or NULL if there is none. Emacs
79 may close all its displays. */
81 static GdkDisplay
*gdpy_def
;
83 /* When the GTK widget W is to be created on a display for F that
84 is not the default display, set the display for W.
85 W can be a GtkMenu or a GtkWindow widget. */
88 xg_set_screen (GtkWidget
*w
, FRAME_PTR f
)
90 if (FRAME_X_DISPLAY (f
) != GDK_DISPLAY ())
92 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
93 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
96 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
98 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
103 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
104 *DPY is set to NULL if the display can't be opened.
106 Returns non-zero if display could be opened, zero if display could not
107 be opened, and less than zero if the GTK version doesn't support
111 xg_display_open (char *display_name
, Display
**dpy
)
115 gdpy
= gdk_display_open (display_name
);
116 if (!gdpy_def
&& gdpy
)
119 gdk_display_manager_set_default_display (gdk_display_manager_get (),
123 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
127 /* Close display DPY. */
130 xg_display_close (Display
*dpy
)
132 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
134 /* If this is the default display, try to change it before closing.
135 If there is no other display to use, gdpy_def is set to NULL, and
136 the next call to xg_display_open resets the default display. */
137 if (gdk_display_get_default () == gdpy
)
139 struct x_display_info
*dpyinfo
;
140 GdkDisplay
*gdpy_new
= NULL
;
142 /* Find another display. */
143 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
144 if (dpyinfo
->display
!= dpy
)
146 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
147 gdk_display_manager_set_default_display (gdk_display_manager_get (),
154 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
155 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
156 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
157 can continue running, but there will be memory leaks. */
158 g_object_run_dispose (G_OBJECT (gdpy
));
160 /* This seems to be fixed in GTK 2.10. */
161 gdk_display_close (gdpy
);
166 /***********************************************************************
168 ***********************************************************************/
169 /* The next two variables and functions are taken from lwlib. */
170 static widget_value
*widget_value_free_list
;
171 static int malloc_cpt
;
173 /* Allocate a widget_value structure, either by taking one from the
174 widget_value_free_list or by malloc:ing a new one.
176 Return a pointer to the allocated structure. */
179 malloc_widget_value (void)
182 if (widget_value_free_list
)
184 wv
= widget_value_free_list
;
185 widget_value_free_list
= wv
->free_list
;
190 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
193 memset (wv
, 0, sizeof (widget_value
));
197 /* This is analogous to free. It frees only what was allocated
198 by malloc_widget_value, and no substructures. */
201 free_widget_value (widget_value
*wv
)
208 /* When the number of already allocated cells is too big,
215 wv
->free_list
= widget_value_free_list
;
216 widget_value_free_list
= wv
;
221 /* Create and return the cursor to be used for popup menus and
222 scroll bars on display DPY. */
225 xg_create_default_cursor (Display
*dpy
)
227 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
228 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
231 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
234 xg_get_pixbuf_from_pix_and_mask (GdkPixmap
*gpix
, GdkPixmap
*gmask
, GdkColormap
*cmap
)
237 GdkPixbuf
*icon_buf
, *tmp_buf
;
239 gdk_drawable_get_size (gpix
, &width
, &height
);
240 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
241 0, 0, 0, 0, width
, height
);
242 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
243 g_object_unref (G_OBJECT (tmp_buf
));
247 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
252 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
253 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
254 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
255 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
258 for (y
= 0; y
< height
; ++y
)
260 guchar
*iconptr
, *maskptr
;
263 iconptr
= pixels
+ y
* rowstride
;
264 maskptr
= mask_pixels
+ y
* mask_rowstride
;
266 for (x
= 0; x
< width
; ++x
)
268 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
269 just R is sufficient. */
271 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
273 iconptr
+= rowstride
/width
;
274 maskptr
+= mask_rowstride
/width
;
278 g_object_unref (G_OBJECT (mask_buf
));
285 file_for_image (Lisp_Object image
)
287 Lisp_Object specified_file
= Qnil
;
289 extern Lisp_Object QCfile
;
291 for (tail
= XCDR (image
);
292 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
293 tail
= XCDR (XCDR (tail
)))
294 if (EQ (XCAR (tail
), QCfile
))
295 specified_file
= XCAR (XCDR (tail
));
297 return specified_file
;
300 /* For the image defined in IMG, make and return a GtkImage. For displays with
301 8 planes or less we must make a GdkPixbuf and apply the mask manually.
302 Otherwise the highlightning and dimming the tool bar code in GTK does
303 will look bad. For display with more than 8 planes we just use the
304 pixmap and mask directly. For monochrome displays, GTK doesn't seem
305 able to use external pixmaps, it looks bad whatever we do.
306 The image is defined on the display where frame F is.
307 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
308 If OLD_WIDGET is NULL, a new widget is constructed and returned.
309 If OLD_WIDGET is not NULL, that widget is modified. */
312 xg_get_image_for_pixmap (FRAME_PTR f
, struct image
*img
, GtkWidget
*widget
, GtkImage
*old_widget
)
320 /* If we have a file, let GTK do all the image handling.
321 This seems to be the only way to make insensitive and activated icons
322 look good in all cases. */
323 Lisp_Object specified_file
= file_for_image (img
->spec
);
326 /* We already loaded the image once before calling this
327 function, so this only fails if the image file has been removed.
328 In that case, use the pixmap already loaded. */
330 if (STRINGP (specified_file
)
331 && STRINGP (file
= x_find_image_file (specified_file
)))
334 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
336 gtk_image_set_from_file (old_widget
, SSDATA (file
));
338 return GTK_WIDGET (old_widget
);
341 /* No file, do the image handling ourselves. This will look very bad
342 on a monochrome display, and sometimes bad on all displays with
345 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
346 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
347 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
349 /* This is a workaround to make icons look good on pseudo color
350 displays. Apparently GTK expects the images to have an alpha
351 channel. If they don't, insensitive and activated icons will
352 look bad. This workaround does not work on monochrome displays,
353 and is strictly not needed on true color/static color displays (i.e.
354 16 bits and higher). But we do it anyway so we get a pixbuf that is
355 not associated with the img->pixmap. The img->pixmap may be removed
356 by clearing the image cache and then the tool bar redraw fails, since
357 Gtk+ assumes the pixmap is always there. */
358 cmap
= gtk_widget_get_colormap (widget
);
359 icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
362 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
364 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
366 g_object_unref (G_OBJECT (icon_buf
));
368 g_object_unref (G_OBJECT (gpix
));
369 if (gmask
) g_object_unref (G_OBJECT (gmask
));
371 return GTK_WIDGET (old_widget
);
375 /* Set CURSOR on W and all widgets W contain. We must do like this
376 for scroll bars and menu because they create widgets internally,
377 and it is those widgets that are visible. */
380 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
382 GdkWindow
*window
= gtk_widget_get_window(w
);
383 GList
*children
= gdk_window_peek_children (window
);
385 gdk_window_set_cursor (window
, cursor
);
387 /* The scroll bar widget has more than one GDK window (had to look at
388 the source to figure this out), and there is no way to set cursor
389 on widgets in GTK. So we must set the cursor for all GDK windows.
392 for ( ; children
; children
= g_list_next (children
))
393 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
396 /* Insert NODE into linked LIST. */
399 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
401 xg_list_node
*list_start
= list
->next
;
403 if (list_start
) list_start
->prev
= node
;
404 node
->next
= list_start
;
409 /* Remove NODE from linked LIST. */
412 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
414 xg_list_node
*list_start
= list
->next
;
415 if (node
== list_start
)
417 list
->next
= node
->next
;
418 if (list
->next
) list
->next
->prev
= 0;
422 node
->prev
->next
= node
->next
;
423 if (node
->next
) node
->next
->prev
= node
->prev
;
427 /* Allocate and return a utf8 version of STR. If STR is already
428 utf8 or NULL, just return STR.
429 If not, a new string is allocated and the caller must free the result
433 get_utf8_string (char *str
)
435 char *utf8_str
= str
;
437 if (!str
) return NULL
;
439 /* If not UTF-8, try current locale. */
440 if (!g_utf8_validate (str
, -1, NULL
))
441 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
445 /* Probably some control characters in str. Escape them. */
449 unsigned char *p
= (unsigned char *)str
;
451 GError
*error
= NULL
;
453 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
454 &bytes_written
, &error
))
455 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
458 p
+= bytes_written
+1;
459 g_error_free (error
);
465 g_error_free (error
);
470 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
471 p
= (unsigned char *)str
;
473 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
474 &bytes_written
, &error
))
475 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
477 strncpy (up
, (char *)p
, bytes_written
);
478 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
479 up
[bytes_written
+4] = '\0';
480 up
+= bytes_written
+4;
481 p
+= bytes_written
+1;
482 g_error_free (error
);
488 strcat (utf8_str
, cp
);
493 g_error_free (error
);
502 /***********************************************************************
503 General functions for creating widgets, resizing, events, e.t.c.
504 ***********************************************************************/
506 /* Make a geometry string and pass that to GTK. It seems this is the
507 only way to get geometry position right if the user explicitly
508 asked for a position when starting Emacs.
509 F is the frame we shall set geometry for. */
512 xg_set_geometry (FRAME_PTR f
)
514 if (f
->size_hint_flags
& (USPosition
| PPosition
))
516 int left
= f
->left_pos
;
517 int xneg
= f
->size_hint_flags
& XNegative
;
518 int top
= f
->top_pos
;
519 int yneg
= f
->size_hint_flags
& YNegative
;
527 sprintf (geom_str
, "=%dx%d%c%d%c%d",
528 FRAME_PIXEL_WIDTH (f
),
529 FRAME_PIXEL_HEIGHT (f
),
530 (xneg
? '-' : '+'), left
,
531 (yneg
? '-' : '+'), top
);
533 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
535 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
539 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
540 and use a GtkFixed widget, this doesn't happen automatically. */
543 xg_clear_under_internal_border (FRAME_PTR f
)
545 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
547 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
548 gtk_widget_queue_draw (wfixed
);
549 gdk_window_process_all_updates ();
550 x_clear_area (FRAME_X_DISPLAY (f
),
553 FRAME_PIXEL_WIDTH (f
),
554 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
555 x_clear_area (FRAME_X_DISPLAY (f
),
558 FRAME_INTERNAL_BORDER_WIDTH (f
),
559 FRAME_PIXEL_HEIGHT (f
), 0);
560 x_clear_area (FRAME_X_DISPLAY (f
),
562 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
563 FRAME_PIXEL_WIDTH (f
),
564 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
565 x_clear_area (FRAME_X_DISPLAY (f
),
567 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
569 FRAME_INTERNAL_BORDER_WIDTH (f
),
570 FRAME_PIXEL_HEIGHT (f
), 0);
574 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
575 and a Gtk+ menu bar, we get resize events for the edit part of the
576 frame only. We let Gtk+ deal with the Gtk+ parts.
577 F is the frame to resize.
578 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
581 xg_frame_resized (FRAME_PTR f
, int pixelwidth
, int pixelheight
)
585 if (pixelwidth
== -1 && pixelheight
== -1)
587 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
588 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
590 &pixelwidth
, &pixelheight
, 0);
595 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
596 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
598 if (columns
!= FRAME_COLS (f
)
599 || rows
!= FRAME_LINES (f
)
600 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
601 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
603 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
604 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
606 xg_clear_under_internal_border (f
);
607 change_frame_size (f
, rows
, columns
, 0, 1, 0);
608 SET_FRAME_GARBAGED (f
);
609 cancel_mouse_face (f
);
613 /* Resize the outer window of frame F after chainging the height.
614 COLUMNS/ROWS is the size the edit area shall have after the resize. */
617 xg_frame_set_char_size (FRAME_PTR f
, int cols
, int rows
)
619 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
620 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
623 if (FRAME_PIXEL_HEIGHT (f
) == 0)
626 /* Take into account the size of the scroll bar. Always use the
627 number of columns occupied by the scroll bar here otherwise we
628 might end up with a frame width that is not a multiple of the
629 frame's character width which is bad for vertically split
631 f
->scroll_bar_actual_width
632 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
634 compute_fringe_widths (f
, 0);
636 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
637 after calculating that value. */
638 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
641 /* Do this before resize, as we don't know yet if we will be resized. */
642 xg_clear_under_internal_border (f
);
644 /* Must resize our top level widget. Font size may have changed,
645 but not rows/cols. */
646 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
647 pixelwidth
, pixelheight
);
648 x_wm_set_size_hint (f
, 0, 0);
650 SET_FRAME_GARBAGED (f
);
651 cancel_mouse_face (f
);
653 /* We can not call change_frame_size for a mapped frame,
654 we can not set pixel width/height either. The window manager may
655 override our resize request, XMonad does this all the time.
656 The best we can do is try to sync, so lisp code sees the updated
657 size as fast as possible.
658 For unmapped windows, we can set rows/cols. When
659 the frame is mapped again we will (hopefully) get the correct size. */
660 if (f
->async_visible
)
662 /* Must call this to flush out events */
663 (void)gtk_events_pending ();
665 x_wait_for_event (f
, ConfigureNotify
);
669 change_frame_size (f
, rows
, cols
, 0, 1, 0);
670 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
671 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
675 /* Handle height changes (i.e. add/remove menu/toolbar).
676 The policy is to keep the number of editable lines. */
679 xg_height_changed (FRAME_PTR f
)
681 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
682 FRAME_PIXEL_WIDTH (f
), FRAME_TOTAL_PIXEL_HEIGHT (f
));
683 f
->output_data
.x
->hint_flags
= 0;
684 x_wm_set_size_hint (f
, 0, 0);
687 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
688 Must be done like this, because GtkWidget:s can have "hidden"
689 X Window that aren't accessible.
691 Return 0 if no widget match WDESC. */
694 xg_win_to_widget (Display
*dpy
, Window wdesc
)
697 GtkWidget
*gwdesc
= 0;
701 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
706 event
.any
.window
= gdkwin
;
707 gwdesc
= gtk_get_event_widget (&event
);
714 /* Fill in the GdkColor C so that it represents PIXEL.
715 W is the widget that color will be used for. Used to find colormap. */
718 xg_pix_to_gcolor (GtkWidget
*w
, long unsigned int pixel
, GdkColor
*c
)
720 GdkColormap
*map
= gtk_widget_get_colormap (w
);
721 gdk_colormap_query_color (map
, pixel
, c
);
724 /* Create and set up the GTK widgets for frame F.
725 Return 0 if creation failed, non-zero otherwise. */
728 xg_create_frame_widgets (FRAME_PTR f
)
739 if (FRAME_X_EMBEDDED_P (f
))
740 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
742 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
744 xg_set_screen (wtop
, f
);
746 wvbox
= gtk_vbox_new (FALSE
, 0);
747 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
749 if (! wtop
|| ! wvbox
|| ! wfixed
)
751 if (wtop
) gtk_widget_destroy (wtop
);
752 if (wvbox
) gtk_widget_destroy (wvbox
);
753 if (wfixed
) gtk_widget_destroy (wfixed
);
759 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
760 gtk_widget_set_name (wtop
, EMACS_CLASS
);
761 gtk_widget_set_name (wvbox
, "pane");
762 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
764 /* If this frame has a title or name, set it in the title bar. */
765 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
766 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
768 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
770 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
771 FRAME_GTK_WIDGET (f
) = wfixed
;
772 f
->output_data
.x
->vbox_widget
= wvbox
;
774 gtk_widget_set_has_window (wfixed
, TRUE
);
776 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
777 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
779 if (FRAME_EXTERNAL_TOOL_BAR (f
))
780 update_frame_tool_bar (f
);
782 /* We don't want this widget double buffered, because we draw on it
783 with regular X drawing primitives, so from a GTK/GDK point of
784 view, the widget is totally blank. When an expose comes, this
785 will make the widget blank, and then Emacs redraws it. This flickers
786 a lot, so we turn off double buffering. */
787 gtk_widget_set_double_buffered (wfixed
, FALSE
);
789 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
790 SSDATA (Vx_resource_name
),
791 SSDATA (Vx_resource_class
));
793 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
794 GTK is to destroy the widget. We want Emacs to do that instead. */
795 g_signal_connect (G_OBJECT (wtop
), "delete-event",
796 G_CALLBACK (gtk_true
), 0);
798 /* Convert our geometry parameters into a geometry string
800 GTK will itself handle calculating the real position this way. */
803 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
805 gtk_widget_add_events (wfixed
,
806 GDK_POINTER_MOTION_MASK
808 | GDK_BUTTON_PRESS_MASK
809 | GDK_BUTTON_RELEASE_MASK
811 | GDK_ENTER_NOTIFY_MASK
812 | GDK_LEAVE_NOTIFY_MASK
813 | GDK_FOCUS_CHANGE_MASK
815 | GDK_VISIBILITY_NOTIFY_MASK
);
817 /* Must realize the windows so the X window gets created. It is used
818 by callers of this function. */
819 gtk_widget_realize (wfixed
);
820 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
822 /* Since GTK clears its window by filling with the background color,
823 we must keep X and GTK background in sync. */
824 xg_pix_to_gcolor (wfixed
, FRAME_BACKGROUND_PIXEL (f
), &bg
);
825 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
827 /* Also, do not let any background pixmap to be set, this looks very
828 bad as Emacs overwrites the background pixmap with its own idea
829 of background color. */
830 style
= gtk_widget_get_modifier_style (wfixed
);
832 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
833 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
834 gtk_widget_modify_style (wfixed
, style
);
836 /* GTK does not set any border, and they look bad with GTK. */
837 /* That they look bad is no excuse for imposing this here. --Stef
838 It should be done by providing the proper default in Fx_create_Frame.
840 f->internal_border_width = 0; */
847 /* Set the normal size hints for the window manager, for frame F.
848 FLAGS is the flags word to use--or 0 meaning preserve the flags
849 that the window now has.
850 If USER_POSITION is nonzero, we set the User Position
851 flag (this is useful when FLAGS is 0). */
854 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
856 /* Must use GTK routines here, otherwise GTK resets the size hints
857 to its own defaults. */
858 GdkGeometry size_hints
;
860 int base_width
, base_height
;
861 int min_rows
= 0, min_cols
= 0;
862 int win_gravity
= f
->win_gravity
;
864 /* Don't set size hints during initialization; that apparently leads
865 to a race condition. See the thread at
866 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
867 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
872 memset (&size_hints
, 0, sizeof (size_hints
));
873 f
->output_data
.x
->size_hints
= size_hints
;
874 f
->output_data
.x
->hint_flags
= hint_flags
;
877 flags
= f
->size_hint_flags
;
879 size_hints
= f
->output_data
.x
->size_hints
;
880 hint_flags
= f
->output_data
.x
->hint_flags
;
882 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
883 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
884 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
886 hint_flags
|= GDK_HINT_BASE_SIZE
;
887 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
888 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
889 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
891 check_frame_size (f
, &min_rows
, &min_cols
);
893 size_hints
.base_width
= base_width
;
894 size_hints
.base_height
= base_height
;
895 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
896 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
898 /* These currently have a one to one mapping with the X values, but I
899 don't think we should rely on that. */
900 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
901 size_hints
.win_gravity
= 0;
902 if (win_gravity
== NorthWestGravity
)
903 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
904 else if (win_gravity
== NorthGravity
)
905 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
906 else if (win_gravity
== NorthEastGravity
)
907 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
908 else if (win_gravity
== WestGravity
)
909 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
910 else if (win_gravity
== CenterGravity
)
911 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
912 else if (win_gravity
== EastGravity
)
913 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
914 else if (win_gravity
== SouthWestGravity
)
915 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
916 else if (win_gravity
== SouthGravity
)
917 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
918 else if (win_gravity
== SouthEastGravity
)
919 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
920 else if (win_gravity
== StaticGravity
)
921 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
925 hint_flags
&= ~GDK_HINT_POS
;
926 hint_flags
|= GDK_HINT_USER_POS
;
929 if (hint_flags
!= f
->output_data
.x
->hint_flags
930 || memcmp (&size_hints
,
931 &f
->output_data
.x
->size_hints
,
932 sizeof (size_hints
)) != 0)
935 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
936 NULL
, &size_hints
, hint_flags
);
937 f
->output_data
.x
->size_hints
= size_hints
;
938 f
->output_data
.x
->hint_flags
= hint_flags
;
943 /* Change background color of a frame.
944 Since GTK uses the background color to clear the window, we must
945 keep the GTK and X colors in sync.
946 F is the frame to change,
947 BG is the pixel value to change to. */
950 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
952 if (FRAME_GTK_WIDGET (f
))
957 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
958 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
964 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
965 functions so GTK does not overwrite the icon. */
968 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
970 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
971 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
972 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
973 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
975 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
980 /***********************************************************************
982 ***********************************************************************/
983 /* Return the dialog title to use for a dialog of type KEY.
984 This is the encoding used by lwlib. We use the same for GTK. */
987 get_dialog_title (char key
)
997 title
= "Information";
1016 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1017 the dialog, but return TRUE so the event does not propagate further
1018 in GTK. This prevents GTK from destroying the dialog widget automatically
1019 and we can always destrou the widget manually, regardles of how
1020 it was popped down (button press or WM_DELETE_WINDOW).
1021 W is the dialog widget.
1022 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1023 user_data is NULL (not used).
1025 Returns TRUE to end propagation of event. */
1028 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1030 gtk_widget_unmap (w
);
1034 /* Create a popup dialog window. See also xg_create_widget below.
1035 WV is a widget_value describing the dialog.
1036 SELECT_CB is the callback to use when a button has been pressed.
1037 DEACTIVATE_CB is the callback to use when the dialog pops down.
1039 Returns the GTK dialog widget. */
1042 create_dialog (widget_value
*wv
, GCallback select_cb
, GCallback deactivate_cb
)
1044 char *title
= get_dialog_title (wv
->name
[0]);
1045 int total_buttons
= wv
->name
[1] - '0';
1046 int right_buttons
= wv
->name
[4] - '0';
1049 int button_spacing
= 10;
1050 GtkWidget
*wdialog
= gtk_dialog_new ();
1051 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1052 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1055 GtkWidget
*whbox_up
;
1056 GtkWidget
*whbox_down
;
1058 /* If the number of buttons is greater than 4, make two rows of buttons
1059 instead. This looks better. */
1060 int make_two_rows
= total_buttons
> 4;
1062 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1063 left_buttons
= total_buttons
- right_buttons
;
1065 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1066 gtk_widget_set_name (wdialog
, "emacs-dialog");
1071 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1072 whbox_up
= gtk_hbox_new (FALSE
, 0);
1073 whbox_down
= gtk_hbox_new (FALSE
, 0);
1075 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1076 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1077 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1079 cur_box
= GTK_BOX (whbox_up
);
1082 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1083 G_CALLBACK (dialog_delete_callback
), 0);
1087 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1088 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1091 for (item
= wv
->contents
; item
; item
= item
->next
)
1093 char *utf8_label
= get_utf8_string (item
->value
);
1097 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1099 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1100 /* This is the text part of the dialog. */
1101 w
= gtk_label_new (utf8_label
);
1102 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1103 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1104 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1106 /* Try to make dialog look better. Must realize first so
1107 the widget can calculate the size it needs. */
1108 gtk_widget_realize (w
);
1109 gtk_widget_size_request (w
, &req
);
1110 gtk_box_set_spacing (wvbox
, req
.height
);
1111 if (item
->value
&& strlen (item
->value
) > 0)
1112 button_spacing
= 2*req
.width
/strlen (item
->value
);
1116 /* This is one button to add to the dialog. */
1117 w
= gtk_button_new_with_label (utf8_label
);
1118 if (! item
->enabled
)
1119 gtk_widget_set_sensitive (w
, FALSE
);
1121 g_signal_connect (G_OBJECT (w
), "clicked",
1122 select_cb
, item
->call_data
);
1124 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1125 if (++button_nr
== left_buttons
)
1128 cur_box
= GTK_BOX (whbox_down
);
1130 gtk_box_pack_start (cur_box
,
1137 if (utf8_label
&& utf8_label
!= item
->value
)
1138 g_free (utf8_label
);
1144 struct xg_dialog_data
1152 /* Function that is called when the file or font dialogs pop down.
1153 W is the dialog widget, RESPONSE is the response code.
1154 USER_DATA is what we passed in to g_signal_connect. */
1157 xg_dialog_response_cb (w
,
1164 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1165 dd
->response
= response
;
1166 g_main_loop_quit (dd
->loop
);
1170 /* Destroy the dialog. This makes it pop down. */
1173 pop_down_dialog (Lisp_Object arg
)
1175 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1176 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1179 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1180 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1182 g_main_loop_quit (dd
->loop
);
1183 g_main_loop_unref (dd
->loop
);
1190 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1191 We pass in DATA as gpointer* so we can use this as a callback. */
1194 xg_maybe_add_timer (gpointer data
)
1196 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1197 EMACS_TIME next_time
= timer_check (1);
1198 long secs
= EMACS_SECS (next_time
);
1199 long usecs
= EMACS_USECS (next_time
);
1203 if (secs
>= 0 && usecs
>= 0 && secs
< ((guint
)-1)/1000)
1205 dd
->timerid
= g_timeout_add (secs
* 1000 + usecs
/1000,
1213 /* Pops up a modal dialog W and waits for response.
1214 We don't use gtk_dialog_run because we want to process emacs timers.
1215 The dialog W is not destroyed when this function returns. */
1218 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1220 int count
= SPECPDL_INDEX ();
1221 struct xg_dialog_data dd
;
1223 xg_set_screen (w
, f
);
1224 gtk_window_set_transient_for (GTK_WINDOW (w
),
1225 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1226 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1227 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1229 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1230 dd
.response
= GTK_RESPONSE_CANCEL
;
1234 g_signal_connect (G_OBJECT (w
),
1236 G_CALLBACK (xg_dialog_response_cb
),
1238 /* Don't destroy the widget if closed by the window manager close button. */
1239 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1240 gtk_widget_show (w
);
1242 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1244 (void) xg_maybe_add_timer (&dd
);
1245 g_main_loop_run (dd
.loop
);
1248 unbind_to (count
, Qnil
);
1254 /***********************************************************************
1255 File dialog functions
1256 ***********************************************************************/
1257 /* Return non-zero if the old file selection dialog is being used.
1258 Return zero if not. */
1261 xg_uses_old_file_dialog (void)
1263 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1264 extern int x_gtk_use_old_file_dialog
;
1265 return x_gtk_use_old_file_dialog
;
1272 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1274 /* Return the selected file for file chooser dialog W.
1275 The returned string must be free:d. */
1278 xg_get_file_name_from_chooser (GtkWidget
*w
)
1280 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1283 /* Callback called when the "Show hidden files" toggle is pressed.
1284 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1287 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1289 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1291 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1292 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1296 /* Callback called when a property changes in a file chooser.
1297 GOBJECT is the file chooser dialog, ARG1 describes the property.
1298 USER_DATA is the toggle widget in the file chooser dialog.
1299 We use this to update the "Show hidden files" toggle when the user
1300 changes that property by right clicking in the file list. */
1303 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1305 extern int x_gtk_show_hidden_files
;
1307 if (strcmp (arg1
->name
, "show-hidden") == 0)
1309 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1310 gboolean visible
, toggle_on
;
1312 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1313 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1315 if (!!visible
!= !!toggle_on
)
1317 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1318 G_CALLBACK (xg_toggle_visibility_cb
),
1320 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1321 g_signal_handlers_unblock_by_func
1322 (G_OBJECT (wtoggle
),
1323 G_CALLBACK (xg_toggle_visibility_cb
),
1326 x_gtk_show_hidden_files
= visible
;
1330 /* Read a file name from the user using a file chooser dialog.
1331 F is the current frame.
1332 PROMPT is a prompt to show to the user. May not be NULL.
1333 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1334 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1335 file. *FUNC is set to a function that can be used to retrieve the
1336 selected file name from the returned widget.
1338 Returns the created widget. */
1341 xg_get_file_with_chooser (f
, prompt
, default_filename
,
1342 mustmatch_p
, only_dir_p
, func
)
1345 char *default_filename
;
1346 int mustmatch_p
, only_dir_p
;
1347 xg_get_file_func
*func
;
1351 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1352 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1353 GtkFileChooserAction action
= (mustmatch_p
?
1354 GTK_FILE_CHOOSER_ACTION_OPEN
:
1355 GTK_FILE_CHOOSER_ACTION_SAVE
);
1356 extern int x_gtk_show_hidden_files
;
1357 extern int x_gtk_file_dialog_help_text
;
1361 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1363 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1364 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1365 (mustmatch_p
|| only_dir_p
?
1366 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1369 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1371 wbox
= gtk_vbox_new (FALSE
, 0);
1372 gtk_widget_show (wbox
);
1373 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1375 if (x_gtk_show_hidden_files
)
1377 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1378 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1380 gtk_widget_show (wtoggle
);
1381 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1382 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1383 g_signal_connect (G_OBJECT (filewin
), "notify",
1384 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1386 if (x_gtk_file_dialog_help_text
)
1389 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1390 Show the C-l help text only for versions < 2.10. */
1391 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1392 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1393 strcat (message
, "\nIf you don't like this file selector, use the "
1394 "corresponding\nkey binding or customize "
1395 "use-file-dialog to turn it off.");
1397 wmessage
= gtk_label_new (message
);
1398 gtk_widget_show (wmessage
);
1401 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1402 if (x_gtk_file_dialog_help_text
)
1403 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1404 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1406 if (default_filename
)
1409 struct gcpro gcpro1
;
1410 char *utf8_filename
;
1413 file
= build_string (default_filename
);
1415 /* File chooser does not understand ~/... in the file name. It must be
1416 an absolute name starting with /. */
1417 if (default_filename
[0] != '/')
1418 file
= Fexpand_file_name (file
, Qnil
);
1420 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1421 if (! NILP (Ffile_directory_p (file
)))
1422 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1426 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1428 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1430 char *cp
= strrchr (utf8_filename
, '/');
1432 else cp
= utf8_filename
;
1433 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1440 *func
= xg_get_file_name_from_chooser
;
1444 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1446 /* Return the selected file for file selector dialog W.
1447 The returned string must be free:d. */
1450 xg_get_file_name_from_selector (GtkWidget
*w
)
1452 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1453 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1456 /* Create a file selection dialog.
1457 F is the current frame.
1458 PROMPT is a prompt to show to the user. May not be NULL.
1459 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1460 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1461 file. *FUNC is set to a function that can be used to retrieve the
1462 selected file name from the returned widget.
1464 Returns the created widget. */
1467 xg_get_file_with_selection (f
, prompt
, default_filename
,
1468 mustmatch_p
, only_dir_p
, func
)
1471 char *default_filename
;
1472 int mustmatch_p
, 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
, char *prompt
, char *default_filename
, int mustmatch_p
, int only_dir_p
)
1515 int filesel_done
= 0;
1516 xg_get_file_func func
;
1518 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1519 /* I really don't know why this is needed, but without this the GLIBC add on
1520 library linuxthreads hangs when the Gnome file chooser backend creates
1522 sigblock (sigmask (__SIGRTMIN
));
1523 #endif /* HAVE_GTK_AND_PTHREAD */
1525 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1527 if (xg_uses_old_file_dialog ())
1528 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1529 mustmatch_p
, only_dir_p
, &func
);
1531 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1532 mustmatch_p
, only_dir_p
, &func
);
1534 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1535 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1536 mustmatch_p
, only_dir_p
, &func
);
1537 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1539 gtk_widget_set_name (w
, "emacs-filedialog");
1541 filesel_done
= xg_dialog_run (f
, w
);
1543 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1544 sigunblock (sigmask (__SIGRTMIN
));
1547 if (filesel_done
== GTK_RESPONSE_OK
)
1550 gtk_widget_destroy (w
);
1554 #ifdef HAVE_FREETYPE
1555 /* Pop up a GTK font selector and return the name of the font the user
1556 selects, as a C string. The returned font name follows GTK's own
1559 `FAMILY [VALUE1 VALUE2] SIZE'
1561 This can be parsed using font_parse_fcname in font.c.
1562 DEFAULT_NAME, if non-zero, is the default font name. */
1565 xg_get_font_name (FRAME_PTR f
, char *default_name
)
1568 char *fontname
= NULL
;
1571 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1572 sigblock (sigmask (__SIGRTMIN
));
1573 #endif /* HAVE_GTK_AND_PTHREAD */
1575 w
= gtk_font_selection_dialog_new ("Pick a font");
1577 default_name
= "Monospace 10";
1578 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1581 gtk_widget_set_name (w
, "emacs-fontdialog");
1583 done
= xg_dialog_run (f
, w
);
1585 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1586 sigunblock (sigmask (__SIGRTMIN
));
1589 if (done
== GTK_RESPONSE_OK
)
1590 fontname
= gtk_font_selection_dialog_get_font_name
1591 (GTK_FONT_SELECTION_DIALOG (w
));
1593 gtk_widget_destroy (w
);
1596 #endif /* HAVE_FREETYPE */
1600 /***********************************************************************
1602 ***********************************************************************/
1604 /* The name of menu items that can be used for customization. Since GTK
1605 RC files are very crude and primitive, we have to set this on all
1606 menu item names so a user can easily customize menu items. */
1608 #define MENU_ITEM_NAME "emacs-menuitem"
1611 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1612 during GC. The next member points to the items. */
1613 static xg_list_node xg_menu_cb_list
;
1615 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1616 during GC. The next member points to the items. */
1617 static xg_list_node xg_menu_item_cb_list
;
1619 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1620 F is the frame CL_DATA will be initialized for.
1621 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1623 The menu bar and all sub menus under the menu bar in a frame
1624 share the same structure, hence the reference count.
1626 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1627 allocated xg_menu_cb_data if CL_DATA is NULL. */
1629 static xg_menu_cb_data
*
1630 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
1634 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1636 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1637 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1638 cl_data
->highlight_cb
= highlight_cb
;
1639 cl_data
->ref_count
= 0;
1641 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1644 cl_data
->ref_count
++;
1649 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1650 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1652 When the menu bar is updated, menu items may have been added and/or
1653 removed, so menu_bar_vector and menu_bar_items_used change. We must
1654 then update CL_DATA since it is used to determine which menu
1655 item that is invoked in the menu.
1656 HIGHLIGHT_CB could change, there is no check that the same
1657 function is given when modifying a menu bar as was given when
1658 creating the menu bar. */
1661 update_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
1666 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1667 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1668 cl_data
->highlight_cb
= highlight_cb
;
1672 /* Decrease reference count for CL_DATA.
1673 If reference count is zero, free CL_DATA. */
1676 unref_cl_data (xg_menu_cb_data
*cl_data
)
1678 if (cl_data
&& cl_data
->ref_count
> 0)
1680 cl_data
->ref_count
--;
1681 if (cl_data
->ref_count
== 0)
1683 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1689 /* Function that marks all lisp data during GC. */
1696 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1697 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1699 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1701 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1703 if (! NILP (cb_data
->help
))
1704 mark_object (cb_data
->help
);
1709 /* Callback called when a menu item is destroyed. Used to free data.
1710 W is the widget that is being destroyed (not used).
1711 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1714 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
1718 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1719 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1724 /* Callback called when the pointer enters/leaves a menu item.
1725 W is the parent of the menu item.
1726 EVENT is either an enter event or leave event.
1727 CLIENT_DATA is not used.
1729 Returns FALSE to tell GTK to keep processing this event. */
1732 menuitem_highlight_callback (GtkWidget
*w
, GdkEventCrossing
*event
, gpointer client_data
)
1735 GtkWidget
*subwidget
;
1736 xg_menu_item_cb_data
*data
;
1738 ev
.crossing
= *event
;
1739 subwidget
= gtk_get_event_widget (&ev
);
1740 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
1744 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1746 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
1747 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1748 (*func
) (subwidget
, call_data
);
1755 /* Callback called when a menu is destroyed. Used to free data.
1756 W is the widget that is being destroyed (not used).
1757 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1760 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
1762 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1765 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1766 must be non-NULL) and can be inserted into a menu item.
1768 Returns the GtkHBox. */
1771 make_widget_for_menu_item (char *utf8_label
, char *utf8_key
)
1777 wbox
= gtk_hbox_new (FALSE
, 0);
1778 wlbl
= gtk_label_new (utf8_label
);
1779 wkey
= gtk_label_new (utf8_key
);
1781 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1782 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1784 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1785 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1787 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1788 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1789 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1794 /* Make and return a menu item widget with the key to the right.
1795 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1796 UTF8_KEY is the text representing the key binding.
1797 ITEM is the widget_value describing the menu item.
1799 GROUP is an in/out parameter. If the menu item to be created is not
1800 part of any radio menu group, *GROUP contains NULL on entry and exit.
1801 If the menu item to be created is part of a radio menu group, on entry
1802 *GROUP contains the group to use, or NULL if this is the first item
1803 in the group. On exit, *GROUP contains the radio item group.
1805 Unfortunately, keys don't line up as nicely as in Motif,
1806 but the MacOS X version doesn't either, so I guess that is OK. */
1809 make_menu_item (char *utf8_label
, char *utf8_key
, widget_value
*item
, GSList
**group
)
1812 GtkWidget
*wtoadd
= 0;
1814 /* It has been observed that some menu items have a NULL name field.
1815 This will lead to this function being called with a NULL utf8_label.
1816 GTK crashes on that so we set a blank label. Why there is a NULL
1817 name remains to be investigated. */
1818 if (! utf8_label
) utf8_label
= " ";
1821 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1823 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1826 if (utf8_key
) w
= gtk_check_menu_item_new ();
1827 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1828 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1830 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1832 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1833 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1834 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1836 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1841 if (utf8_key
) w
= gtk_menu_item_new ();
1842 else w
= gtk_menu_item_new_with_label (utf8_label
);
1845 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1846 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1851 /* Return non-zero if LABEL specifies a separator (GTK only has one
1854 static const char* separator_names
[] = {
1859 "single-dashed-line",
1860 "double-dashed-line",
1862 "shadow-etched-out",
1863 "shadow-etched-in-dash",
1864 "shadow-etched-out-dash",
1865 "shadow-double-etched-in",
1866 "shadow-double-etched-out",
1867 "shadow-double-etched-in-dash",
1868 "shadow-double-etched-out-dash",
1873 xg_separator_p (char *label
)
1875 if (! label
) return 0;
1876 else if (strlen (label
) > 3
1877 && strncmp (label
, "--", 2) == 0
1883 for (i
= 0; separator_names
[i
]; ++i
)
1884 if (strcmp (label
, separator_names
[i
]) == 0)
1889 /* Old-style separator, maybe. It's a separator if it contains
1891 while (*label
== '-')
1893 if (*label
== 0) return 1;
1899 static int xg_detached_menus
;
1901 /* Returns non-zero if there are detached menus. */
1904 xg_have_tear_offs (void)
1906 return xg_detached_menus
> 0;
1909 /* Callback invoked when a detached menu window is removed. Here we
1910 decrease the xg_detached_menus count.
1911 WIDGET is the top level window that is removed (the parent of the menu).
1912 CLIENT_DATA is not used. */
1915 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
1917 if (xg_detached_menus
> 0) --xg_detached_menus
;
1920 /* Callback invoked when a menu is detached. It increases the
1921 xg_detached_menus count.
1922 WIDGET is the GtkTearoffMenuItem.
1923 CLIENT_DATA is not used. */
1926 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
1928 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
1929 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
1931 ++xg_detached_menus
;
1932 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
1934 G_CALLBACK (tearoff_remove
), 0);
1939 /* Create a menu item widget, and connect the callbacks.
1940 ITEM decribes the menu item.
1941 F is the frame the created menu belongs to.
1942 SELECT_CB is the callback to use when a menu item is selected.
1943 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1944 CL_DATA points to the callback data to be used for this menu.
1945 GROUP is an in/out parameter. If the menu item to be created is not
1946 part of any radio menu group, *GROUP contains NULL on entry and exit.
1947 If the menu item to be created is part of a radio menu group, on entry
1948 *GROUP contains the group to use, or NULL if this is the first item
1949 in the group. On exit, *GROUP contains the radio item group.
1951 Returns the created GtkWidget. */
1954 xg_create_one_menuitem (widget_value
*item
, FRAME_PTR f
, GCallback select_cb
, GCallback highlight_cb
, xg_menu_cb_data
*cl_data
, GSList
**group
)
1959 xg_menu_item_cb_data
*cb_data
;
1961 utf8_label
= get_utf8_string (item
->name
);
1962 utf8_key
= get_utf8_string (item
->key
);
1964 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
1966 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
1967 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
1969 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
1971 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
1973 cb_data
->select_id
= 0;
1974 cb_data
->help
= item
->help
;
1975 cb_data
->cl_data
= cl_data
;
1976 cb_data
->call_data
= item
->call_data
;
1978 g_signal_connect (G_OBJECT (w
),
1980 G_CALLBACK (menuitem_destroy_callback
),
1983 /* Put cb_data in widget, so we can get at it when modifying menubar */
1984 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
1986 /* final item, not a submenu */
1987 if (item
->call_data
&& ! item
->contents
)
1991 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
1997 static GtkWidget
*create_menus (widget_value
*, FRAME_PTR
, GCallback
,
1998 GCallback
, GCallback
, int, int, int,
1999 GtkWidget
*, xg_menu_cb_data
*, char *);
2001 /* Create a full menu tree specified by DATA.
2002 F is the frame the created menu belongs to.
2003 SELECT_CB is the callback to use when a menu item is selected.
2004 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2005 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2006 POP_UP_P is non-zero if we shall create a popup menu.
2007 MENU_BAR_P is non-zero if we shall create a menu bar.
2008 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2009 if MENU_BAR_P is non-zero.
2010 TOPMENU is the topmost GtkWidget that others shall be placed under.
2011 It may be NULL, in that case we create the appropriate widget
2012 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2013 CL_DATA is the callback data we shall use for this menu, or NULL
2014 if we haven't set the first callback yet.
2015 NAME is the name to give to the top level menu if this function
2016 creates it. May be NULL to not set any name.
2018 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2021 This function calls itself to create submenus. */
2024 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2025 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
2028 GCallback select_cb
;
2029 GCallback deactivate_cb
;
2030 GCallback highlight_cb
;
2035 xg_menu_cb_data
*cl_data
;
2039 GtkWidget
*wmenu
= topmenu
;
2040 GSList
*group
= NULL
;
2046 wmenu
= gtk_menu_new ();
2047 xg_set_screen (wmenu
, f
);
2048 /* Connect this to the menu instead of items so we get enter/leave for
2049 disabled items also. TODO: Still does not get enter/leave for
2050 disabled items in detached menus. */
2051 g_signal_connect (G_OBJECT (wmenu
),
2052 "enter-notify-event",
2053 G_CALLBACK (menuitem_highlight_callback
),
2055 g_signal_connect (G_OBJECT (wmenu
),
2056 "leave-notify-event",
2057 G_CALLBACK (menuitem_highlight_callback
),
2062 wmenu
= gtk_menu_bar_new ();
2063 /* Set width of menu bar to a small value so it doesn't enlarge
2064 a small initial frame size. The width will be set to the
2065 width of the frame later on when it is added to a container.
2066 height -1: Natural height. */
2067 gtk_widget_set_size_request (wmenu
, 1, -1);
2070 /* Put cl_data on the top menu for easier access. */
2071 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2072 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2073 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2074 G_CALLBACK (menu_destroy_callback
), cl_data
);
2077 gtk_widget_set_name (wmenu
, name
);
2080 g_signal_connect (G_OBJECT (wmenu
),
2081 "selection-done", deactivate_cb
, 0);
2084 if (! menu_bar_p
&& add_tearoff_p
)
2086 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2087 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2089 g_signal_connect (G_OBJECT (tearoff
), "activate",
2090 G_CALLBACK (tearoff_activate
), 0);
2093 for (item
= data
; item
; item
= item
->next
)
2097 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2098 && !xg_separator_p (item
->name
))
2101 /* A title for a popup. We do the same as GTK does when
2102 creating titles, but it does not look good. */
2104 utf8_label
= get_utf8_string (item
->name
);
2106 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2107 w
= gtk_menu_item_new_with_label (utf8_label
);
2108 gtk_widget_set_sensitive (w
, FALSE
);
2109 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2111 else if (xg_separator_p (item
->name
))
2114 /* GTK only have one separator type. */
2115 w
= gtk_separator_menu_item_new ();
2119 w
= xg_create_one_menuitem (item
,
2121 item
->contents
? 0 : select_cb
,
2126 /* Create a possibly empty submenu for menu bar items, since some
2127 themes don't highlight items correctly without it. */
2128 if (item
->contents
|| menu_bar_p
)
2130 GtkWidget
*submenu
= create_menus (item
->contents
,
2141 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2145 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2146 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2152 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2153 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2154 with some text and buttons.
2155 F is the frame the created item belongs to.
2156 NAME is the name to use for the top widget.
2157 VAL is a widget_value structure describing items to be created.
2158 SELECT_CB is the callback to use when a menu item is selected or
2159 a dialog button is pressed.
2160 DEACTIVATE_CB is the callback to use when an item is deactivated.
2161 For a menu, when a sub menu is not shown anymore, for a dialog it is
2162 called when the dialog is popped down.
2163 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2165 Returns the widget created. */
2168 xg_create_widget (type
, name
, f
, val
,
2169 select_cb
, deactivate_cb
, highlight_cb
)
2174 GCallback select_cb
;
2175 GCallback deactivate_cb
;
2176 GCallback highlight_cb
;
2179 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2180 int pop_up_p
= strcmp (type
, "popup") == 0;
2182 if (strcmp (type
, "dialog") == 0)
2184 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2185 xg_set_screen (w
, f
);
2186 gtk_window_set_transient_for (GTK_WINDOW (w
),
2187 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2188 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2189 gtk_widget_set_name (w
, "emacs-dialog");
2190 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2192 else if (menu_bar_p
|| pop_up_p
)
2194 w
= create_menus (val
->contents
,
2206 /* Set the cursor to an arrow for popup menus when they are mapped.
2207 This is done by default for menu bar menus. */
2210 /* Must realize so the GdkWindow inside the widget is created. */
2211 gtk_widget_realize (w
);
2212 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2217 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2224 /* Return the label for menu item WITEM. */
2227 xg_get_menu_item_label (GtkMenuItem
*witem
)
2229 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2230 return gtk_label_get_label (wlabel
);
2233 /* Return non-zero if the menu item WITEM has the text LABEL. */
2236 xg_item_label_same_p (GtkMenuItem
*witem
, char *label
)
2239 char *utf8_label
= get_utf8_string (label
);
2240 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2242 if (! old_label
&& ! utf8_label
)
2244 else if (old_label
&& utf8_label
)
2245 is_same
= strcmp (utf8_label
, old_label
) == 0;
2247 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2252 /* Destroy widgets in LIST. */
2255 xg_destroy_widgets (GList
*list
)
2259 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2261 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2263 /* Destroying the widget will remove it from the container it is in. */
2264 gtk_widget_destroy (w
);
2268 /* Update the top level names in MENUBAR (i.e. not submenus).
2269 F is the frame the menu bar belongs to.
2270 *LIST is a list with the current menu bar names (menu item widgets).
2271 ITER is the item within *LIST that shall be updated.
2272 POS is the numerical position, starting at 0, of ITER in *LIST.
2273 VAL describes what the menu bar shall look like after the update.
2274 SELECT_CB is the callback to use when a menu item is selected.
2275 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2276 CL_DATA points to the callback data to be used for this menu bar.
2278 This function calls itself to walk through the menu bar names. */
2281 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2282 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2289 GCallback select_cb
;
2290 GCallback deactivate_cb
;
2291 GCallback highlight_cb
;
2292 xg_menu_cb_data
*cl_data
;
2294 if (! iter
&& ! val
)
2296 else if (iter
&& ! val
)
2298 /* Item(s) have been removed. Remove all remaining items. */
2299 xg_destroy_widgets (iter
);
2301 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2302 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2303 gtk_menu_item_new_with_label (""),
2309 else if (! iter
&& val
)
2311 /* Item(s) added. Add all new items in one call. */
2312 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2313 0, 1, 0, menubar
, cl_data
, 0);
2319 /* Below this neither iter or val is NULL */
2320 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2322 /* This item is still the same, check next item. */
2324 iter
= g_list_next (iter
);
2327 else /* This item is changed. */
2329 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2330 GtkMenuItem
*witem2
= 0;
2331 int val_in_menubar
= 0;
2332 int iter_in_new_menubar
= 0;
2336 /* See if the changed entry (val) is present later in the menu bar */
2338 iter2
&& ! val_in_menubar
;
2339 iter2
= g_list_next (iter2
))
2341 witem2
= GTK_MENU_ITEM (iter2
->data
);
2342 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2345 /* See if the current entry (iter) is present later in the
2346 specification for the new menu bar. */
2347 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2348 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2350 if (val_in_menubar
&& ! iter_in_new_menubar
)
2354 /* This corresponds to:
2359 g_object_ref (G_OBJECT (witem
));
2360 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2361 gtk_widget_destroy (GTK_WIDGET (witem
));
2363 /* Must get new list since the old changed. */
2364 g_list_free (*list
);
2365 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2366 while (nr
-- > 0) iter
= g_list_next (iter
);
2368 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2370 /* This corresponds to:
2373 Rename B to X. This might seem to be a strange thing to do,
2374 since if there is a menu under B it will be totally wrong for X.
2375 But consider editing a C file. Then there is a C-mode menu
2376 (corresponds to B above).
2377 If then doing C-x C-f the minibuf menu (X above) replaces the
2378 C-mode menu. When returning from the minibuffer, we get
2379 back the C-mode menu. Thus we do:
2380 Rename B to X (C-mode to minibuf menu)
2381 Rename X to B (minibuf to C-mode menu).
2382 If the X menu hasn't been invoked, the menu under B
2383 is up to date when leaving the minibuffer. */
2384 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2385 char *utf8_label
= get_utf8_string (val
->name
);
2386 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2388 gtk_label_set_text (wlabel
, utf8_label
);
2390 /* If this item has a submenu that has been detached, change
2391 the title in the WM decorations also. */
2392 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2393 /* Set the title of the detached window. */
2394 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2396 iter
= g_list_next (iter
);
2400 else if (! val_in_menubar
&& iter_in_new_menubar
)
2402 /* This corresponds to:
2409 GtkWidget
*w
= xg_create_one_menuitem (val
,
2416 /* Create a possibly empty submenu for menu bar items, since some
2417 themes don't highlight items correctly without it. */
2418 GtkWidget
*submenu
= create_menus (NULL
, f
,
2419 select_cb
, deactivate_cb
,
2421 0, 0, 0, 0, cl_data
, 0);
2422 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2423 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2424 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2426 g_list_free (*list
);
2427 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2428 while (nr
-- > 0) iter
= g_list_next (iter
);
2429 iter
= g_list_next (iter
);
2433 else /* if (val_in_menubar && iter_in_new_menubar) */
2436 /* This corresponds to:
2441 g_object_ref (G_OBJECT (witem2
));
2442 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2443 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2444 GTK_WIDGET (witem2
), pos
);
2445 g_object_unref (G_OBJECT (witem2
));
2447 g_list_free (*list
);
2448 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2449 while (nr
-- > 0) iter
= g_list_next (iter
);
2450 if (iter
) iter
= g_list_next (iter
);
2456 /* Update the rest of the menu bar. */
2457 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2458 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2461 /* Update the menu item W so it corresponds to VAL.
2462 SELECT_CB is the callback to use when a menu item is selected.
2463 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2464 CL_DATA is the data to set in the widget for menu invocation. */
2467 xg_update_menu_item (widget_value
*val
, GtkWidget
*w
, GCallback select_cb
, GCallback highlight_cb
, xg_menu_cb_data
*cl_data
)
2474 const char *old_label
= 0;
2475 const char *old_key
= 0;
2476 xg_menu_item_cb_data
*cb_data
;
2478 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2479 utf8_label
= get_utf8_string (val
->name
);
2480 utf8_key
= get_utf8_string (val
->key
);
2482 /* See if W is a menu item with a key. See make_menu_item above. */
2483 if (GTK_IS_HBOX (wchild
))
2485 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2487 wlbl
= GTK_LABEL (list
->data
);
2488 wkey
= GTK_LABEL (list
->next
->data
);
2493 /* Remove the key and keep just the label. */
2494 g_object_ref (G_OBJECT (wlbl
));
2495 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2496 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2497 g_object_unref (G_OBJECT (wlbl
));
2502 else /* Just a label. */
2504 wlbl
= GTK_LABEL (wchild
);
2506 /* Check if there is now a key. */
2509 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2510 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2512 wlbl
= GTK_LABEL (list
->data
);
2513 wkey
= GTK_LABEL (list
->next
->data
);
2516 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2517 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2522 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2523 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2525 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2526 gtk_label_set_text (wkey
, utf8_key
);
2528 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2529 gtk_label_set_text (wlbl
, utf8_label
);
2531 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2532 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2534 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2535 gtk_widget_set_sensitive (w
, FALSE
);
2536 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2537 gtk_widget_set_sensitive (w
, TRUE
);
2539 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2543 cb_data
->call_data
= val
->call_data
;
2544 cb_data
->help
= val
->help
;
2545 cb_data
->cl_data
= cl_data
;
2547 /* We assume the callback functions don't change. */
2548 if (val
->call_data
&& ! val
->contents
)
2550 /* This item shall have a select callback. */
2551 if (! cb_data
->select_id
)
2553 = g_signal_connect (G_OBJECT (w
), "activate",
2554 select_cb
, cb_data
);
2556 else if (cb_data
->select_id
)
2558 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2559 cb_data
->select_id
= 0;
2564 /* Update the toggle menu item W so it corresponds to VAL. */
2567 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
2569 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2572 /* Update the radio menu item W so it corresponds to VAL. */
2575 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
2577 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2580 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2581 SUBMENU may be NULL, in that case a new menu is created.
2582 F is the frame the menu bar belongs to.
2583 VAL describes the contents of the menu bar.
2584 SELECT_CB is the callback to use when a menu item is selected.
2585 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2586 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2587 CL_DATA is the call back data to use for any newly created items.
2589 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2593 xg_update_submenu (submenu
, f
, val
,
2594 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2598 GCallback select_cb
;
2599 GCallback deactivate_cb
;
2600 GCallback highlight_cb
;
2601 xg_menu_cb_data
*cl_data
;
2603 GtkWidget
*newsub
= submenu
;
2607 int has_tearoff_p
= 0;
2608 GList
*first_radio
= 0;
2611 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2613 for (cur
= val
, iter
= list
;
2615 iter
= g_list_next (iter
), cur
= cur
->next
)
2617 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2619 /* Skip tearoff items, they have no counterpart in val. */
2620 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2623 iter
= g_list_next (iter
);
2624 if (iter
) w
= GTK_WIDGET (iter
->data
);
2628 /* Remember first radio button in a group. If we get a mismatch in
2629 a radio group we must rebuild the whole group so that the connections
2630 in GTK becomes correct. */
2631 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2633 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2634 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2637 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2639 if (! xg_separator_p (cur
->name
))
2642 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2644 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2646 xg_update_toggle_item (cur
, w
);
2647 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2649 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2651 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2653 xg_update_radio_item (cur
, w
);
2654 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2656 else if (GTK_IS_MENU_ITEM (w
))
2658 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2661 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2662 xg_separator_p (cur
->name
))
2665 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2667 sub
= gtk_menu_item_get_submenu (witem
);
2668 if (sub
&& ! cur
->contents
)
2670 /* Not a submenu anymore. */
2671 g_object_ref (G_OBJECT (sub
));
2672 remove_submenu (witem
);
2673 gtk_widget_destroy (sub
);
2675 else if (cur
->contents
)
2679 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2680 select_cb
, deactivate_cb
,
2681 highlight_cb
, cl_data
);
2683 /* If this item just became a submenu, we must set it. */
2685 gtk_menu_item_set_submenu (witem
, nsub
);
2690 /* Structural difference. Remove everything from here and down
2696 /* Remove widgets from first structual change. */
2699 /* If we are adding new menu items below, we must remove from
2700 first radio button so that radio groups become correct. */
2701 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2702 else xg_destroy_widgets (iter
);
2707 /* More items added. Create them. */
2708 newsub
= create_menus (cur
,
2721 if (list
) g_list_free (list
);
2726 /* Update the MENUBAR.
2727 F is the frame the menu bar belongs to.
2728 VAL describes the contents of the menu bar.
2729 If DEEP_P is non-zero, rebuild all but the top level menu names in
2730 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2731 SELECT_CB is the callback to use when a menu item is selected.
2732 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2733 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2736 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2737 select_cb
, deactivate_cb
, highlight_cb
)
2742 GCallback select_cb
;
2743 GCallback deactivate_cb
;
2744 GCallback highlight_cb
;
2746 xg_menu_cb_data
*cl_data
;
2747 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2751 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2754 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2755 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2761 /* Update all sub menus.
2762 We must keep the submenus (GTK menu item widgets) since the
2763 X Window in the XEvent that activates the menu are those widgets. */
2765 /* Update cl_data, menu_item things in F may have changed. */
2766 update_cl_data (cl_data
, f
, highlight_cb
);
2768 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2775 /* Find sub menu that corresponds to val and update it. */
2776 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2778 witem
= GTK_MENU_ITEM (iter
->data
);
2779 if (xg_item_label_same_p (witem
, cur
->name
))
2781 sub
= gtk_menu_item_get_submenu (witem
);
2786 newsub
= xg_update_submenu (sub
,
2793 /* sub may still be NULL. If we just updated non deep and added
2794 a new menu bar item, it has no sub menu yet. So we set the
2795 newly created sub menu under witem. */
2798 xg_set_screen (newsub
, f
);
2799 gtk_menu_item_set_submenu (witem
, newsub
);
2805 gtk_widget_show_all (menubar
);
2808 /* Recompute all the widgets of frame F, when the menu bar has been
2809 changed. Value is non-zero if widgets were updated. */
2812 xg_update_frame_menubar (FRAME_PTR f
)
2814 struct x_output
*x
= f
->output_data
.x
;
2817 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
2820 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
2821 return 0; /* Already done this, happens for frames created invisible. */
2825 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2827 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2829 gtk_widget_show_all (x
->menubar_widget
);
2830 gtk_widget_size_request (x
->menubar_widget
, &req
);
2831 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2832 xg_height_changed (f
);
2838 /* Get rid of the menu bar of frame F, and free its storage.
2839 This is used when deleting a frame, and when turning off the menu bar. */
2842 free_frame_menubar (FRAME_PTR f
)
2844 struct x_output
*x
= f
->output_data
.x
;
2846 if (x
->menubar_widget
)
2850 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2851 /* The menubar and its children shall be deleted when removed from
2853 x
->menubar_widget
= 0;
2854 FRAME_MENUBAR_HEIGHT (f
) = 0;
2855 xg_height_changed (f
);
2862 /***********************************************************************
2863 Scroll bar functions
2864 ***********************************************************************/
2867 /* Setting scroll bar values invokes the callback. Use this variable
2868 to indicate that callback should do nothing. */
2870 int xg_ignore_gtk_scrollbar
;
2872 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
2873 may be larger than 32 bits. Keep a mapping from integer index to widget
2874 pointers to get around the 32 bit limitation. */
2878 GtkWidget
**widgets
;
2883 /* Grow this much every time we need to allocate more */
2885 #define ID_TO_WIDGET_INCR 32
2887 /* Store the widget pointer W in id_to_widget and return the integer index. */
2890 xg_store_widget_in_map (GtkWidget
*w
)
2894 if (id_to_widget
.max_size
== id_to_widget
.used
)
2896 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
2898 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
2899 sizeof (GtkWidget
*)*new_size
);
2901 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
2902 id_to_widget
.widgets
[i
] = 0;
2903 id_to_widget
.max_size
= new_size
;
2906 /* Just loop over the array and find a free place. After all,
2907 how many scroll bars are we creating? Should be a small number.
2908 The check above guarantees we will find a free place. */
2909 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
2911 if (! id_to_widget
.widgets
[i
])
2913 id_to_widget
.widgets
[i
] = w
;
2914 ++id_to_widget
.used
;
2920 /* Should never end up here */
2924 /* Remove pointer at IDX from id_to_widget.
2925 Called when scroll bar is destroyed. */
2928 xg_remove_widget_from_map (int idx
)
2930 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2932 id_to_widget
.widgets
[idx
] = 0;
2933 --id_to_widget
.used
;
2937 /* Get the widget pointer at IDX from id_to_widget. */
2940 xg_get_widget_from_map (int idx
)
2942 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2943 return id_to_widget
.widgets
[idx
];
2948 /* Return the scrollbar id for X Window WID on display DPY.
2949 Return -1 if WID not in id_to_widget. */
2952 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
2957 w
= xg_win_to_widget (dpy
, wid
);
2961 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
2962 if (id_to_widget
.widgets
[idx
] == w
)
2969 /* Callback invoked when scroll bar WIDGET is destroyed.
2970 DATA is the index into id_to_widget for WIDGET.
2971 We free pointer to last scroll bar values here and remove the index. */
2974 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
2976 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
2977 xg_remove_widget_from_map (id
);
2980 /* Create a scroll bar widget for frame F. Store the scroll bar
2982 SCROLL_CALLBACK is the callback to invoke when the value of the
2984 END_CALLBACK is the callback to invoke when scrolling ends.
2985 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
2986 to set resources for the widget. */
2989 xg_create_scroll_bar (FRAME_PTR f
, struct scroll_bar
*bar
, GCallback scroll_callback
, GCallback end_callback
, char *scroll_bar_name
)
2996 /* Page, step increment values are not so important here, they
2997 will be corrected in x_set_toolkit_scroll_bar_thumb. */
2998 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3001 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3002 webox
= gtk_event_box_new ();
3003 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3004 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3005 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3007 scroll_id
= xg_store_widget_in_map (wscroll
);
3009 /* The EMACS_INT cast avoids a warning. */
3010 g_signal_connect (G_OBJECT (wscroll
),
3012 G_CALLBACK (xg_gtk_scroll_destroy
),
3013 (gpointer
) (EMACS_INT
) scroll_id
);
3014 g_signal_connect (G_OBJECT (wscroll
),
3018 g_signal_connect (G_OBJECT (wscroll
),
3019 "button-release-event",
3023 /* The scroll bar widget does not draw on a window of its own. Instead
3024 it draws on the parent window, in this case the edit widget. So
3025 whenever the edit widget is cleared, the scroll bar needs to redraw
3026 also, which causes flicker. Put an event box between the edit widget
3027 and the scroll bar, so the scroll bar instead draws itself on the
3028 event box window. */
3029 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3030 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3033 /* Set the cursor to an arrow. */
3034 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3036 bar
->x_window
= scroll_id
;
3039 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3042 xg_remove_scroll_bar (FRAME_PTR f
, int scrollbar_id
)
3044 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3047 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3048 gtk_widget_destroy (w
);
3049 gtk_widget_destroy (wparent
);
3050 SET_FRAME_GARBAGED (f
);
3054 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3056 TOP/LEFT are the new pixel positions where the bar shall appear.
3057 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3060 xg_update_scrollbar_pos (FRAME_PTR f
, int scrollbar_id
, int top
, int left
, int width
, int height
)
3063 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3067 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3068 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3071 /* Clear out old position. */
3072 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3073 if (gtk_widget_get_parent (wparent
) == wfixed
)
3075 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3076 "x", &oldx
, "y", &oldy
, NULL
);
3077 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3080 /* Move and resize to new values. */
3081 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3082 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3085 /* No room. Hide scroll bar as some themes output a warning if
3086 the height is less than the min size. */
3087 gtk_widget_hide (wparent
);
3088 gtk_widget_hide (wscroll
);
3092 gtk_widget_show_all (wparent
);
3093 gtk_widget_set_size_request (wscroll
, width
, height
);
3095 gtk_widget_queue_draw (wfixed
);
3096 gdk_window_process_all_updates ();
3097 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3099 /* Clear under old scroll bar position. This must be done after
3100 the gtk_widget_queue_draw and gdk_window_process_all_updates
3102 x_clear_area (FRAME_X_DISPLAY (f
),
3104 oldx
, oldy
, oldw
, oldh
, 0);
3107 /* GTK does not redraw until the main loop is entered again, but
3108 if there are no X events pending we will not enter it. So we sync
3109 here to get some events. */
3112 SET_FRAME_GARBAGED (f
);
3113 cancel_mouse_face (f
);
3117 /* Set the thumb size and position of scroll bar BAR. We are currently
3118 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3121 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
3123 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3125 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3127 if (wscroll
&& NILP (bar
->dragging
))
3136 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3138 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3139 rather than the real portion value. This makes the thumb less likely
3140 to resize and that looks better. */
3141 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3142 /* When the thumb is at the bottom, position == whole.
3143 So we need to increase `whole' to make space for the thumb. */
3150 top
= (gdouble
) position
/ whole
;
3151 shown
= (gdouble
) portion
/ whole
;
3154 size
= shown
* XG_SB_RANGE
;
3155 size
= min (size
, XG_SB_RANGE
);
3156 size
= max (size
, 1);
3158 value
= top
* XG_SB_RANGE
;
3159 value
= min (value
, XG_SB_MAX
- size
);
3160 value
= max (value
, XG_SB_MIN
);
3162 /* Assume all lines are of equal size. */
3163 new_step
= size
/ max (1, FRAME_LINES (f
));
3165 if ((int) gtk_adjustment_get_page_size (adj
) != size
3166 || (int) gtk_adjustment_get_step_increment (adj
) != new_step
)
3168 gtk_adjustment_set_page_size (adj
, size
);
3169 gtk_adjustment_set_step_increment (adj
, new_step
);
3170 /* Assume a page increment is about 95% of the page size */
3171 gtk_adjustment_set_page_increment (adj
,(int) (0.95*size
));
3175 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3179 /* gtk_range_set_value invokes the callback. Set
3180 ignore_gtk_scrollbar to make the callback do nothing */
3181 xg_ignore_gtk_scrollbar
= 1;
3183 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3184 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3186 gtk_adjustment_changed (adj
);
3188 xg_ignore_gtk_scrollbar
= 0;
3195 /* Return non-zero if EVENT is for a scroll bar in frame F.
3196 When the same X window is used for several Gtk+ widgets, we cannot
3197 say for sure based on the X window alone if an event is for the
3198 frame. This function does additional checks.
3200 Return non-zero if the event is for a scroll bar, zero otherwise. */
3203 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3207 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3209 /* Check if press occurred outside the edit widget. */
3210 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3211 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3212 != gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3215 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3216 || event
->type
== MotionNotify
))
3218 /* If we are releasing or moving the scroll bar, it has the grab. */
3219 GtkWidget
*w
= gtk_grab_get_current ();
3220 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3228 /***********************************************************************
3230 ***********************************************************************/
3231 /* The key for the data we put in the GtkImage widgets. The data is
3232 the image used by Emacs. We use this to see if we need to update
3233 the GtkImage with a new image. */
3234 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3236 /* The key for storing the latest modifiers so the activate callback can
3238 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3240 /* The key for storing the button widget in its proxy menu item. */
3241 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3243 /* The key for the data we put in the GtkImage widgets. The data is
3244 the stock name used by Emacs. We use this to see if we need to update
3245 the GtkImage with a new image. */
3246 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3248 /* As above, but this is used for named theme widgets, as opposed to
3250 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3252 /* Callback function invoked when a tool bar item is pressed.
3253 W is the button widget in the tool bar that got pressed,
3254 CLIENT_DATA is an integer that is the index of the button in the
3255 tool bar. 0 is the first button. */
3258 xg_tool_bar_button_cb (GtkWidget
*widget
, GdkEventButton
*event
, gpointer user_data
)
3260 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3261 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3262 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3267 /* Callback function invoked when a tool bar item is pressed.
3268 W is the button widget in the tool bar that got pressed,
3269 CLIENT_DATA is an integer that is the index of the button in the
3270 tool bar. 0 is the first button. */
3273 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3275 /* The EMACS_INT cast avoids a warning. */
3276 int idx
= (int) (EMACS_INT
) client_data
;
3277 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3278 XG_TOOL_BAR_LAST_MODIFIER
);
3280 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3281 Lisp_Object key
, frame
;
3282 struct input_event event
;
3285 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3288 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3290 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3291 XSETFRAME (frame
, f
);
3293 /* We generate two events here. The first one is to set the prefix
3294 to `(tool_bar)', see keyboard.c. */
3295 event
.kind
= TOOL_BAR_EVENT
;
3296 event
.frame_or_window
= frame
;
3298 kbd_buffer_store_event (&event
);
3300 event
.kind
= TOOL_BAR_EVENT
;
3301 event
.frame_or_window
= frame
;
3303 /* Convert between the modifier bits GDK uses and the modifier bits
3304 Emacs uses. This assumes GDK and X masks are the same, which they are when
3306 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3307 kbd_buffer_store_event (&event
);
3309 /* Return focus to the frame after we have clicked on a detached
3311 Fx_focus_frame (frame
);
3314 /* Callback function invoked when a tool bar item is pressed in a detached
3315 tool bar or the overflow drop down menu.
3316 We just call xg_tool_bar_callback.
3317 W is the menu item widget that got pressed,
3318 CLIENT_DATA is an integer that is the index of the button in the
3319 tool bar. 0 is the first button. */
3322 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3324 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3325 XG_TOOL_BAR_PROXY_BUTTON
));
3326 xg_tool_bar_callback (wbutton
, client_data
);
3331 xg_tool_bar_help_callback (GtkWidget
*w
,
3332 GdkEventCrossing
*event
,
3333 gpointer client_data
);
3335 /* This callback is called when a help is to be shown for an item in
3336 the detached tool bar when the detached tool bar it is not expanded. */
3339 xg_tool_bar_proxy_help_callback (GtkWidget
*w
, GdkEventCrossing
*event
, gpointer client_data
)
3341 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3342 XG_TOOL_BAR_PROXY_BUTTON
));
3344 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3348 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3350 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3351 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
3352 GtkWidget
*c2
= (GtkWidget
*) clist
->next
->data
;
3353 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3354 g_list_free (clist
);
3355 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3359 /* This callback is called when a tool item should create a proxy item,
3360 such as for the overflow menu. Also called when the tool bar is detached.
3361 If we don't create a proxy menu item, the detached tool bar will be
3365 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3367 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (toolitem
));
3368 GtkButton
*wbutton
= GTK_BUTTON (gtk_bin_get_child (GTK_BIN (weventbox
)));
3369 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
3371 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3372 GtkImage
*wimage
= GTK_IMAGE (c1
);
3373 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3374 (gtk_label_get_text (wlbl
));
3375 GtkWidget
*wmenuimage
;
3378 if (gtk_button_get_use_stock (wbutton
))
3379 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3380 GTK_ICON_SIZE_MENU
);
3383 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3384 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3386 if (store_type
== GTK_IMAGE_STOCK
)
3389 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3390 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3392 else if (store_type
== GTK_IMAGE_ICON_SET
)
3394 GtkIconSet
*icon_set
;
3395 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3396 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3397 GTK_ICON_SIZE_MENU
);
3399 else if (store_type
== GTK_IMAGE_PIXBUF
)
3404 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3407 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3409 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3410 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3411 GDK_INTERP_BILINEAR
);
3413 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3417 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3421 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3423 const gchar
*icon_name
;
3424 GtkIconSize icon_size
;
3426 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3427 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3428 GTK_ICON_SIZE_MENU
);
3432 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3437 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3439 g_signal_connect (G_OBJECT (wmenuitem
),
3441 G_CALLBACK (xg_tool_bar_proxy_callback
),
3445 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3446 (gpointer
) wbutton
);
3447 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3448 gtk_widget_set_sensitive (wmenuitem
,
3449 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
3451 /* Use enter/leave notify to show help. We use the events
3452 rather than the GtkButton specific signals "enter" and
3453 "leave", so we can have only one callback. The event
3454 will tell us what kind of event it is. */
3455 g_signal_connect (G_OBJECT (wmenuitem
),
3456 "enter-notify-event",
3457 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3459 g_signal_connect (G_OBJECT (wmenuitem
),
3460 "leave-notify-event",
3461 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3467 /* This callback is called when a tool bar is detached. We must set
3468 the height of the tool bar to zero when this happens so frame sizes
3469 are correctly calculated.
3470 WBOX is the handle box widget that enables detach/attach of the tool bar.
3471 W is the tool bar widget.
3472 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3475 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
, GtkWidget
*w
, gpointer client_data
)
3477 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3478 extern int x_gtk_whole_detached_tool_bar
;
3480 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3485 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3487 /* When detaching a tool bar, not everything dissapear. There are
3488 a few pixels left that are used to drop the tool bar back into
3490 FRAME_TOOLBAR_HEIGHT (f
) = 4;
3491 xg_height_changed (f
);
3495 /* This callback is called when a tool bar is reattached. We must set
3496 the height of the tool bar when this happens so frame sizes
3497 are correctly calculated.
3498 WBOX is the handle box widget that enables detach/attach of the tool bar.
3499 W is the tool bar widget.
3500 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3503 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
, GtkWidget
*w
, gpointer client_data
)
3505 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3506 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3512 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3514 gtk_widget_size_request (w
, &req
);
3515 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3516 xg_height_changed (f
);
3520 /* This callback is called when the mouse enters or leaves a tool bar item.
3521 It is used for displaying and hiding the help text.
3522 W is the tool bar item, a button.
3523 EVENT is either an enter event or leave event.
3524 CLIENT_DATA is an integer that is the index of the button in the
3525 tool bar. 0 is the first button.
3527 Returns FALSE to tell GTK to keep processing this event. */
3530 xg_tool_bar_help_callback (GtkWidget
*w
, GdkEventCrossing
*event
, gpointer client_data
)
3532 /* The EMACS_INT cast avoids a warning. */
3533 int idx
= (int) (EMACS_INT
) client_data
;
3534 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3535 Lisp_Object help
, frame
;
3537 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3540 if (event
->type
== GDK_ENTER_NOTIFY
)
3542 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3543 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3546 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3551 XSETFRAME (frame
, f
);
3552 kbd_buffer_store_help_event (frame
, help
);
3558 /* This callback is called when a tool bar item shall be redrawn.
3559 It modifies the expose event so that the GtkImage widget redraws the
3560 whole image. This to overcome a bug that makes GtkImage draw the image
3561 in the wrong place when it tries to redraw just a part of the image.
3562 W is the GtkImage to be redrawn.
3563 EVENT is the expose event for W.
3564 CLIENT_DATA is unused.
3566 Returns FALSE to tell GTK to keep processing this event. */
3569 xg_tool_bar_item_expose_callback (GtkWidget
*w
, GdkEventExpose
*event
, gpointer client_data
)
3573 gdk_drawable_get_size (event
->window
, &width
, &height
);
3575 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3576 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3578 event
->area
.x
= max (0, event
->area
.x
);
3579 event
->area
.y
= max (0, event
->area
.y
);
3581 event
->area
.width
= max (width
, event
->area
.width
);
3582 event
->area
.height
= max (height
, event
->area
.height
);
3587 /* Attach a tool bar to frame F. */
3590 xg_pack_tool_bar (FRAME_PTR f
)
3592 struct x_output
*x
= f
->output_data
.x
;
3593 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3595 x
->handlebox_widget
= gtk_handle_box_new ();
3596 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3597 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3598 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3599 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3601 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3604 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3607 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3610 gtk_widget_show (x
->toolbar_widget
);
3611 gtk_widget_show (x
->handlebox_widget
);
3614 /* Create a tool bar for frame F. */
3615 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
3616 #define toolbar_set_orientation(w, o) \
3617 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
3619 #define toolbar_set_orientation(w, o) \
3620 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
3624 xg_create_tool_bar (FRAME_PTR f
)
3626 struct x_output
*x
= f
->output_data
.x
;
3628 x
->toolbar_widget
= gtk_toolbar_new ();
3629 x
->toolbar_detached
= 0;
3631 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3633 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3634 toolbar_set_orientation (x
->toolbar_widget
,
3635 GTK_ORIENTATION_HORIZONTAL
);
3639 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3641 /* Find the right-to-left image named by RTL in the tool bar images for F.
3642 Returns IMAGE if RTL is not found. */
3645 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
3648 Lisp_Object file
, rtl_name
;
3649 struct gcpro gcpro1
, gcpro2
;
3650 GCPRO2 (file
, rtl_name
);
3652 rtl_name
= Ffile_name_nondirectory (rtl
);
3654 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3656 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3657 if (!NILP (file
= file_for_image (rtl_image
)))
3659 file
= call1 (intern ("file-name-sans-extension"),
3660 Ffile_name_nondirectory (file
));
3661 if (EQ (Fequal (file
, rtl_name
), Qt
))
3672 static GtkToolItem
*
3673 xg_make_tool_item (FRAME_PTR f
,
3675 GtkWidget
**wbutton
,
3679 GtkToolItem
*ti
= gtk_tool_item_new ();
3680 GtkWidget
*vb
= EQ (Vtool_bar_style
, Qboth_horiz
)
3681 ? gtk_hbox_new (FALSE
, 0) : gtk_vbox_new (FALSE
, 0);
3682 GtkWidget
*wb
= gtk_button_new ();
3683 GtkWidget
*weventbox
= gtk_event_box_new ();
3686 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
3688 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
3689 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
3690 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
3691 gtk_container_add (GTK_CONTAINER (wb
), vb
);
3692 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
3693 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
3697 /* The EMACS_INT cast avoids a warning. */
3698 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
3699 G_CALLBACK (xg_tool_bar_menu_proxy
),
3700 (gpointer
) (EMACS_INT
) i
);
3702 g_signal_connect (G_OBJECT (wb
), "clicked",
3703 G_CALLBACK (xg_tool_bar_callback
),
3704 (gpointer
) (EMACS_INT
) i
);
3706 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
3708 /* Catch expose events to overcome an annoying redraw bug, see
3709 comment for xg_tool_bar_item_expose_callback. */
3710 g_signal_connect (G_OBJECT (ti
),
3712 G_CALLBACK (xg_tool_bar_item_expose_callback
),
3715 gtk_tool_item_set_homogeneous (ti
, FALSE
);
3717 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
3718 no distinction based on modifiers in the activate callback,
3719 so we have to do it ourselves. */
3720 g_signal_connect (wb
, "button-release-event",
3721 G_CALLBACK (xg_tool_bar_button_cb
),
3724 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
3726 /* Use enter/leave notify to show help. We use the events
3727 rather than the GtkButton specific signals "enter" and
3728 "leave", so we can have only one callback. The event
3729 will tell us what kind of event it is. */
3730 /* The EMACS_INT cast avoids a warning. */
3731 g_signal_connect (G_OBJECT (weventbox
),
3732 "enter-notify-event",
3733 G_CALLBACK (xg_tool_bar_help_callback
),
3734 (gpointer
) (EMACS_INT
) i
);
3735 g_signal_connect (G_OBJECT (weventbox
),
3736 "leave-notify-event",
3737 G_CALLBACK (xg_tool_bar_help_callback
),
3738 (gpointer
) (EMACS_INT
) i
);
3741 if (wbutton
) *wbutton
= wb
;
3747 xg_show_toolbar_item (GtkToolItem
*ti
)
3749 Lisp_Object style
= Ftool_bar_get_system_style ();
3751 int show_label
= EQ (style
, Qboth
)
3752 || EQ (style
, Qboth_horiz
) || EQ (style
, Qtext
);
3753 int show_image
= ! EQ (style
, Qtext
);
3754 int horiz
= EQ (style
, Qboth_horiz
);
3756 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3757 GtkWidget
*wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3758 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
3760 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
3761 GtkWidget
*new_box
= NULL
;
3763 if (GTK_IS_VBOX (vb
) && horiz
)
3764 new_box
= gtk_hbox_new (FALSE
, 0);
3765 else if (GTK_IS_HBOX (vb
) && !horiz
&& show_label
&& show_image
)
3766 new_box
= gtk_vbox_new (FALSE
, 0);
3769 g_object_ref (G_OBJECT (wimage
));
3770 g_object_ref (G_OBJECT (wlbl
));
3771 gtk_container_remove (GTK_CONTAINER (vb
), wimage
);
3772 gtk_container_remove (GTK_CONTAINER (vb
), wlbl
);
3773 gtk_widget_destroy (GTK_WIDGET (vb
));
3774 gtk_box_pack_start (GTK_BOX (new_box
), wimage
, TRUE
, TRUE
, 0);
3775 gtk_box_pack_start (GTK_BOX (new_box
), wlbl
, TRUE
, TRUE
, 0);
3776 gtk_container_add (GTK_CONTAINER (wbutton
), new_box
);
3777 g_object_unref (G_OBJECT (wimage
));
3778 g_object_unref (G_OBJECT (wlbl
));
3782 if (show_label
) gtk_widget_show (wlbl
);
3783 else gtk_widget_hide (wlbl
);
3784 if (show_image
) gtk_widget_show (wimage
);
3785 else gtk_widget_hide (wimage
);
3786 gtk_widget_show (GTK_WIDGET (weventbox
));
3787 gtk_widget_show (GTK_WIDGET (vb
));
3788 gtk_widget_show (GTK_WIDGET (wbutton
));
3789 gtk_widget_show (GTK_WIDGET (ti
));
3793 /* Update the tool bar for frame F. Add new buttons and remove old. */
3795 extern Lisp_Object Qx_gtk_map_stock
;
3798 update_frame_tool_bar (FRAME_PTR f
)
3801 GtkRequisition old_req
, new_req
;
3802 struct x_output
*x
= f
->output_data
.x
;
3803 int hmargin
= 0, vmargin
= 0;
3804 GtkToolbar
*wtoolbar
;
3806 GtkTextDirection dir
;
3807 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
3809 if (! FRAME_GTK_WIDGET (f
))
3814 if (INTEGERP (Vtool_bar_button_margin
)
3815 && XINT (Vtool_bar_button_margin
) > 0)
3817 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3818 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3820 else if (CONSP (Vtool_bar_button_margin
))
3822 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3823 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3824 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3826 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3827 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3828 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3831 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3832 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3833 i.e. zero. This means that margins less than
3834 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3835 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3836 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3838 if (! x
->toolbar_widget
)
3839 xg_create_tool_bar (f
);
3841 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
3842 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &old_req
);
3843 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
3845 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3847 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3848 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3852 struct image
*img
= NULL
;
3854 Lisp_Object stock
= Qnil
;
3855 GtkStockItem stock_item
;
3856 char *stock_name
= NULL
;
3857 char *icon_name
= NULL
;
3859 GtkWidget
*wbutton
= NULL
;
3860 GtkWidget
*weventbox
;
3861 Lisp_Object specified_file
;
3862 Lisp_Object lbl
= PROP (TOOL_BAR_ITEM_LABEL
);
3863 char *label
= SSDATA (PROP (TOOL_BAR_ITEM_LABEL
));
3865 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), i
);
3869 weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3870 wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3874 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3876 /* Ignore invalid image specifications. */
3877 if (!valid_image_p (image
))
3879 if (wbutton
) gtk_widget_hide (wbutton
);
3883 specified_file
= file_for_image (image
);
3884 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
3885 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
3887 if (STRINGP (stock
))
3889 stock_name
= SSDATA (stock
);
3890 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
3892 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
3893 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
3895 icon_name
= stock_name
+ 2;
3899 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
3902 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3904 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
3905 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3913 if (stock_name
== NULL
&& icon_name
== NULL
)
3915 /* No stock image, or stock item not known. Try regular image. */
3917 /* If image is a vector, choose the image according to the
3919 if (dir
== GTK_TEXT_DIR_RTL
3920 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
3923 image
= find_rtl_image (f
, image
, rtl
);
3926 if (VECTORP (image
))
3930 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3931 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3934 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3935 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3937 xassert (ASIZE (image
) >= idx
);
3938 image
= AREF (image
, idx
);
3943 img_id
= lookup_image (f
, image
);
3944 img
= IMAGE_FROM_ID (f
, img_id
);
3945 prepare_image_for_display (f
, img
);
3947 if (img
->load_failed_p
|| img
->pixmap
== None
)
3950 gtk_widget_hide_all (GTK_WIDGET (ti
));
3953 /* Insert an empty (non-image) button */
3954 ti
= xg_make_tool_item (f
, NULL
, NULL
, "", i
);
3955 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, -1);
3966 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
3967 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
3968 (gpointer
) xstrdup (stock_name
),
3969 (GDestroyNotify
) xfree
);
3973 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
3974 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
3975 (gpointer
) xstrdup (icon_name
),
3976 (GDestroyNotify
) xfree
);
3980 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
3981 /* Save the image so we can see if an update is needed when
3982 this function is called again. */
3983 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
3984 (gpointer
)img
->pixmap
);
3987 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
3988 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
);
3989 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, -1);
3990 gtk_widget_set_sensitive (wbutton
, enabled_p
);
3994 GtkWidget
*vb
= gtk_bin_get_child (GTK_BIN (wbutton
));
3996 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
3998 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
3999 XG_TOOL_BAR_IMAGE_DATA
);
4000 gpointer old_stock_name
= g_object_get_data (G_OBJECT (wimage
),
4001 XG_TOOL_BAR_STOCK_NAME
);
4002 gpointer old_icon_name
= g_object_get_data (G_OBJECT (wimage
),
4003 XG_TOOL_BAR_ICON_NAME
);
4004 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4006 (! old_stock_name
|| strcmp (old_stock_name
, stock_name
) != 0))
4008 gtk_image_set_from_stock (GTK_IMAGE (wimage
),
4009 stock_name
, icon_size
);
4010 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4011 (gpointer
) xstrdup (stock_name
),
4012 (GDestroyNotify
) xfree
);
4013 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4015 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4018 else if (icon_name
&&
4019 (! old_icon_name
|| strcmp (old_icon_name
, icon_name
) != 0))
4021 gtk_image_set_from_icon_name (GTK_IMAGE (wimage
),
4022 icon_name
, icon_size
);
4023 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4024 (gpointer
) xstrdup (icon_name
),
4025 (GDestroyNotify
) xfree
);
4026 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4028 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4031 else if (img
&& old_img
!= img
->pixmap
)
4033 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
4034 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4035 (gpointer
)img
->pixmap
);
4037 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4039 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4043 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
4045 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4047 xg_show_toolbar_item (ti
);
4052 /* Remove buttons not longer needed. We just hide them so they
4053 can be reused later on. */
4056 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), i
++);
4057 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
4058 } while (ti
!= NULL
);
4061 if (pack_tool_bar
&& f
->n_tool_bar_items
!= 0)
4062 xg_pack_tool_bar (f
);
4065 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &new_req
);
4066 if (old_req
.height
!= new_req
.height
4067 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
4069 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
4070 xg_height_changed (f
);
4075 /* Deallocate all resources for the tool bar on frame F.
4076 Remove the tool bar. */
4079 free_frame_tool_bar (FRAME_PTR f
)
4081 struct x_output
*x
= f
->output_data
.x
;
4083 if (x
->toolbar_widget
)
4085 int is_packed
= x
->handlebox_widget
!= 0;
4087 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4088 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4090 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4091 x
->handlebox_widget
);
4093 gtk_widget_destroy (x
->toolbar_widget
);
4095 x
->toolbar_widget
= 0;
4096 x
->handlebox_widget
= 0;
4097 FRAME_TOOLBAR_HEIGHT (f
) = 0;
4098 xg_height_changed (f
);
4106 /***********************************************************************
4108 ***********************************************************************/
4110 xg_initialize (void)
4112 GtkBindingSet
*binding_set
;
4115 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4116 we keep it permanently linked in. */
4121 xg_ignore_gtk_scrollbar
= 0;
4122 xg_detached_menus
= 0;
4123 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4124 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4126 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4127 id_to_widget
.widgets
= 0;
4129 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4130 bindings. It doesn't seem to be any way to remove properties,
4131 so we set it to VoidSymbol which in X means "no key". */
4132 gtk_settings_set_string_property (gtk_settings_get_default (),
4133 "gtk-menu-bar-accel",
4137 /* Make GTK text input widgets use Emacs style keybindings. This is
4139 gtk_settings_set_string_property (gtk_settings_get_default (),
4140 "gtk-key-theme-name",
4144 /* Make dialogs close on C-g. Since file dialog inherits from
4145 dialog, this works for them also. */
4146 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4147 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4150 /* Make menus close on C-g. */
4151 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4152 (GTK_TYPE_MENU_SHELL
));
4153 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4157 #endif /* USE_GTK */
4159 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
4160 (do not change this comment) */