1 /* Functions for creating and updating GTK widgets.
2 Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
29 #include "blockinput.h"
30 #include "syssignal.h"
34 #include "termhooks.h"
38 #include <gdk/gdkkeysyms.h>
41 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
42 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
45 /***********************************************************************
46 Display handling functions
47 ***********************************************************************/
49 #ifdef HAVE_GTK_MULTIDISPLAY
51 /* Return the GdkDisplay that corresponds to the X display DPY. */
54 xg_get_gdk_display (dpy
)
57 return gdk_x11_lookup_xdisplay (dpy
);
60 /* When the GTK widget W is to be created on a display for F that
61 is not the default display, set the display for W.
62 W can be a GtkMenu or a GtkWindow widget. */
69 if (FRAME_X_DISPLAY (f
) != GDK_DISPLAY ())
71 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
72 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
75 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
77 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
82 #else /* not HAVE_GTK_MULTIDISPLAY */
84 /* Make some defines so we can use the GTK 2.2 functions when
85 compiling with GTK 2.0. */
87 #define xg_set_screen(w, f)
88 #define gdk_xid_table_lookup_for_display(dpy, w) gdk_xid_table_lookup (w)
89 #define gdk_pixmap_foreign_new_for_display(dpy, p) gdk_pixmap_foreign_new (p)
90 #define gdk_cursor_new_for_display(dpy, c) gdk_cursor_new (c)
91 #define gdk_x11_lookup_xdisplay(dpy) 0
92 #define GdkDisplay void
94 #endif /* not HAVE_GTK_MULTIDISPLAY */
96 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
97 *DPY is set to NULL if the display can't be opened.
99 Returns non-zero if display could be opened, zero if display could not
100 be opened, and less than zero if the GTK version doesn't support
104 xg_display_open (display_name
, dpy
)
108 #ifdef HAVE_GTK_MULTIDISPLAY
111 gdpy
= gdk_display_open (display_name
);
112 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
116 #else /* not HAVE_GTK_MULTIDISPLAY */
119 #endif /* not HAVE_GTK_MULTIDISPLAY */
123 /* Close display DPY. */
126 xg_display_close (Display
*dpy
)
128 #ifdef HAVE_GTK_MULTIDISPLAY
129 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
131 /* GTK 2.2 has a bug that makes gdk_display_close crash (bug
132 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way
133 we can continue running, but there will be memory leaks. */
135 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 4
137 /* If this is the default display, we must change it before calling
138 dispose, otherwise it will crash. */
139 if (gdk_display_get_default () == gdpy
)
141 struct x_display_info
*dpyinfo
;
142 Display
*new_dpy
= 0;
143 GdkDisplay
*gdpy_new
;
145 /* Find another display. */
146 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
147 if (dpyinfo
->display
!= dpy
)
149 new_dpy
= dpyinfo
->display
;
153 if (! new_dpy
) return; /* Emacs will exit anyway. */
155 gdpy_new
= gdk_x11_lookup_xdisplay (new_dpy
);
156 gdk_display_manager_set_default_display (gdk_display_manager_get (),
160 g_object_run_dispose (G_OBJECT (gdpy
));
163 /* I hope this will be fixed in GTK 2.4. It is what bug 85715 says. */
164 gdk_display_close (gdpy
);
166 #endif /* HAVE_GTK_MULTIDISPLAY */
170 /***********************************************************************
172 ***********************************************************************/
173 /* The timer for scroll bar repetition and menu bar timeouts.
174 NULL if no timer is started. */
175 static struct atimer
*xg_timer
;
178 /* The next two variables and functions are taken from lwlib. */
179 static widget_value
*widget_value_free_list
;
180 static int malloc_cpt
;
182 /* Allocate a widget_value structure, either by taking one from the
183 widget_value_free_list or by malloc:ing a new one.
185 Return a pointer to the allocated structure. */
188 malloc_widget_value ()
191 if (widget_value_free_list
)
193 wv
= widget_value_free_list
;
194 widget_value_free_list
= wv
->free_list
;
199 wv
= (widget_value
*) malloc (sizeof (widget_value
));
202 memset (wv
, 0, sizeof (widget_value
));
206 /* This is analogous to free. It frees only what was allocated
207 by malloc_widget_value, and no substructures. */
210 free_widget_value (wv
)
218 /* When the number of already allocated cells is too big,
225 wv
->free_list
= widget_value_free_list
;
226 widget_value_free_list
= wv
;
231 /* Create and return the cursor to be used for popup menus and
232 scroll bars on display DPY. */
235 xg_create_default_cursor (dpy
)
238 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
239 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
242 /* For the image defined in IMG, make and return a GtkImage. For displays with
243 8 planes or less we must make a GdkPixbuf and apply the mask manually.
244 Otherwise the highlightning and dimming the tool bar code in GTK does
245 will look bad. For display with more than 8 planes we just use the
246 pixmap and mask directly. For monochrome displays, GTK doesn't seem
247 able to use external pixmaps, it looks bad whatever we do.
248 The image is defined on the display where frame F is.
249 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
250 If OLD_WIDGET is NULL, a new widget is constructed and returned.
251 If OLD_WIDGET is not NULL, that widget is modified. */
254 xg_get_image_for_pixmap (f
, img
, widget
, old_widget
)
258 GtkImage
*old_widget
;
264 /* If we are on a one bit display, let GTK do all the image handling.
265 This seems to be the only way to make insensitive and activated icons
267 if (x_screen_planes (f
) == 1)
269 Lisp_Object specified_file
= Qnil
;
271 extern Lisp_Object QCfile
;
273 for (tail
= XCDR (img
->spec
);
274 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
275 tail
= XCDR (XCDR (tail
)))
276 if (EQ (XCAR (tail
), QCfile
))
277 specified_file
= XCAR (XCDR (tail
));
279 if (STRINGP (specified_file
))
282 Lisp_Object file
= Qnil
;
286 file
= x_find_image_file (specified_file
);
287 /* We already loaded the image once before calling this
288 function, so this should not fail. */
289 xassert (STRINGP (file
) != 0);
292 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SDATA (file
)));
294 gtk_image_set_from_file (old_widget
, SDATA (file
));
297 return GTK_WIDGET (old_widget
);
301 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
302 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
303 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
305 if (x_screen_planes (f
) > 8 || x_screen_planes (f
) == 1)
308 old_widget
= GTK_IMAGE (gtk_image_new_from_pixmap (gpix
, gmask
));
310 gtk_image_set_from_pixmap (old_widget
, gpix
, gmask
);
314 /* This is a workaround to make icons look good on pseudo color
315 displays. Apparently GTK expects the images to have an alpha
316 channel. If they don't, insensitive and activated icons will
317 look bad. This workaround does not work on monochrome displays,
318 and is not needed on true color/static color displays (i.e.
319 16 bits and higher). */
320 int x
, y
, width
, height
, rowstride
, mask_rowstride
;
321 GdkPixbuf
*icon_buf
, *tmp_buf
;
325 gdk_drawable_get_size (gpix
, &width
, &height
);
326 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
,
328 gtk_widget_get_colormap (widget
),
329 0, 0, 0, 0, width
, height
);
330 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
331 g_object_unref (G_OBJECT (tmp_buf
));
335 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
340 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
341 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
342 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
343 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
346 for (y
= 0; y
< height
; ++y
)
348 guchar
*iconptr
, *maskptr
;
351 iconptr
= pixels
+ y
* rowstride
;
352 maskptr
= mask_pixels
+ y
* mask_rowstride
;
354 for (x
= 0; x
< width
; ++x
)
356 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
357 just R is sufficient. */
359 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
361 iconptr
+= rowstride
/width
;
362 maskptr
+= mask_rowstride
/width
;
366 g_object_unref (G_OBJECT (mask_buf
));
370 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
372 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
374 g_object_unref (G_OBJECT (icon_buf
));
377 g_object_unref (G_OBJECT (gpix
));
378 if (gmask
) g_object_unref (G_OBJECT (gmask
));
380 return GTK_WIDGET (old_widget
);
384 /* Set CURSOR on W and all widgets W contain. We must do like this
385 for scroll bars and menu because they create widgets internally,
386 and it is those widgets that are visible. */
389 xg_set_cursor (w
, cursor
)
393 GList
*children
= gdk_window_peek_children (w
->window
);
395 gdk_window_set_cursor (w
->window
, cursor
);
397 /* The scroll bar widget has more than one GDK window (had to look at
398 the source to figure this out), and there is no way to set cursor
399 on widgets in GTK. So we must set the cursor for all GDK windows.
402 for ( ; children
; children
= g_list_next (children
))
403 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
406 /* Timer function called when a timeout occurs for xg_timer.
407 This function processes all GTK events in a recursive event loop.
408 This is done because GTK timer events are not seen by Emacs event
409 detection, Emacs only looks for X events. When a scroll bar has the
410 pointer (detected by button press/release events below) an Emacs
411 timer is started, and this function can then check if the GTK timer
412 has expired by calling the GTK event loop.
413 Also, when a menu is active, it has a small timeout before it
414 pops down the sub menu under it. */
417 xg_process_timeouts (timer
)
418 struct atimer
*timer
;
421 /* Ideally we would like to just handle timer events, like the Xt version
422 of this does in xterm.c, but there is no such feature in GTK. */
423 while (gtk_events_pending ())
424 gtk_main_iteration ();
428 /* Start the xg_timer with an interval of 0.1 seconds, if not already started.
429 xg_process_timeouts is called when the timer expires. The timer
430 started is continuous, i.e. runs until xg_stop_timer is called. */
438 EMACS_SET_SECS_USECS (interval
, 0, 100000);
439 xg_timer
= start_atimer (ATIMER_CONTINUOUS
,
446 /* Stop the xg_timer if started. */
453 cancel_atimer (xg_timer
);
458 /* Insert NODE into linked LIST. */
461 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
463 xg_list_node
*list_start
= list
->next
;
465 if (list_start
) list_start
->prev
= node
;
466 node
->next
= list_start
;
471 /* Remove NODE from linked LIST. */
474 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
476 xg_list_node
*list_start
= list
->next
;
477 if (node
== list_start
)
479 list
->next
= node
->next
;
480 if (list
->next
) list
->next
->prev
= 0;
484 node
->prev
->next
= node
->next
;
485 if (node
->next
) node
->next
->prev
= node
->prev
;
489 /* Allocate and return a utf8 version of STR. If STR is already
490 utf8 or NULL, just return STR.
491 If not, a new string is allocated and the caller must free the result
495 get_utf8_string (str
)
498 char *utf8_str
= str
;
500 /* If not UTF-8, try current locale. */
501 if (str
&& !g_utf8_validate (str
, -1, NULL
))
502 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
509 /***********************************************************************
510 General functions for creating widgets, resizing, events, e.t.c.
511 ***********************************************************************/
513 /* Make a geometry string and pass that to GTK. It seems this is the
514 only way to get geometry position right if the user explicitly
515 asked for a position when starting Emacs.
516 F is the frame we shall set geometry for. */
522 if (f
->size_hint_flags
& USPosition
)
524 int left
= f
->left_pos
;
525 int xneg
= f
->size_hint_flags
& XNegative
;
526 int top
= f
->top_pos
;
527 int yneg
= f
->size_hint_flags
& YNegative
;
535 sprintf (geom_str
, "=%dx%d%c%d%c%d",
536 FRAME_PIXEL_WIDTH (f
),
537 FRAME_TOTAL_PIXEL_HEIGHT (f
),
538 (xneg
? '-' : '+'), left
,
539 (yneg
? '-' : '+'), top
);
541 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
543 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
548 /* Resize the outer window of frame F after chainging the height.
549 This happend when the menu bar or the tool bar is added or removed.
550 COLUMNS/ROWS is the size the edit area shall have after the resize. */
553 xg_resize_outer_widget (f
, columns
, rows
)
558 /* If we are not mapped yet, set geometry once again, as window
559 height now have changed. */
560 if (! GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f
)))
563 xg_frame_set_char_size (f
, columns
, rows
);
564 gdk_window_process_all_updates ();
567 /* Function to handle resize of our widgets. Since Emacs has some layouts
568 that does not fit well with GTK standard containers, we do most layout
570 F is the frame to resize.
571 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
574 xg_resize_widgets (f
, pixelwidth
, pixelheight
)
576 int pixelwidth
, pixelheight
;
578 int mbheight
= FRAME_MENUBAR_HEIGHT (f
);
579 int tbheight
= FRAME_TOOLBAR_HEIGHT (f
);
580 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, (pixelheight
581 - mbheight
- tbheight
));
582 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
584 if (FRAME_GTK_WIDGET (f
)
585 && (columns
!= FRAME_COLS (f
)
586 || rows
!= FRAME_LINES (f
)
587 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
588 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
)))
590 struct x_output
*x
= f
->output_data
.x
;
593 all
.y
= mbheight
+ tbheight
;
596 all
.width
= pixelwidth
;
597 all
.height
= pixelheight
- mbheight
- tbheight
;
599 gtk_widget_size_allocate (x
->edit_widget
, &all
);
601 change_frame_size (f
, rows
, columns
, 0, 1, 0);
602 SET_FRAME_GARBAGED (f
);
603 cancel_mouse_face (f
);
608 /* Update our widget size to be COLS/ROWS characters for frame F. */
611 xg_frame_set_char_size (f
, cols
, rows
)
616 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
617 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
620 /* Take into account the size of the scroll bar. Always use the
621 number of columns occupied by the scroll bar here otherwise we
622 might end up with a frame width that is not a multiple of the
623 frame's character width which is bad for vertically split
625 f
->scroll_bar_actual_width
626 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
628 compute_fringe_widths (f
, 0);
630 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
631 after calculating that value. */
632 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
634 /* Must resize our top level widget. Font size may have changed,
635 but not rows/cols. */
636 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
637 pixelwidth
, pixelheight
);
638 xg_resize_widgets (f
, pixelwidth
, pixelheight
);
639 x_wm_set_size_hint (f
, 0, 0);
640 SET_FRAME_GARBAGED (f
);
641 cancel_mouse_face (f
);
644 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
645 Must be done like this, because GtkWidget:s can have "hidden"
646 X Window that aren't accessible.
648 Return 0 if no widget match WDESC. */
651 xg_win_to_widget (dpy
, wdesc
)
656 GtkWidget
*gwdesc
= 0;
660 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
665 event
.any
.window
= gdkwin
;
666 gwdesc
= gtk_get_event_widget (&event
);
673 /* Fill in the GdkColor C so that it represents PIXEL.
674 W is the widget that color will be used for. Used to find colormap. */
677 xg_pix_to_gcolor (w
, pixel
, c
)
682 GdkColormap
*map
= gtk_widget_get_colormap (w
);
683 gdk_colormap_query_color (map
, pixel
, c
);
686 /* Create and set up the GTK widgets for frame F.
687 Return 0 if creation failed, non-zero otherwise. */
690 xg_create_frame_widgets (f
)
703 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
704 xg_set_screen (wtop
, f
);
706 wvbox
= gtk_vbox_new (FALSE
, 0);
707 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
709 if (! wtop
|| ! wvbox
|| ! wfixed
)
711 if (wtop
) gtk_widget_destroy (wtop
);
712 if (wvbox
) gtk_widget_destroy (wvbox
);
713 if (wfixed
) gtk_widget_destroy (wfixed
);
719 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
720 gtk_widget_set_name (wtop
, EMACS_CLASS
);
721 gtk_widget_set_name (wvbox
, "pane");
722 gtk_widget_set_name (wfixed
, SDATA (Vx_resource_name
));
724 /* If this frame has a title or name, set it in the title bar. */
725 if (! NILP (f
->title
)) title
= SDATA (ENCODE_UTF_8 (f
->title
));
726 else if (! NILP (f
->name
)) title
= SDATA (ENCODE_UTF_8 (f
->name
));
728 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
730 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
731 FRAME_GTK_WIDGET (f
) = wfixed
;
732 f
->output_data
.x
->vbox_widget
= wvbox
;
734 gtk_fixed_set_has_window (GTK_FIXED (wfixed
), TRUE
);
736 gtk_widget_set_size_request (wfixed
, FRAME_PIXEL_WIDTH (f
),
737 FRAME_PIXEL_HEIGHT (f
));
739 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
740 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
742 if (FRAME_EXTERNAL_TOOL_BAR (f
))
743 update_frame_tool_bar (f
);
745 /* The tool bar is created but first there are no items in it.
746 This causes it to be zero height. Later items are added, but then
747 the frame is already mapped, so there is a "jumping" resize.
748 This makes geometry handling difficult, for example -0-0 will end
749 up in the wrong place as tool bar height has not been taken into account.
750 So we cheat a bit by setting a height that is what it will have
751 later on when tool bar items are added. */
752 if (FRAME_EXTERNAL_TOOL_BAR (f
) && f
->n_tool_bar_items
== 0)
753 FRAME_TOOLBAR_HEIGHT (f
) = 38;
756 /* We don't want this widget double buffered, because we draw on it
757 with regular X drawing primitives, so from a GTK/GDK point of
758 view, the widget is totally blank. When an expose comes, this
759 will make the widget blank, and then Emacs redraws it. This flickers
760 a lot, so we turn off double buffering. */
761 gtk_widget_set_double_buffered (wfixed
, FALSE
);
763 /* GTK documents says use gtk_window_set_resizable. But then a user
764 can't shrink the window from its starting size. */
765 gtk_window_set_policy (GTK_WINDOW (wtop
), TRUE
, TRUE
, TRUE
);
766 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
767 SDATA (Vx_resource_name
),
768 SDATA (Vx_resource_class
));
770 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
771 GTK is to destroy the widget. We want Emacs to do that instead. */
772 g_signal_connect (G_OBJECT (wtop
), "delete-event",
773 G_CALLBACK (gtk_true
), 0);
775 /* Convert our geometry parameters into a geometry string
777 GTK will itself handle calculating the real position this way. */
780 gtk_widget_add_events (wfixed
,
781 GDK_POINTER_MOTION_MASK
783 | GDK_BUTTON_PRESS_MASK
784 | GDK_BUTTON_RELEASE_MASK
786 | GDK_ENTER_NOTIFY_MASK
787 | GDK_LEAVE_NOTIFY_MASK
788 | GDK_FOCUS_CHANGE_MASK
790 | GDK_VISIBILITY_NOTIFY_MASK
);
792 /* Must realize the windows so the X window gets created. It is used
793 by callers of this function. */
794 gtk_widget_realize (wfixed
);
795 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
797 /* Since GTK clears its window by filling with the background color,
798 we must keep X and GTK background in sync. */
799 xg_pix_to_gcolor (wfixed
, f
->output_data
.x
->background_pixel
, &bg
);
800 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
802 /* Also, do not let any background pixmap to be set, this looks very
803 bad as Emacs overwrites the background pixmap with its own idea
804 of background color. */
805 style
= gtk_widget_get_modifier_style (wfixed
);
807 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
808 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
809 gtk_widget_modify_style (wfixed
, style
);
811 /* GTK does not set any border, and they look bad with GTK. */
813 f
->internal_border_width
= 0;
820 /* Set the normal size hints for the window manager, for frame F.
821 FLAGS is the flags word to use--or 0 meaning preserve the flags
822 that the window now has.
823 If USER_POSITION is nonzero, we set the User Position
824 flag (this is useful when FLAGS is 0). */
827 x_wm_set_size_hint (f
, flags
, user_position
)
832 if (FRAME_GTK_OUTER_WIDGET (f
))
834 /* Must use GTK routines here, otherwise GTK resets the size hints
835 to its own defaults. */
836 GdkGeometry size_hints
;
838 int base_width
, base_height
;
839 int min_rows
= 0, min_cols
= 0;
840 int win_gravity
= f
->win_gravity
;
844 memset (&size_hints
, 0, sizeof (size_hints
));
845 f
->output_data
.x
->size_hints
= size_hints
;
846 f
->output_data
.x
->hint_flags
= hint_flags
;
849 flags
= f
->size_hint_flags
;
851 size_hints
= f
->output_data
.x
->size_hints
;
852 hint_flags
= f
->output_data
.x
->hint_flags
;
854 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
855 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
856 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
858 hint_flags
|= GDK_HINT_BASE_SIZE
;
859 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
860 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
861 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
863 check_frame_size (f
, &min_rows
, &min_cols
);
865 size_hints
.base_width
= base_width
;
866 size_hints
.base_height
= base_height
;
867 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
868 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
871 /* These currently have a one to one mapping with the X values, but I
872 don't think we should rely on that. */
873 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
874 size_hints
.win_gravity
= 0;
875 if (win_gravity
== NorthWestGravity
)
876 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
877 else if (win_gravity
== NorthGravity
)
878 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
879 else if (win_gravity
== NorthEastGravity
)
880 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
881 else if (win_gravity
== WestGravity
)
882 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
883 else if (win_gravity
== CenterGravity
)
884 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
885 else if (win_gravity
== EastGravity
)
886 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
887 else if (win_gravity
== SouthWestGravity
)
888 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
889 else if (win_gravity
== SouthGravity
)
890 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
891 else if (win_gravity
== SouthEastGravity
)
892 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
893 else if (win_gravity
== StaticGravity
)
894 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
896 if (flags
& PPosition
) hint_flags
|= GDK_HINT_POS
;
897 if (flags
& USPosition
) hint_flags
|= GDK_HINT_USER_POS
;
898 if (flags
& USSize
) hint_flags
|= GDK_HINT_USER_SIZE
;
902 hint_flags
&= ~GDK_HINT_POS
;
903 hint_flags
|= GDK_HINT_USER_POS
;
908 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
909 FRAME_GTK_OUTER_WIDGET (f
),
913 f
->output_data
.x
->size_hints
= size_hints
;
914 f
->output_data
.x
->hint_flags
= hint_flags
;
919 /* Change background color of a frame.
920 Since GTK uses the background colour to clear the window, we must
921 keep the GTK and X colors in sync.
922 F is the frame to change,
923 BG is the pixel value to change to. */
926 xg_set_background_color (f
, bg
)
930 if (FRAME_GTK_WIDGET (f
))
935 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
936 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
943 /***********************************************************************
945 ***********************************************************************/
946 /* Return the dialog title to use for a dialog of type KEY.
947 This is the encoding used by lwlib. We use the same for GTK. */
950 get_dialog_title (char key
)
960 title
= "Information";
979 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
980 the dialog, but return TRUE so the event does not propagate further
981 in GTK. This prevents GTK from destroying the dialog widget automatically
982 and we can always destrou the widget manually, regardles of how
983 it was popped down (button press or WM_DELETE_WINDOW).
984 W is the dialog widget.
985 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
986 user_data is NULL (not used).
988 Returns TRUE to end propagation of event. */
991 dialog_delete_callback (w
, event
, user_data
)
996 gtk_widget_unmap (w
);
1000 /* Create a popup dialog window. See also xg_create_widget below.
1001 WV is a widget_value describing the dialog.
1002 SELECT_CB is the callback to use when a button has been pressed.
1003 DEACTIVATE_CB is the callback to use when the dialog pops down.
1005 Returns the GTK dialog widget. */
1008 create_dialog (wv
, select_cb
, deactivate_cb
)
1010 GCallback select_cb
;
1011 GCallback deactivate_cb
;
1013 char *title
= get_dialog_title (wv
->name
[0]);
1014 int total_buttons
= wv
->name
[1] - '0';
1015 int right_buttons
= wv
->name
[4] - '0';
1018 int button_spacing
= 10;
1019 GtkWidget
*wdialog
= gtk_dialog_new ();
1023 GtkWidget
*whbox_up
;
1024 GtkWidget
*whbox_down
;
1026 /* If the number of buttons is greater than 4, make two rows of buttons
1027 instead. This looks better. */
1028 int make_two_rows
= total_buttons
> 4;
1030 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1031 left_buttons
= total_buttons
- right_buttons
;
1033 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1034 gtk_widget_set_name (wdialog
, "emacs-dialog");
1036 cur_box
= GTK_BOX (GTK_DIALOG (wdialog
)->action_area
);
1040 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1041 whbox_up
= gtk_hbox_new (FALSE
, 0);
1042 whbox_down
= gtk_hbox_new (FALSE
, 0);
1044 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1045 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1046 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1048 cur_box
= GTK_BOX (whbox_up
);
1051 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1052 G_CALLBACK (dialog_delete_callback
), 0);
1056 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1057 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1060 for (item
= wv
->contents
; item
; item
= item
->next
)
1062 char *utf8_label
= get_utf8_string (item
->value
);
1066 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1068 /* This is the text part of the dialog. */
1069 w
= gtk_label_new (utf8_label
);
1070 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1073 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
), w
,
1075 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1077 /* Try to make dialog look better. Must realize first so
1078 the widget can calculate the size it needs. */
1079 gtk_widget_realize (w
);
1080 gtk_widget_size_request (w
, &req
);
1081 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1083 if (item
->value
&& strlen (item
->value
) > 0)
1084 button_spacing
= 2*req
.width
/strlen (item
->value
);
1088 /* This is one button to add to the dialog. */
1089 w
= gtk_button_new_with_label (utf8_label
);
1090 if (! item
->enabled
)
1091 gtk_widget_set_sensitive (w
, FALSE
);
1093 g_signal_connect (G_OBJECT (w
), "clicked",
1094 select_cb
, item
->call_data
);
1096 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1097 if (++button_nr
== left_buttons
)
1100 cur_box
= GTK_BOX (whbox_down
);
1102 gtk_box_pack_start (cur_box
,
1109 if (utf8_label
&& utf8_label
!= item
->value
)
1110 g_free (utf8_label
);
1118 /***********************************************************************
1119 File dialog functions
1120 ***********************************************************************/
1121 /* Function that is called when the file dialog pops down.
1122 W is the dialog widget, RESPONSE is the response code.
1123 USER_DATA is what we passed in to g_signal_connect (pointer to int). */
1126 xg_file_response_cb (w
,
1133 int *ptr
= (int *) user_data
;
1138 /* Destroy the dialog. This makes it pop down. */
1141 pop_down_file_dialog (arg
)
1144 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1146 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1151 typedef char * (*xg_get_file_func
) P_ ((GtkWidget
*));
1153 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1155 /* Return the selected file for file chooser dialog W.
1156 The returned string must be free:d. */
1159 xg_get_file_name_from_chooser (w
)
1162 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1165 /* Read a file name from the user using a file chooser dialog.
1166 F is the current frame.
1167 PROMPT is a prompt to show to the user. May not be NULL.
1168 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1169 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1170 file. *FUNC is set to a function that can be used to retrieve the
1171 selected file name from the returned widget.
1173 Returns the created widget. */
1176 xg_get_file_with_chooser (f
, prompt
, default_filename
,
1177 mustmatch_p
, only_dir_p
, func
)
1180 char *default_filename
;
1181 int mustmatch_p
, only_dir_p
;
1182 xg_get_file_func
*func
;
1185 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1186 GtkFileChooserAction action
= (mustmatch_p
?
1187 GTK_FILE_CHOOSER_ACTION_OPEN
:
1188 GTK_FILE_CHOOSER_ACTION_SAVE
);
1191 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1193 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1194 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1195 (mustmatch_p
|| only_dir_p
?
1196 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1199 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1201 if (default_filename
)
1204 struct gcpro gcpro1
;
1207 file
= build_string (default_filename
);
1209 /* File chooser does not understand ~/... in the file name. It must be
1210 an absolute name starting with /. */
1211 if (default_filename
[0] != '/')
1212 file
= Fexpand_file_name (file
, Qnil
);
1214 default_filename
= SDATA (file
);
1215 if (Ffile_directory_p (file
))
1216 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1219 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1225 *func
= xg_get_file_name_from_chooser
;
1228 #endif /* HAVE_GTK_FILE_CHOOSER_DIALOG_NEW */
1230 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1232 /* Return the selected file for file selector dialog W.
1233 The returned string must be free:d. */
1236 xg_get_file_name_from_selector (w
)
1239 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1240 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1243 /* Create a file selection dialog.
1244 F is the current frame.
1245 PROMPT is a prompt to show to the user. May not be NULL.
1246 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1247 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1248 file. *FUNC is set to a function that can be used to retrieve the
1249 selected file name from the returned widget.
1251 Returns the created widget. */
1254 xg_get_file_with_selection (f
, prompt
, default_filename
,
1255 mustmatch_p
, only_dir_p
, func
)
1258 char *default_filename
;
1259 int mustmatch_p
, only_dir_p
;
1260 xg_get_file_func
*func
;
1263 GtkFileSelection
*filesel
;
1265 filewin
= gtk_file_selection_new (prompt
);
1266 filesel
= GTK_FILE_SELECTION (filewin
);
1268 if (default_filename
)
1269 gtk_file_selection_set_filename (filesel
, default_filename
);
1273 /* The selection_entry part of filesel is not documented. */
1274 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1275 gtk_file_selection_hide_fileop_buttons (filesel
);
1278 *func
= xg_get_file_name_from_selector
;
1282 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1284 /* Read a file name from the user using a file dialog, either the old
1285 file selection dialog, or the new file chooser dialog. Which to use
1286 depends on what the GTK version used has, and what the value of
1287 gtk-use-old-file-dialog.
1288 F is the current frame.
1289 PROMPT is a prompt to show to the user. May not be NULL.
1290 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1291 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1294 Returns a file name or NULL if no file was selected.
1295 The returned string must be freed by the caller. */
1298 xg_get_file_name (f
, prompt
, default_filename
, mustmatch_p
, only_dir_p
)
1301 char *default_filename
;
1302 int mustmatch_p
, only_dir_p
;
1305 int count
= SPECPDL_INDEX ();
1307 int filesel_done
= 0;
1308 xg_get_file_func func
;
1309 extern int x_use_old_gtk_file_dialog
;
1311 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1312 /* I really don't know why this is needed, but without this the GLIBC add on
1313 library linuxthreads hangs when the Gnome file chooser backend creates
1315 sigblock (sigmask (__SIGRTMIN
));
1316 #endif /* HAVE_GTK_AND_PTHREAD */
1318 #ifdef HAVE_GTK_FILE_BOTH
1320 if (x_use_old_gtk_file_dialog
)
1321 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1322 mustmatch_p
, only_dir_p
, &func
);
1324 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1325 mustmatch_p
, only_dir_p
, &func
);
1327 #else /* not HAVE_GTK_FILE_BOTH */
1329 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1330 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1331 mustmatch_p
, only_dir_p
, &func
);
1333 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1334 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1335 mustmatch_p
, only_dir_p
, &func
);
1338 #endif /* HAVE_GTK_FILE_BOTH */
1340 xg_set_screen (w
, f
);
1341 gtk_widget_set_name (w
, "emacs-filedialog");
1342 gtk_window_set_transient_for (GTK_WINDOW (w
),
1343 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1344 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1345 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1347 g_signal_connect (G_OBJECT (w
),
1349 G_CALLBACK (xg_file_response_cb
),
1352 /* Don't destroy the widget if closed by the window manager close button. */
1353 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1355 gtk_widget_show (w
);
1357 record_unwind_protect (pop_down_file_dialog
, make_save_value (w
, 0));
1358 while (! filesel_done
)
1360 x_menu_wait_for_event (0);
1361 gtk_main_iteration ();
1364 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1365 sigunblock (sigmask (__SIGRTMIN
));
1368 if (filesel_done
== GTK_RESPONSE_OK
)
1371 unbind_to (count
, Qnil
);
1377 /***********************************************************************
1379 ***********************************************************************/
1381 /* The name of menu items that can be used for citomization. Since GTK
1382 RC files are very crude and primitive, we have to set this on all
1383 menu item names so a user can easily cutomize menu items. */
1385 #define MENU_ITEM_NAME "emacs-menuitem"
1388 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1389 during GC. The next member points to the items. */
1390 static xg_list_node xg_menu_cb_list
;
1392 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1393 during GC. The next member points to the items. */
1394 static xg_list_node xg_menu_item_cb_list
;
1396 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1397 F is the frame CL_DATA will be initialized for.
1398 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1400 The menu bar and all sub menus under the menu bar in a frame
1401 share the same structure, hence the reference count.
1403 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1404 allocated xg_menu_cb_data if CL_DATA is NULL. */
1406 static xg_menu_cb_data
*
1407 make_cl_data (cl_data
, f
, highlight_cb
)
1408 xg_menu_cb_data
*cl_data
;
1410 GCallback highlight_cb
;
1414 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1416 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1417 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1418 cl_data
->highlight_cb
= highlight_cb
;
1419 cl_data
->ref_count
= 0;
1421 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1424 cl_data
->ref_count
++;
1429 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1430 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1432 When the menu bar is updated, menu items may have been added and/or
1433 removed, so menu_bar_vector and menu_bar_items_used change. We must
1434 then update CL_DATA since it is used to determine which menu
1435 item that is invoked in the menu.
1436 HIGHLIGHT_CB could change, there is no check that the same
1437 function is given when modifying a menu bar as was given when
1438 creating the menu bar. */
1441 update_cl_data (cl_data
, f
, highlight_cb
)
1442 xg_menu_cb_data
*cl_data
;
1444 GCallback highlight_cb
;
1449 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1450 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1451 cl_data
->highlight_cb
= highlight_cb
;
1455 /* Decrease reference count for CL_DATA.
1456 If reference count is zero, free CL_DATA. */
1459 unref_cl_data (cl_data
)
1460 xg_menu_cb_data
*cl_data
;
1462 if (cl_data
&& cl_data
->ref_count
> 0)
1464 cl_data
->ref_count
--;
1465 if (cl_data
->ref_count
== 0)
1467 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1473 /* Function that marks all lisp data during GC. */
1480 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1481 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1483 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1485 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1487 if (! NILP (cb_data
->help
))
1488 mark_object (cb_data
->help
);
1493 /* Callback called when a menu item is destroyed. Used to free data.
1494 W is the widget that is being destroyed (not used).
1495 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1498 menuitem_destroy_callback (w
, client_data
)
1500 gpointer client_data
;
1504 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1505 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1510 /* Callback called when the pointer enters/leaves a menu item.
1512 EVENT is either an enter event or leave event.
1513 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W.
1515 Returns FALSE to tell GTK to keep processing this event. */
1518 menuitem_highlight_callback (w
, event
, client_data
)
1520 GdkEventCrossing
*event
;
1521 gpointer client_data
;
1525 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1526 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : client_data
;
1528 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1530 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1531 (*func
) (w
, call_data
);
1538 /* Callback called when a menu is destroyed. Used to free data.
1539 W is the widget that is being destroyed (not used).
1540 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1543 menu_destroy_callback (w
, client_data
)
1545 gpointer client_data
;
1547 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1550 /* Callback called when a menu does a grab or ungrab. That means the
1551 menu has been activated or deactivated.
1552 Used to start a timer so the small timeout the menus in GTK uses before
1553 popping down a menu is seen by Emacs (see xg_process_timeouts above).
1554 W is the widget that does the grab (not used).
1555 UNGRAB_P is TRUE if this is an ungrab, FALSE if it is a grab.
1556 CLIENT_DATA is NULL (not used). */
1559 menu_grab_callback (GtkWidget
*widget
,
1561 gpointer client_data
)
1563 /* Keep track of total number of grabs. */
1566 if (ungrab_p
) cnt
--;
1569 if (cnt
> 0 && ! xg_timer
) xg_start_timer ();
1570 else if (cnt
== 0 && xg_timer
) xg_stop_timer ();
1573 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1574 must be non-NULL) and can be inserted into a menu item.
1576 Returns the GtkHBox. */
1579 make_widget_for_menu_item (utf8_label
, utf8_key
)
1587 wbox
= gtk_hbox_new (FALSE
, 0);
1588 wlbl
= gtk_label_new (utf8_label
);
1589 wkey
= gtk_label_new (utf8_key
);
1591 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1592 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1594 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1595 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1597 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1598 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1599 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1604 /* Make and return a menu item widget with the key to the right.
1605 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1606 UTF8_KEY is the text representing the key binding.
1607 ITEM is the widget_value describing the menu item.
1609 GROUP is an in/out parameter. If the menu item to be created is not
1610 part of any radio menu group, *GROUP contains NULL on entry and exit.
1611 If the menu item to be created is part of a radio menu group, on entry
1612 *GROUP contains the group to use, or NULL if this is the first item
1613 in the group. On exit, *GROUP contains the radio item group.
1615 Unfortunately, keys don't line up as nicely as in Motif,
1616 but the MacOS X version doesn't either, so I guess that is OK. */
1619 make_menu_item (utf8_label
, utf8_key
, item
, group
)
1626 GtkWidget
*wtoadd
= 0;
1628 /* It has been observed that some menu items have a NULL name field.
1629 This will lead to this function being called with a NULL utf8_label.
1630 GTK crashes on that so we set a blank label. Why there is a NULL
1631 name remains to be investigated. */
1632 if (! utf8_label
) utf8_label
= " ";
1635 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1637 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1640 if (utf8_key
) w
= gtk_check_menu_item_new ();
1641 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1642 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1644 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1646 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1647 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1648 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1650 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1655 if (utf8_key
) w
= gtk_menu_item_new ();
1656 else w
= gtk_menu_item_new_with_label (utf8_label
);
1659 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1660 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1665 /* Return non-zero if LABEL specifies a separator (GTK only has one
1669 xg_separator_p (char *label
)
1671 if (! label
) return 0;
1672 else if (strlen (label
) > 3
1673 && strncmp (label
, "--", 2) == 0
1676 static char* separator_names
[] = {
1681 "single-dashed-line",
1682 "double-dashed-line",
1684 "shadow-etched-out",
1685 "shadow-etched-in-dash",
1686 "shadow-etched-out-dash",
1687 "shadow-double-etched-in",
1688 "shadow-double-etched-out",
1689 "shadow-double-etched-in-dash",
1690 "shadow-double-etched-out-dash",
1697 for (i
= 0; separator_names
[i
]; ++i
)
1698 if (strcmp (label
, separator_names
[i
]) == 0)
1703 /* Old-style separator, maybe. It's a separator if it contains
1705 while (*label
== '-')
1707 if (*label
== 0) return 1;
1713 static int xg_detached_menus
;
1715 /* Returns non-zero if there are detached menus. */
1718 xg_have_tear_offs ()
1720 return xg_detached_menus
> 0;
1723 /* Callback invoked when a detached menu window is removed. Here we
1724 decrease the xg_detached_menus count.
1725 WIDGET is the top level window that is removed (the parent of the menu).
1726 CLIENT_DATA is not used. */
1729 tearoff_remove (widget
, client_data
)
1731 gpointer client_data
;
1733 if (xg_detached_menus
> 0) --xg_detached_menus
;
1736 /* Callback invoked when a menu is detached. It increases the
1737 xg_detached_menus count.
1738 WIDGET is the GtkTearoffMenuItem.
1739 CLIENT_DATA is not used. */
1742 tearoff_activate (widget
, client_data
)
1744 gpointer client_data
;
1746 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
1747 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
1749 ++xg_detached_menus
;
1750 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
1752 G_CALLBACK (tearoff_remove
), 0);
1757 /* Create a menu item widget, and connect the callbacks.
1758 ITEM decribes the menu item.
1759 F is the frame the created menu belongs to.
1760 SELECT_CB is the callback to use when a menu item is selected.
1761 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1762 CL_DATA points to the callback data to be used for this menu.
1763 GROUP is an in/out parameter. If the menu item to be created is not
1764 part of any radio menu group, *GROUP contains NULL on entry and exit.
1765 If the menu item to be created is part of a radio menu group, on entry
1766 *GROUP contains the group to use, or NULL if this is the first item
1767 in the group. On exit, *GROUP contains the radio item group.
1769 Returns the created GtkWidget. */
1772 xg_create_one_menuitem (item
, f
, select_cb
, highlight_cb
, cl_data
, group
)
1775 GCallback select_cb
;
1776 GCallback highlight_cb
;
1777 xg_menu_cb_data
*cl_data
;
1783 xg_menu_item_cb_data
*cb_data
;
1785 utf8_label
= get_utf8_string (item
->name
);
1786 utf8_key
= get_utf8_string (item
->key
);
1788 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
1790 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
1791 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
1793 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
1795 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
1797 cb_data
->unhighlight_id
= cb_data
->highlight_id
= cb_data
->select_id
= 0;
1798 cb_data
->help
= item
->help
;
1799 cb_data
->cl_data
= cl_data
;
1800 cb_data
->call_data
= item
->call_data
;
1802 g_signal_connect (G_OBJECT (w
),
1804 G_CALLBACK (menuitem_destroy_callback
),
1807 /* Put cb_data in widget, so we can get at it when modifying menubar */
1808 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
1810 /* final item, not a submenu */
1811 if (item
->call_data
&& ! item
->contents
)
1815 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
1818 if (! NILP (item
->help
) && highlight_cb
)
1820 /* We use enter/leave notify instead of select/deselect because
1821 select/deselect doesn't go well with detached menus. */
1822 cb_data
->highlight_id
1823 = g_signal_connect (G_OBJECT (w
),
1824 "enter-notify-event",
1825 G_CALLBACK (menuitem_highlight_callback
),
1827 cb_data
->unhighlight_id
1828 = g_signal_connect (G_OBJECT (w
),
1829 "leave-notify-event",
1830 G_CALLBACK (menuitem_highlight_callback
),
1837 static GtkWidget
*create_menus
P_ ((widget_value
*, FRAME_PTR
, GCallback
,
1838 GCallback
, GCallback
, int, int, int,
1839 GtkWidget
*, xg_menu_cb_data
*, char *));
1841 /* Create a full menu tree specified by DATA.
1842 F is the frame the created menu belongs to.
1843 SELECT_CB is the callback to use when a menu item is selected.
1844 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
1845 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1846 POP_UP_P is non-zero if we shall create a popup menu.
1847 MENU_BAR_P is non-zero if we shall create a menu bar.
1848 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
1849 if MENU_BAR_P is non-zero.
1850 TOPMENU is the topmost GtkWidget that others shall be placed under.
1851 It may be NULL, in that case we create the appropriate widget
1852 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
1853 CL_DATA is the callback data we shall use for this menu, or NULL
1854 if we haven't set the first callback yet.
1855 NAME is the name to give to the top level menu if this function
1856 creates it. May be NULL to not set any name.
1858 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
1861 This function calls itself to create submenus. */
1864 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
1865 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
1868 GCallback select_cb
;
1869 GCallback deactivate_cb
;
1870 GCallback highlight_cb
;
1875 xg_menu_cb_data
*cl_data
;
1879 GtkWidget
*wmenu
= topmenu
;
1880 GSList
*group
= NULL
;
1886 wmenu
= gtk_menu_new ();
1887 xg_set_screen (wmenu
, f
);
1889 else wmenu
= gtk_menu_bar_new ();
1891 /* Put cl_data on the top menu for easier access. */
1892 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
1893 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
1894 g_signal_connect (G_OBJECT (wmenu
), "destroy",
1895 G_CALLBACK (menu_destroy_callback
), cl_data
);
1898 gtk_widget_set_name (wmenu
, name
);
1901 g_signal_connect (G_OBJECT (wmenu
),
1902 "selection-done", deactivate_cb
, 0);
1904 g_signal_connect (G_OBJECT (wmenu
),
1905 "grab-notify", G_CALLBACK (menu_grab_callback
), 0);
1908 if (! menu_bar_p
&& add_tearoff_p
)
1910 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
1911 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
1913 g_signal_connect (G_OBJECT (tearoff
), "activate",
1914 G_CALLBACK (tearoff_activate
), 0);
1917 for (item
= data
; item
; item
= item
->next
)
1921 if (pop_up_p
&& !item
->contents
&& !item
->call_data
1922 && !xg_separator_p (item
->name
))
1925 /* A title for a popup. We do the same as GTK does when
1926 creating titles, but it does not look good. */
1928 utf8_label
= get_utf8_string (item
->name
);
1930 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
1931 w
= gtk_menu_item_new_with_label (utf8_label
);
1932 gtk_widget_set_sensitive (w
, FALSE
);
1933 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
1935 else if (xg_separator_p (item
->name
))
1938 /* GTK only have one separator type. */
1939 w
= gtk_separator_menu_item_new ();
1943 w
= xg_create_one_menuitem (item
,
1945 item
->contents
? 0 : select_cb
,
1952 GtkWidget
*submenu
= create_menus (item
->contents
,
1963 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
1967 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
1968 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
1974 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
1975 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
1976 with some text and buttons.
1977 F is the frame the created item belongs to.
1978 NAME is the name to use for the top widget.
1979 VAL is a widget_value structure describing items to be created.
1980 SELECT_CB is the callback to use when a menu item is selected or
1981 a dialog button is pressed.
1982 DEACTIVATE_CB is the callback to use when an item is deactivated.
1983 For a menu, when a sub menu is not shown anymore, for a dialog it is
1984 called when the dialog is popped down.
1985 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1987 Returns the widget created. */
1990 xg_create_widget (type
, name
, f
, val
,
1991 select_cb
, deactivate_cb
, highlight_cb
)
1996 GCallback select_cb
;
1997 GCallback deactivate_cb
;
1998 GCallback highlight_cb
;
2001 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2002 int pop_up_p
= strcmp (type
, "popup") == 0;
2004 if (strcmp (type
, "dialog") == 0)
2006 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2007 xg_set_screen (w
, f
);
2008 gtk_window_set_transient_for (GTK_WINDOW (w
),
2009 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2010 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2011 gtk_widget_set_name (w
, "emacs-dialog");
2012 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2014 else if (menu_bar_p
|| pop_up_p
)
2016 w
= create_menus (val
->contents
,
2028 /* Set the cursor to an arrow for popup menus when they are mapped.
2029 This is done by default for menu bar menus. */
2032 /* Must realize so the GdkWindow inside the widget is created. */
2033 gtk_widget_realize (w
);
2034 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2039 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2046 /* Return the label for menu item WITEM. */
2049 xg_get_menu_item_label (witem
)
2052 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2053 return gtk_label_get_label (wlabel
);
2056 /* Return non-zero if the menu item WITEM has the text LABEL. */
2059 xg_item_label_same_p (witem
, label
)
2064 char *utf8_label
= get_utf8_string (label
);
2065 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2067 if (! old_label
&& ! utf8_label
)
2069 else if (old_label
&& utf8_label
)
2070 is_same
= strcmp (utf8_label
, old_label
) == 0;
2072 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2077 /* Destroy widgets in LIST. */
2080 xg_destroy_widgets (list
)
2085 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2087 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2089 /* Destroying the widget will remove it from the container it is in. */
2090 gtk_widget_destroy (w
);
2094 /* Update the top level names in MENUBAR (i.e. not submenus).
2095 F is the frame the menu bar belongs to.
2096 *LIST is a list with the current menu bar names (menu item widgets).
2097 ITER is the item within *LIST that shall be updated.
2098 POS is the numerical position, starting at 0, of ITER in *LIST.
2099 VAL describes what the menu bar shall look like after the update.
2100 SELECT_CB is the callback to use when a menu item is selected.
2101 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2102 CL_DATA points to the callback data to be used for this menu bar.
2104 This function calls itself to walk through the menu bar names. */
2107 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2108 select_cb
, highlight_cb
, cl_data
)
2115 GCallback select_cb
;
2116 GCallback highlight_cb
;
2117 xg_menu_cb_data
*cl_data
;
2119 if (! iter
&& ! val
)
2121 else if (iter
&& ! val
)
2123 /* Item(s) have been removed. Remove all remaining items. */
2124 xg_destroy_widgets (iter
);
2130 else if (! iter
&& val
)
2132 /* Item(s) added. Add all new items in one call. */
2133 create_menus (val
, f
, select_cb
, 0, highlight_cb
,
2134 0, 1, 0, menubar
, cl_data
, 0);
2140 /* Below this neither iter or val is NULL */
2141 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2143 /* This item is still the same, check next item. */
2145 iter
= g_list_next (iter
);
2148 else /* This item is changed. */
2150 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2151 GtkMenuItem
*witem2
= 0;
2152 int val_in_menubar
= 0;
2153 int iter_in_new_menubar
= 0;
2157 /* See if the changed entry (val) is present later in the menu bar */
2159 iter2
&& ! val_in_menubar
;
2160 iter2
= g_list_next (iter2
))
2162 witem2
= GTK_MENU_ITEM (iter2
->data
);
2163 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2166 /* See if the current entry (iter) is present later in the
2167 specification for the new menu bar. */
2168 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2169 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2171 if (val_in_menubar
&& ! iter_in_new_menubar
)
2175 /* This corresponds to:
2180 gtk_widget_ref (GTK_WIDGET (witem
));
2181 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2182 gtk_widget_destroy (GTK_WIDGET (witem
));
2184 /* Must get new list since the old changed. */
2185 g_list_free (*list
);
2186 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2187 while (nr
-- > 0) iter
= g_list_next (iter
);
2189 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2191 /* This corresponds to:
2194 Rename B to X. This might seem to be a strange thing to do,
2195 since if there is a menu under B it will be totally wrong for X.
2196 But consider editing a C file. Then there is a C-mode menu
2197 (corresponds to B above).
2198 If then doing C-x C-f the minibuf menu (X above) replaces the
2199 C-mode menu. When returning from the minibuffer, we get
2200 back the C-mode menu. Thus we do:
2201 Rename B to X (C-mode to minibuf menu)
2202 Rename X to B (minibuf to C-mode menu).
2203 If the X menu hasn't been invoked, the menu under B
2204 is up to date when leaving the minibuffer. */
2205 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2206 char *utf8_label
= get_utf8_string (val
->name
);
2207 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2209 gtk_label_set_text (wlabel
, utf8_label
);
2211 /* If this item has a submenu that has been detached, change
2212 the title in the WM decorations also. */
2213 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2214 /* Set the title of the detached window. */
2215 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2217 iter
= g_list_next (iter
);
2221 else if (! val_in_menubar
&& iter_in_new_menubar
)
2223 /* This corresponds to:
2230 GtkWidget
*w
= xg_create_one_menuitem (val
,
2237 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2238 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2240 g_list_free (*list
);
2241 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2242 while (nr
-- > 0) iter
= g_list_next (iter
);
2243 iter
= g_list_next (iter
);
2247 else /* if (val_in_menubar && iter_in_new_menubar) */
2250 /* This corresponds to:
2255 gtk_widget_ref (GTK_WIDGET (witem2
));
2256 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2257 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2258 GTK_WIDGET (witem2
), pos
);
2259 gtk_widget_unref (GTK_WIDGET (witem2
));
2261 g_list_free (*list
);
2262 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2263 while (nr
-- > 0) iter
= g_list_next (iter
);
2269 /* Update the rest of the menu bar. */
2270 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2271 select_cb
, highlight_cb
, cl_data
);
2274 /* Update the menu item W so it corresponds to VAL.
2275 SELECT_CB is the callback to use when a menu item is selected.
2276 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2277 CL_DATA is the data to set in the widget for menu invokation. */
2280 xg_update_menu_item (val
, w
, select_cb
, highlight_cb
, cl_data
)
2283 GCallback select_cb
;
2284 GCallback highlight_cb
;
2285 xg_menu_cb_data
*cl_data
;
2292 const char *old_label
= 0;
2293 const char *old_key
= 0;
2294 xg_menu_item_cb_data
*cb_data
;
2296 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2297 utf8_label
= get_utf8_string (val
->name
);
2298 utf8_key
= get_utf8_string (val
->key
);
2300 /* See if W is a menu item with a key. See make_menu_item above. */
2301 if (GTK_IS_HBOX (wchild
))
2303 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2305 wlbl
= GTK_LABEL (list
->data
);
2306 wkey
= GTK_LABEL (list
->next
->data
);
2311 /* Remove the key and keep just the label. */
2312 gtk_widget_ref (GTK_WIDGET (wlbl
));
2313 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2314 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2319 else /* Just a label. */
2321 wlbl
= GTK_LABEL (wchild
);
2323 /* Check if there is now a key. */
2326 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2327 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2329 wlbl
= GTK_LABEL (list
->data
);
2330 wkey
= GTK_LABEL (list
->next
->data
);
2333 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2334 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2339 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2340 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2342 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2343 gtk_label_set_text (wkey
, utf8_key
);
2345 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2346 gtk_label_set_text (wlbl
, utf8_label
);
2348 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2349 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2351 if (! val
->enabled
&& GTK_WIDGET_SENSITIVE (w
))
2352 gtk_widget_set_sensitive (w
, FALSE
);
2353 else if (val
->enabled
&& ! GTK_WIDGET_SENSITIVE (w
))
2354 gtk_widget_set_sensitive (w
, TRUE
);
2356 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2360 cb_data
->call_data
= val
->call_data
;
2361 cb_data
->help
= val
->help
;
2362 cb_data
->cl_data
= cl_data
;
2364 /* We assume the callback functions don't change. */
2365 if (val
->call_data
&& ! val
->contents
)
2367 /* This item shall have a select callback. */
2368 if (! cb_data
->select_id
)
2370 = g_signal_connect (G_OBJECT (w
), "activate",
2371 select_cb
, cb_data
);
2373 else if (cb_data
->select_id
)
2375 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2376 cb_data
->select_id
= 0;
2379 if (NILP (cb_data
->help
))
2381 /* Shall not have help. Remove if any existed previously. */
2382 if (cb_data
->highlight_id
)
2384 g_signal_handler_disconnect (G_OBJECT (w
),
2385 cb_data
->highlight_id
);
2386 cb_data
->highlight_id
= 0;
2388 if (cb_data
->unhighlight_id
)
2390 g_signal_handler_disconnect (G_OBJECT (w
),
2391 cb_data
->unhighlight_id
);
2392 cb_data
->unhighlight_id
= 0;
2395 else if (! cb_data
->highlight_id
&& highlight_cb
)
2397 /* Have help now, but didn't previously. Add callback. */
2398 cb_data
->highlight_id
2399 = g_signal_connect (G_OBJECT (w
),
2400 "enter-notify-event",
2401 G_CALLBACK (menuitem_highlight_callback
),
2403 cb_data
->unhighlight_id
2404 = g_signal_connect (G_OBJECT (w
),
2405 "leave-notify-event",
2406 G_CALLBACK (menuitem_highlight_callback
),
2412 /* Update the toggle menu item W so it corresponds to VAL. */
2415 xg_update_toggle_item (val
, w
)
2419 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2422 /* Update the radio menu item W so it corresponds to VAL. */
2425 xg_update_radio_item (val
, w
)
2429 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2432 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2433 SUBMENU may be NULL, in that case a new menu is created.
2434 F is the frame the menu bar belongs to.
2435 VAL describes the contents of the menu bar.
2436 SELECT_CB is the callback to use when a menu item is selected.
2437 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2438 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2439 CL_DATA is the call back data to use for any newly created items.
2441 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2445 xg_update_submenu (submenu
, f
, val
,
2446 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2450 GCallback select_cb
;
2451 GCallback deactivate_cb
;
2452 GCallback highlight_cb
;
2453 xg_menu_cb_data
*cl_data
;
2455 GtkWidget
*newsub
= submenu
;
2459 int has_tearoff_p
= 0;
2460 GList
*first_radio
= 0;
2463 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2465 for (cur
= val
, iter
= list
;
2467 iter
= g_list_next (iter
), cur
= cur
->next
)
2469 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2471 /* Skip tearoff items, they have no counterpart in val. */
2472 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2475 iter
= g_list_next (iter
);
2476 if (iter
) w
= GTK_WIDGET (iter
->data
);
2480 /* Remember first radio button in a group. If we get a mismatch in
2481 a radio group we must rebuild the whole group so that the connections
2482 in GTK becomes correct. */
2483 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2485 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2486 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2489 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2491 if (! xg_separator_p (cur
->name
))
2494 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2496 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2498 xg_update_toggle_item (cur
, w
);
2499 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2501 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2503 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2505 xg_update_radio_item (cur
, w
);
2506 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2508 else if (GTK_IS_MENU_ITEM (w
))
2510 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2513 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2514 xg_separator_p (cur
->name
))
2517 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2519 sub
= gtk_menu_item_get_submenu (witem
);
2520 if (sub
&& ! cur
->contents
)
2522 /* Not a submenu anymore. */
2523 gtk_widget_ref (sub
);
2524 gtk_menu_item_remove_submenu (witem
);
2525 gtk_widget_destroy (sub
);
2527 else if (cur
->contents
)
2531 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2532 select_cb
, deactivate_cb
,
2533 highlight_cb
, cl_data
);
2535 /* If this item just became a submenu, we must set it. */
2537 gtk_menu_item_set_submenu (witem
, nsub
);
2542 /* Structural difference. Remove everything from here and down
2548 /* Remove widgets from first structual change. */
2551 /* If we are adding new menu items below, we must remove from
2552 first radio button so that radio groups become correct. */
2553 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2554 else xg_destroy_widgets (iter
);
2559 /* More items added. Create them. */
2560 newsub
= create_menus (cur
,
2573 if (list
) g_list_free (list
);
2578 /* Update the MENUBAR.
2579 F is the frame the menu bar belongs to.
2580 VAL describes the contents of the menu bar.
2581 If DEEP_P is non-zero, rebuild all but the top level menu names in
2582 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2583 SELECT_CB is the callback to use when a menu item is selected.
2584 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2585 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2588 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2589 select_cb
, deactivate_cb
, highlight_cb
)
2594 GCallback select_cb
;
2595 GCallback deactivate_cb
;
2596 GCallback highlight_cb
;
2598 xg_menu_cb_data
*cl_data
;
2599 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2603 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2606 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2607 select_cb
, highlight_cb
, cl_data
);
2613 /* Update all sub menus.
2614 We must keep the submenus (GTK menu item widgets) since the
2615 X Window in the XEvent that activates the menu are those widgets. */
2617 /* Update cl_data, menu_item things in F may have changed. */
2618 update_cl_data (cl_data
, f
, highlight_cb
);
2620 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2627 /* Find sub menu that corresponds to val and update it. */
2628 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2630 witem
= GTK_MENU_ITEM (iter
->data
);
2631 if (xg_item_label_same_p (witem
, cur
->name
))
2633 sub
= gtk_menu_item_get_submenu (witem
);
2638 newsub
= xg_update_submenu (sub
,
2645 /* sub may still be NULL. If we just updated non deep and added
2646 a new menu bar item, it has no sub menu yet. So we set the
2647 newly created sub menu under witem. */
2650 xg_set_screen (newsub
, f
);
2651 gtk_menu_item_set_submenu (witem
, newsub
);
2657 gtk_widget_show_all (menubar
);
2660 /* Recompute all the widgets of frame F, when the menu bar has been
2661 changed. Value is non-zero if widgets were updated. */
2664 xg_update_frame_menubar (f
)
2667 struct x_output
*x
= f
->output_data
.x
;
2670 if (!x
->menubar_widget
|| GTK_WIDGET_MAPPED (x
->menubar_widget
))
2675 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2677 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2679 gtk_widget_show_all (x
->menubar_widget
);
2680 gtk_widget_size_request (x
->menubar_widget
, &req
);
2682 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2684 /* The height has changed, resize outer widget and set columns
2685 rows to what we had before adding the menu bar. */
2686 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2688 SET_FRAME_GARBAGED (f
);
2694 /* Get rid of the menu bar of frame F, and free its storage.
2695 This is used when deleting a frame, and when turning off the menu bar. */
2698 free_frame_menubar (f
)
2701 struct x_output
*x
= f
->output_data
.x
;
2703 if (x
->menubar_widget
)
2707 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2708 /* The menubar and its children shall be deleted when removed from
2710 x
->menubar_widget
= 0;
2711 FRAME_MENUBAR_HEIGHT (f
) = 0;
2713 /* The height has changed, resize outer widget and set columns
2714 rows to what we had before removing the menu bar. */
2715 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2717 SET_FRAME_GARBAGED (f
);
2724 /***********************************************************************
2725 Scroll bar functions
2726 ***********************************************************************/
2729 /* Setting scroll bar values invokes the callback. Use this variable
2730 to indicate that callback should do nothing. */
2732 int xg_ignore_gtk_scrollbar
;
2734 /* SET_SCROLL_BAR_X_WINDOW assumes the second argument fits in
2735 32 bits. But we want to store pointers, and they may be larger
2736 than 32 bits. Keep a mapping from integer index to widget pointers
2737 to get around the 32 bit limitation. */
2741 GtkWidget
**widgets
;
2746 /* Grow this much every time we need to allocate more */
2748 #define ID_TO_WIDGET_INCR 32
2750 /* Store the widget pointer W in id_to_widget and return the integer index. */
2753 xg_store_widget_in_map (w
)
2758 if (id_to_widget
.max_size
== id_to_widget
.used
)
2760 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
2762 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
2763 sizeof (GtkWidget
*)*new_size
);
2765 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
2766 id_to_widget
.widgets
[i
] = 0;
2767 id_to_widget
.max_size
= new_size
;
2770 /* Just loop over the array and find a free place. After all,
2771 how many scroll bars are we creating? Should be a small number.
2772 The check above guarantees we will find a free place. */
2773 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
2775 if (! id_to_widget
.widgets
[i
])
2777 id_to_widget
.widgets
[i
] = w
;
2778 ++id_to_widget
.used
;
2784 /* Should never end up here */
2788 /* Remove pointer at IDX from id_to_widget.
2789 Called when scroll bar is destroyed. */
2792 xg_remove_widget_from_map (idx
)
2795 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2797 id_to_widget
.widgets
[idx
] = 0;
2798 --id_to_widget
.used
;
2802 /* Get the widget pointer at IDX from id_to_widget. */
2805 xg_get_widget_from_map (idx
)
2808 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2809 return id_to_widget
.widgets
[idx
];
2814 /* Return the scrollbar id for X Window WID on display DPY.
2815 Return -1 if WID not in id_to_widget. */
2818 xg_get_scroll_id_for_window (dpy
, wid
)
2825 w
= xg_win_to_widget (dpy
, wid
);
2829 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
2830 if (id_to_widget
.widgets
[idx
] == w
)
2837 /* Callback invoked when scroll bar WIDGET is destroyed.
2838 DATA is the index into id_to_widget for WIDGET.
2839 We free pointer to last scroll bar values here and remove the index. */
2842 xg_gtk_scroll_destroy (widget
, data
)
2847 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
2849 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
2851 xg_remove_widget_from_map (id
);
2854 /* Callback for button press/release events. Used to start timer so that
2855 the scroll bar repetition timer in GTK gets handeled.
2856 Also, sets bar->dragging to Qnil when dragging (button release) is done.
2857 WIDGET is the scroll bar widget the event is for (not used).
2858 EVENT contains the event.
2859 USER_DATA points to the struct scrollbar structure.
2861 Returns FALSE to tell GTK that it shall continue propagate the event
2865 scroll_bar_button_cb (widget
, event
, user_data
)
2867 GdkEventButton
*event
;
2870 if (event
->type
== GDK_BUTTON_PRESS
&& ! xg_timer
)
2872 else if (event
->type
== GDK_BUTTON_RELEASE
)
2874 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
2875 if (xg_timer
) xg_stop_timer ();
2876 bar
->dragging
= Qnil
;
2882 /* Create a scroll bar widget for frame F. Store the scroll bar
2884 SCROLL_CALLBACK is the callback to invoke when the value of the
2886 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
2887 to set resources for the widget. */
2890 xg_create_scroll_bar (f
, bar
, scroll_callback
, scroll_bar_name
)
2892 struct scroll_bar
*bar
;
2893 GCallback scroll_callback
;
2894 char *scroll_bar_name
;
2901 /* Page, step increment values are not so important here, they
2902 will be corrected in x_set_toolkit_scroll_bar_thumb. */
2903 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
2906 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
2907 webox
= gtk_event_box_new ();
2908 gtk_widget_set_name (wscroll
, scroll_bar_name
);
2909 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
2911 scroll_id
= xg_store_widget_in_map (wscroll
);
2913 g_signal_connect (G_OBJECT (wscroll
),
2917 /* The EMACS_INT cast avoids a warning. */
2918 g_signal_connect (G_OBJECT (wscroll
),
2920 G_CALLBACK (xg_gtk_scroll_destroy
),
2921 (gpointer
) (EMACS_INT
) scroll_id
);
2923 /* Connect to button press and button release to detect if any scroll bar
2925 g_signal_connect (G_OBJECT (wscroll
),
2926 "button-press-event",
2927 G_CALLBACK (scroll_bar_button_cb
),
2929 g_signal_connect (G_OBJECT (wscroll
),
2930 "button-release-event",
2931 G_CALLBACK (scroll_bar_button_cb
),
2934 /* The scroll bar widget does not draw on a window of its own. Instead
2935 it draws on the parent window, in this case the edit widget. So
2936 whenever the edit widget is cleared, the scroll bar needs to redraw
2937 also, which causes flicker. Put an event box between the edit widget
2938 and the scroll bar, so the scroll bar instead draws itself on the
2939 event box window. */
2940 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
2941 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
2944 /* Set the cursor to an arrow. */
2945 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2947 SET_SCROLL_BAR_X_WINDOW (bar
, scroll_id
);
2950 /* Make the scroll bar represented by SCROLLBAR_ID visible. */
2953 xg_show_scroll_bar (scrollbar_id
)
2956 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
2958 gtk_widget_show_all (gtk_widget_get_parent (w
));
2961 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
2964 xg_remove_scroll_bar (f
, scrollbar_id
)
2968 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
2971 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
2972 gtk_widget_destroy (w
);
2973 gtk_widget_destroy (wparent
);
2974 SET_FRAME_GARBAGED (f
);
2978 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
2980 TOP/LEFT are the new pixel positions where the bar shall appear.
2981 WIDTH, HEIGHT is the size in pixels the bar shall have. */
2984 xg_update_scrollbar_pos (f
, scrollbar_id
, top
, left
, width
, height
)
2993 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
2997 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
2998 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3000 /* Move and resize to new values. */
3001 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3002 gtk_widget_set_size_request (wscroll
, width
, height
);
3003 gtk_widget_queue_draw (wparent
);
3004 gdk_window_process_all_updates ();
3005 /* GTK does not redraw until the main loop is entered again, but
3006 if there are no X events pending we will not enter it. So we sync
3007 here to get some events. */
3009 SET_FRAME_GARBAGED (f
);
3010 cancel_mouse_face (f
);
3014 /* Set the thumb size and position of scroll bar BAR. We are currently
3015 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3018 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
3019 struct scroll_bar
*bar
;
3020 int portion
, position
, whole
;
3022 GtkWidget
*wscroll
= xg_get_widget_from_map (SCROLL_BAR_X_WINDOW (bar
));
3024 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3026 if (wscroll
&& NILP (bar
->dragging
))
3035 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3037 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3038 rather than the real portion value. This makes the thumb less likely
3039 to resize and that looks better. */
3040 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3041 /* When the thumb is at the bottom, position == whole.
3042 So we need to increase `whole' to make space for the thumb. */
3049 top
= (gdouble
) position
/ whole
;
3050 shown
= (gdouble
) portion
/ whole
;
3053 size
= shown
* XG_SB_RANGE
;
3054 size
= min (size
, XG_SB_RANGE
);
3055 size
= max (size
, 1);
3057 value
= top
* XG_SB_RANGE
;
3058 value
= min (value
, XG_SB_MAX
- size
);
3059 value
= max (value
, XG_SB_MIN
);
3061 /* Assume all lines are of equal size. */
3062 new_step
= size
/ max (1, FRAME_LINES (f
));
3064 if ((int) adj
->page_size
!= size
3065 || (int) adj
->step_increment
!= new_step
)
3067 adj
->page_size
= size
;
3068 adj
->step_increment
= new_step
;
3069 /* Assume a page increment is about 95% of the page size */
3070 adj
->page_increment
= (int) (0.95*adj
->page_size
);
3074 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3076 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3080 /* gtk_range_set_value invokes the callback. Set
3081 ignore_gtk_scrollbar to make the callback do nothing */
3082 xg_ignore_gtk_scrollbar
= 1;
3084 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3085 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3087 gtk_adjustment_changed (adj
);
3089 xg_ignore_gtk_scrollbar
= 0;
3097 /***********************************************************************
3099 ***********************************************************************/
3100 /* The key for the data we put in the GtkImage widgets. The data is
3101 the image used by Emacs. We use this to see if we need to update
3102 the GtkImage with a new image. */
3103 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3105 /* Callback function invoked when a tool bar item is pressed.
3106 W is the button widget in the tool bar that got pressed,
3107 CLIENT_DATA is an integer that is the index of the button in the
3108 tool bar. 0 is the first button. */
3111 xg_tool_bar_callback (w
, client_data
)
3113 gpointer client_data
;
3115 /* The EMACS_INT cast avoids a warning. */
3116 int idx
= (int) (EMACS_INT
) client_data
;
3117 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3118 Lisp_Object key
, frame
;
3119 struct input_event event
;
3122 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3125 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3127 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3128 XSETFRAME (frame
, f
);
3129 event
.kind
= TOOL_BAR_EVENT
;
3130 event
.frame_or_window
= frame
;
3132 kbd_buffer_store_event (&event
);
3134 event
.kind
= TOOL_BAR_EVENT
;
3135 event
.frame_or_window
= frame
;
3137 event
.modifiers
= 0; /* These are not available. */
3138 kbd_buffer_store_event (&event
);
3141 /* This callback is called when a tool bar is detached. We must set
3142 the height of the tool bar to zero when this happens so frame sizes
3143 are correctly calculated.
3144 WBOX is the handle box widget that enables detach/attach of the tool bar.
3145 W is the tool bar widget.
3146 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3149 xg_tool_bar_detach_callback (wbox
, w
, client_data
)
3152 gpointer client_data
;
3154 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3158 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3160 /* When detaching a tool bar, not everything dissapear. There are
3161 a few pixels left that are used to drop the tool bar back into
3163 FRAME_TOOLBAR_HEIGHT (f
) = 2;
3165 /* The height has changed, resize outer widget and set columns
3166 rows to what we had before detaching the tool bar. */
3167 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3171 /* This callback is called when a tool bar is reattached. We must set
3172 the height of the tool bar when this happens so frame sizes
3173 are correctly calculated.
3174 WBOX is the handle box widget that enables detach/attach of the tool bar.
3175 W is the tool bar widget.
3176 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3179 xg_tool_bar_attach_callback (wbox
, w
, client_data
)
3182 gpointer client_data
;
3184 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3190 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3192 gtk_widget_size_request (w
, &req
);
3193 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3195 /* The height has changed, resize outer widget and set columns
3196 rows to what we had before attaching the tool bar. */
3197 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3201 /* This callback is called when the mouse enters or leaves a tool bar item.
3202 It is used for displaying and hiding the help text.
3203 W is the tool bar item, a button.
3204 EVENT is either an enter event or leave event.
3205 CLIENT_DATA is an integer that is the index of the button in the
3206 tool bar. 0 is the first button.
3208 Returns FALSE to tell GTK to keep processing this event. */
3211 xg_tool_bar_help_callback (w
, event
, client_data
)
3213 GdkEventCrossing
*event
;
3214 gpointer client_data
;
3216 /* The EMACS_INT cast avoids a warning. */
3217 int idx
= (int) (EMACS_INT
) client_data
;
3218 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3219 Lisp_Object help
, frame
;
3221 if (! GTK_IS_BUTTON (w
))
3226 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3229 if (event
->type
== GDK_ENTER_NOTIFY
)
3231 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3232 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3235 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3240 XSETFRAME (frame
, f
);
3241 kbd_buffer_store_help_event (frame
, help
);
3247 /* This callback is called when a tool bar item shall be redrawn.
3248 It modifies the expose event so that the GtkImage widget redraws the
3249 whole image. This to overcome a bug that makes GtkImage draw the image
3250 in the wrong place when it tries to redraw just a part of the image.
3251 W is the GtkImage to be redrawn.
3252 EVENT is the expose event for W.
3253 CLIENT_DATA is unused.
3255 Returns FALSE to tell GTK to keep processing this event. */
3258 xg_tool_bar_item_expose_callback (w
, event
, client_data
)
3260 GdkEventExpose
*event
;
3261 gpointer client_data
;
3265 gdk_drawable_get_size (event
->window
, &width
, &height
);
3267 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3268 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3270 event
->area
.x
= max (0, event
->area
.x
);
3271 event
->area
.y
= max (0, event
->area
.y
);
3273 event
->area
.width
= max (width
, event
->area
.width
);
3274 event
->area
.height
= max (height
, event
->area
.height
);
3279 /* This callback is called when a tool bar shall be redrawn.
3280 We need to update the tool bar from here in case the image cache
3281 has deleted the pixmaps used in the tool bar.
3282 W is the GtkToolbar to be redrawn.
3283 EVENT is the expose event for W.
3284 CLIENT_DATA is pointing to the frame for this tool bar.
3286 Returns FALSE to tell GTK to keep processing this event. */
3289 xg_tool_bar_expose_callback (w
, event
, client_data
)
3291 GdkEventExpose
*event
;
3292 gpointer client_data
;
3294 update_frame_tool_bar ((FRAME_PTR
) client_data
);
3298 /* Create a tool bar for frame F. */
3301 xg_create_tool_bar (f
)
3304 struct x_output
*x
= f
->output_data
.x
;
3306 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3308 x
->toolbar_widget
= gtk_toolbar_new ();
3309 x
->handlebox_widget
= gtk_handle_box_new ();
3310 x
->toolbar_detached
= 0;
3312 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3315 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3318 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3321 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3323 /* We only have icons, so override any user setting. We could
3324 use the caption property of the toolbar item (see update_frame_tool_bar
3325 below), but some of those strings are long, making the toolbar so
3326 long it does not fit on the screen. The GtkToolbar widget makes every
3327 item equal size, so the longest caption determine the size of every
3328 tool bar item. I think the creators of the GtkToolbar widget
3329 counted on 4 or 5 character long strings. */
3330 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3331 gtk_toolbar_set_orientation (GTK_TOOLBAR (x
->toolbar_widget
),
3332 GTK_ORIENTATION_HORIZONTAL
);
3334 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3335 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3336 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3337 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3338 g_signal_connect (G_OBJECT (x
->toolbar_widget
),
3340 G_CALLBACK (xg_tool_bar_expose_callback
),
3343 gtk_widget_show_all (x
->handlebox_widget
);
3345 gtk_widget_size_request (x
->toolbar_widget
, &req
);
3346 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3348 /* The height has changed, resize outer widget and set columns
3349 rows to what we had before adding the tool bar. */
3350 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3352 SET_FRAME_GARBAGED (f
);
3355 /* Update the tool bar for frame F. Add new buttons and remove old. */
3358 update_frame_tool_bar (f
)
3362 GtkRequisition old_req
, new_req
;
3365 struct x_output
*x
= f
->output_data
.x
;
3366 int hmargin
, vmargin
;
3368 if (! FRAME_GTK_WIDGET (f
))
3373 if (INTEGERP (Vtool_bar_button_margin
)
3374 && XINT (Vtool_bar_button_margin
) > 0)
3376 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3377 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3379 else if (CONSP (Vtool_bar_button_margin
))
3381 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3382 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3383 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3385 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3386 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3387 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3390 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3391 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3392 i.e. zero. This means that margins less than
3393 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3394 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3395 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3397 if (! x
->toolbar_widget
)
3398 xg_create_tool_bar (f
);
3400 gtk_widget_size_request (x
->toolbar_widget
, &old_req
);
3402 icon_list
= gtk_container_get_children (GTK_CONTAINER (x
->toolbar_widget
));
3405 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3407 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3409 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3410 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3415 GtkWidget
*wicon
= iter
? GTK_WIDGET (iter
->data
) : 0;
3417 if (iter
) iter
= g_list_next (iter
);
3419 /* If image is a vector, choose the image according to the
3421 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3422 if (VECTORP (image
))
3426 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3427 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3430 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3431 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3433 xassert (ASIZE (image
) >= idx
);
3434 image
= AREF (image
, idx
);
3439 /* Ignore invalid image specifications. */
3440 if (!valid_image_p (image
))
3442 if (wicon
) gtk_widget_hide (wicon
);
3446 img_id
= lookup_image (f
, image
);
3447 img
= IMAGE_FROM_ID (f
, img_id
);
3448 prepare_image_for_display (f
, img
);
3450 if (img
->load_failed_p
|| img
->pixmap
== None
)
3452 if (wicon
) gtk_widget_hide (wicon
);
3458 GtkWidget
*w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
3460 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
3462 /* The EMACS_INT cast avoids a warning. */
3463 gtk_toolbar_append_item (GTK_TOOLBAR (x
->toolbar_widget
),
3466 GTK_SIGNAL_FUNC (xg_tool_bar_callback
),
3467 (gpointer
) (EMACS_INT
) i
);
3469 /* Save the image so we can see if an update is needed when
3470 this function is called again. */
3471 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
3472 (gpointer
)img
->pixmap
);
3474 /* Catch expose events to overcome an annoying redraw bug, see
3475 comment for xg_tool_bar_item_expose_callback. */
3476 g_signal_connect (G_OBJECT (w
),
3478 G_CALLBACK (xg_tool_bar_item_expose_callback
),
3481 /* We must set sensitive on the button that is the parent
3482 of the GtkImage parent. Go upwards until we find the button. */
3483 while (! GTK_IS_BUTTON (w
))
3484 w
= gtk_widget_get_parent (w
);
3488 /* Save the frame in the button so the xg_tool_bar_callback
3490 g_object_set_data (G_OBJECT (w
), XG_FRAME_DATA
, (gpointer
)f
);
3491 gtk_widget_set_sensitive (w
, enabled_p
);
3493 /* Use enter/leave notify to show help. We use the events
3494 rather than the GtkButton specific signals "enter" and
3495 "leave", so we can have only one callback. The event
3496 will tell us what kind of event it is. */
3497 /* The EMACS_INT cast avoids a warning. */
3498 g_signal_connect (G_OBJECT (w
),
3499 "enter-notify-event",
3500 G_CALLBACK (xg_tool_bar_help_callback
),
3501 (gpointer
) (EMACS_INT
) i
);
3502 g_signal_connect (G_OBJECT (w
),
3503 "leave-notify-event",
3504 G_CALLBACK (xg_tool_bar_help_callback
),
3505 (gpointer
) (EMACS_INT
) i
);
3510 /* The child of the tool bar is a button. Inside that button
3511 is a vbox. Inside that vbox is the GtkImage. */
3512 GtkWidget
*wvbox
= gtk_bin_get_child (GTK_BIN (wicon
));
3513 GList
*chlist
= gtk_container_get_children (GTK_CONTAINER (wvbox
));
3514 GtkImage
*wimage
= GTK_IMAGE (chlist
->data
);
3515 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
3516 XG_TOOL_BAR_IMAGE_DATA
);
3517 g_list_free (chlist
);
3519 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
3521 if (old_img
!= img
->pixmap
)
3522 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
3524 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
3525 (gpointer
)img
->pixmap
);
3527 gtk_widget_set_sensitive (wicon
, enabled_p
);
3528 gtk_widget_show (wicon
);
3534 /* Remove buttons not longer needed. We just hide them so they
3535 can be reused later on. */
3538 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3539 gtk_widget_hide (w
);
3540 iter
= g_list_next (iter
);
3543 gtk_widget_size_request (x
->toolbar_widget
, &new_req
);
3544 if (old_req
.height
!= new_req
.height
3545 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
3547 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
3548 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3551 if (icon_list
) g_list_free (icon_list
);
3556 /* Deallocate all resources for the tool bar on frame F.
3557 Remove the tool bar. */
3560 free_frame_tool_bar (f
)
3563 struct x_output
*x
= f
->output_data
.x
;
3565 if (x
->toolbar_widget
)
3568 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
3569 x
->handlebox_widget
);
3570 x
->toolbar_widget
= 0;
3571 x
->handlebox_widget
= 0;
3572 FRAME_TOOLBAR_HEIGHT (f
) = 0;
3574 /* The height has changed, resize outer widget and set columns
3575 rows to what we had before removing the tool bar. */
3576 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3578 SET_FRAME_GARBAGED (f
);
3585 /***********************************************************************
3587 ***********************************************************************/
3591 GtkBindingSet
*binding_set
;
3593 xg_ignore_gtk_scrollbar
= 0;
3594 xg_detached_menus
= 0;
3595 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
3596 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
3598 id_to_widget
.max_size
= id_to_widget
.used
= 0;
3599 id_to_widget
.widgets
= 0;
3601 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
3602 bindings. It doesn't seem to be any way to remove properties,
3603 so we set it to VoidSymbol which in X means "no key". */
3604 gtk_settings_set_string_property (gtk_settings_get_default (),
3605 "gtk-menu-bar-accel",
3609 /* Make GTK text input widgets use Emacs style keybindings. This is
3611 gtk_settings_set_string_property (gtk_settings_get_default (),
3612 "gtk-key-theme-name",
3616 /* Make dialogs close on C-g. Since file dialog inherits from
3617 dialog, this works for them also. */
3618 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_DIALOG
));
3619 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3622 /* Make menus close on C-g. */
3623 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_MENU_SHELL
));
3624 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3628 #endif /* USE_GTK */
3630 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
3631 (do not change this comment) */