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 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
245 xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
)
250 int x
, y
, width
, height
, rowstride
, mask_rowstride
;
251 GdkPixbuf
*icon_buf
, *tmp_buf
;
255 gdk_drawable_get_size (gpix
, &width
, &height
);
256 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
257 0, 0, 0, 0, width
, height
);
258 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
259 g_object_unref (G_OBJECT (tmp_buf
));
263 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
268 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
269 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
270 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
271 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
274 for (y
= 0; y
< height
; ++y
)
276 guchar
*iconptr
, *maskptr
;
279 iconptr
= pixels
+ y
* rowstride
;
280 maskptr
= mask_pixels
+ y
* mask_rowstride
;
282 for (x
= 0; x
< width
; ++x
)
284 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
285 just R is sufficient. */
287 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
289 iconptr
+= rowstride
/width
;
290 maskptr
+= mask_rowstride
/width
;
294 g_object_unref (G_OBJECT (mask_buf
));
300 /* For the image defined in IMG, make and return a GtkImage. For displays with
301 8 planes or less we must make a GdkPixbuf and apply the mask manually.
302 Otherwise the highlightning and dimming the tool bar code in GTK does
303 will look bad. For display with more than 8 planes we just use the
304 pixmap and mask directly. For monochrome displays, GTK doesn't seem
305 able to use external pixmaps, it looks bad whatever we do.
306 The image is defined on the display where frame F is.
307 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
308 If OLD_WIDGET is NULL, a new widget is constructed and returned.
309 If OLD_WIDGET is not NULL, that widget is modified. */
312 xg_get_image_for_pixmap (f
, img
, widget
, old_widget
)
316 GtkImage
*old_widget
;
322 /* If we are on a one bit display, let GTK do all the image handling.
323 This seems to be the only way to make insensitive and activated icons
325 if (x_screen_planes (f
) == 1)
327 Lisp_Object specified_file
= Qnil
;
329 extern Lisp_Object QCfile
;
331 for (tail
= XCDR (img
->spec
);
332 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
333 tail
= XCDR (XCDR (tail
)))
334 if (EQ (XCAR (tail
), QCfile
))
335 specified_file
= XCAR (XCDR (tail
));
337 if (STRINGP (specified_file
))
340 Lisp_Object file
= Qnil
;
344 file
= x_find_image_file (specified_file
);
345 /* We already loaded the image once before calling this
346 function, so this should not fail. */
347 xassert (STRINGP (file
) != 0);
350 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SDATA (file
)));
352 gtk_image_set_from_file (old_widget
, SDATA (file
));
355 return GTK_WIDGET (old_widget
);
359 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
360 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
361 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
363 if (x_screen_planes (f
) > 8 || x_screen_planes (f
) == 1)
366 old_widget
= GTK_IMAGE (gtk_image_new_from_pixmap (gpix
, gmask
));
368 gtk_image_set_from_pixmap (old_widget
, gpix
, gmask
);
373 /* This is a workaround to make icons look good on pseudo color
374 displays. Apparently GTK expects the images to have an alpha
375 channel. If they don't, insensitive and activated icons will
376 look bad. This workaround does not work on monochrome displays,
377 and is not needed on true color/static color displays (i.e.
378 16 bits and higher). */
379 GdkColormap
*cmap
= gtk_widget_get_colormap (widget
);
380 GdkPixbuf
*icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
383 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
385 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
387 g_object_unref (G_OBJECT (icon_buf
));
390 g_object_unref (G_OBJECT (gpix
));
391 if (gmask
) g_object_unref (G_OBJECT (gmask
));
393 return GTK_WIDGET (old_widget
);
397 /* Set CURSOR on W and all widgets W contain. We must do like this
398 for scroll bars and menu because they create widgets internally,
399 and it is those widgets that are visible. */
402 xg_set_cursor (w
, cursor
)
406 GList
*children
= gdk_window_peek_children (w
->window
);
408 gdk_window_set_cursor (w
->window
, cursor
);
410 /* The scroll bar widget has more than one GDK window (had to look at
411 the source to figure this out), and there is no way to set cursor
412 on widgets in GTK. So we must set the cursor for all GDK windows.
415 for ( ; children
; children
= g_list_next (children
))
416 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
419 /* Timer function called when a timeout occurs for xg_timer.
420 This function processes all GTK events in a recursive event loop.
421 This is done because GTK timer events are not seen by Emacs event
422 detection, Emacs only looks for X events. When a scroll bar has the
423 pointer (detected by button press/release events below) an Emacs
424 timer is started, and this function can then check if the GTK timer
425 has expired by calling the GTK event loop.
426 Also, when a menu is active, it has a small timeout before it
427 pops down the sub menu under it. */
430 xg_process_timeouts (timer
)
431 struct atimer
*timer
;
434 /* Ideally we would like to just handle timer events, like the Xt version
435 of this does in xterm.c, but there is no such feature in GTK. */
436 while (gtk_events_pending ())
437 gtk_main_iteration ();
441 /* Start the xg_timer with an interval of 0.1 seconds, if not already started.
442 xg_process_timeouts is called when the timer expires. The timer
443 started is continuous, i.e. runs until xg_stop_timer is called. */
451 EMACS_SET_SECS_USECS (interval
, 0, 100000);
452 xg_timer
= start_atimer (ATIMER_CONTINUOUS
,
459 /* Stop the xg_timer if started. */
466 cancel_atimer (xg_timer
);
471 /* Insert NODE into linked LIST. */
474 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
476 xg_list_node
*list_start
= list
->next
;
478 if (list_start
) list_start
->prev
= node
;
479 node
->next
= list_start
;
484 /* Remove NODE from linked LIST. */
487 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
489 xg_list_node
*list_start
= list
->next
;
490 if (node
== list_start
)
492 list
->next
= node
->next
;
493 if (list
->next
) list
->next
->prev
= 0;
497 node
->prev
->next
= node
->next
;
498 if (node
->next
) node
->next
->prev
= node
->prev
;
502 /* Allocate and return a utf8 version of STR. If STR is already
503 utf8 or NULL, just return STR.
504 If not, a new string is allocated and the caller must free the result
508 get_utf8_string (str
)
511 char *utf8_str
= str
;
513 /* If not UTF-8, try current locale. */
514 if (str
&& !g_utf8_validate (str
, -1, NULL
))
515 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
522 /***********************************************************************
523 General functions for creating widgets, resizing, events, e.t.c.
524 ***********************************************************************/
526 /* Make a geometry string and pass that to GTK. It seems this is the
527 only way to get geometry position right if the user explicitly
528 asked for a position when starting Emacs.
529 F is the frame we shall set geometry for. */
535 if (f
->size_hint_flags
& USPosition
)
537 int left
= f
->left_pos
;
538 int xneg
= f
->size_hint_flags
& XNegative
;
539 int top
= f
->top_pos
;
540 int yneg
= f
->size_hint_flags
& YNegative
;
548 sprintf (geom_str
, "=%dx%d%c%d%c%d",
549 FRAME_PIXEL_WIDTH (f
),
550 FRAME_TOTAL_PIXEL_HEIGHT (f
),
551 (xneg
? '-' : '+'), left
,
552 (yneg
? '-' : '+'), top
);
554 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
556 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
561 /* Resize the outer window of frame F after chainging the height.
562 This happend when the menu bar or the tool bar is added or removed.
563 COLUMNS/ROWS is the size the edit area shall have after the resize. */
566 xg_resize_outer_widget (f
, columns
, rows
)
571 /* If we are not mapped yet, set geometry once again, as window
572 height now have changed. */
573 if (! GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f
)))
576 xg_frame_set_char_size (f
, columns
, rows
);
577 gdk_window_process_all_updates ();
580 /* Function to handle resize of our widgets. Since Emacs has some layouts
581 that does not fit well with GTK standard containers, we do most layout
583 F is the frame to resize.
584 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
587 xg_resize_widgets (f
, pixelwidth
, pixelheight
)
589 int pixelwidth
, pixelheight
;
591 int mbheight
= FRAME_MENUBAR_HEIGHT (f
);
592 int tbheight
= FRAME_TOOLBAR_HEIGHT (f
);
593 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, (pixelheight
594 - mbheight
- tbheight
));
595 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
597 if (FRAME_GTK_WIDGET (f
)
598 && (columns
!= FRAME_COLS (f
)
599 || rows
!= FRAME_LINES (f
)
600 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
601 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
)))
603 struct x_output
*x
= f
->output_data
.x
;
606 all
.y
= mbheight
+ tbheight
;
609 all
.width
= pixelwidth
;
610 all
.height
= pixelheight
- mbheight
- tbheight
;
612 gtk_widget_size_allocate (x
->edit_widget
, &all
);
614 change_frame_size (f
, rows
, columns
, 0, 1, 0);
615 SET_FRAME_GARBAGED (f
);
616 cancel_mouse_face (f
);
621 /* Update our widget size to be COLS/ROWS characters for frame F. */
624 xg_frame_set_char_size (f
, cols
, rows
)
629 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
630 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
633 /* Take into account the size of the scroll bar. Always use the
634 number of columns occupied by the scroll bar here otherwise we
635 might end up with a frame width that is not a multiple of the
636 frame's character width which is bad for vertically split
638 f
->scroll_bar_actual_width
639 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
641 compute_fringe_widths (f
, 0);
643 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
644 after calculating that value. */
645 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
647 /* Must resize our top level widget. Font size may have changed,
648 but not rows/cols. */
649 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
650 pixelwidth
, pixelheight
);
651 xg_resize_widgets (f
, pixelwidth
, pixelheight
);
652 x_wm_set_size_hint (f
, 0, 0);
653 SET_FRAME_GARBAGED (f
);
654 cancel_mouse_face (f
);
657 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
658 Must be done like this, because GtkWidget:s can have "hidden"
659 X Window that aren't accessible.
661 Return 0 if no widget match WDESC. */
664 xg_win_to_widget (dpy
, wdesc
)
669 GtkWidget
*gwdesc
= 0;
673 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
678 event
.any
.window
= gdkwin
;
679 gwdesc
= gtk_get_event_widget (&event
);
686 /* Fill in the GdkColor C so that it represents PIXEL.
687 W is the widget that color will be used for. Used to find colormap. */
690 xg_pix_to_gcolor (w
, pixel
, c
)
695 GdkColormap
*map
= gtk_widget_get_colormap (w
);
696 gdk_colormap_query_color (map
, pixel
, c
);
699 /* Create and set up the GTK widgets for frame F.
700 Return 0 if creation failed, non-zero otherwise. */
703 xg_create_frame_widgets (f
)
716 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
717 xg_set_screen (wtop
, f
);
719 wvbox
= gtk_vbox_new (FALSE
, 0);
720 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
722 if (! wtop
|| ! wvbox
|| ! wfixed
)
724 if (wtop
) gtk_widget_destroy (wtop
);
725 if (wvbox
) gtk_widget_destroy (wvbox
);
726 if (wfixed
) gtk_widget_destroy (wfixed
);
732 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
733 gtk_widget_set_name (wtop
, EMACS_CLASS
);
734 gtk_widget_set_name (wvbox
, "pane");
735 gtk_widget_set_name (wfixed
, SDATA (Vx_resource_name
));
737 /* If this frame has a title or name, set it in the title bar. */
738 if (! NILP (f
->title
)) title
= SDATA (ENCODE_UTF_8 (f
->title
));
739 else if (! NILP (f
->name
)) title
= SDATA (ENCODE_UTF_8 (f
->name
));
741 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
743 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
744 FRAME_GTK_WIDGET (f
) = wfixed
;
745 f
->output_data
.x
->vbox_widget
= wvbox
;
747 gtk_fixed_set_has_window (GTK_FIXED (wfixed
), TRUE
);
749 gtk_widget_set_size_request (wfixed
, FRAME_PIXEL_WIDTH (f
),
750 FRAME_PIXEL_HEIGHT (f
));
752 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
753 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
755 if (FRAME_EXTERNAL_TOOL_BAR (f
))
756 update_frame_tool_bar (f
);
758 /* The tool bar is created but first there are no items in it.
759 This causes it to be zero height. Later items are added, but then
760 the frame is already mapped, so there is a "jumping" resize.
761 This makes geometry handling difficult, for example -0-0 will end
762 up in the wrong place as tool bar height has not been taken into account.
763 So we cheat a bit by setting a height that is what it will have
764 later on when tool bar items are added. */
765 if (FRAME_EXTERNAL_TOOL_BAR (f
) && f
->n_tool_bar_items
== 0)
766 FRAME_TOOLBAR_HEIGHT (f
) = 38;
769 /* We don't want this widget double buffered, because we draw on it
770 with regular X drawing primitives, so from a GTK/GDK point of
771 view, the widget is totally blank. When an expose comes, this
772 will make the widget blank, and then Emacs redraws it. This flickers
773 a lot, so we turn off double buffering. */
774 gtk_widget_set_double_buffered (wfixed
, FALSE
);
776 /* GTK documents says use gtk_window_set_resizable. But then a user
777 can't shrink the window from its starting size. */
778 gtk_window_set_policy (GTK_WINDOW (wtop
), TRUE
, TRUE
, TRUE
);
779 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
780 SDATA (Vx_resource_name
),
781 SDATA (Vx_resource_class
));
783 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
784 GTK is to destroy the widget. We want Emacs to do that instead. */
785 g_signal_connect (G_OBJECT (wtop
), "delete-event",
786 G_CALLBACK (gtk_true
), 0);
788 /* Convert our geometry parameters into a geometry string
790 GTK will itself handle calculating the real position this way. */
793 gtk_widget_add_events (wfixed
,
794 GDK_POINTER_MOTION_MASK
796 | GDK_BUTTON_PRESS_MASK
797 | GDK_BUTTON_RELEASE_MASK
799 | GDK_ENTER_NOTIFY_MASK
800 | GDK_LEAVE_NOTIFY_MASK
801 | GDK_FOCUS_CHANGE_MASK
803 | GDK_VISIBILITY_NOTIFY_MASK
);
805 /* Must realize the windows so the X window gets created. It is used
806 by callers of this function. */
807 gtk_widget_realize (wfixed
);
808 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
810 /* Since GTK clears its window by filling with the background color,
811 we must keep X and GTK background in sync. */
812 xg_pix_to_gcolor (wfixed
, f
->output_data
.x
->background_pixel
, &bg
);
813 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
815 /* Also, do not let any background pixmap to be set, this looks very
816 bad as Emacs overwrites the background pixmap with its own idea
817 of background color. */
818 style
= gtk_widget_get_modifier_style (wfixed
);
820 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
821 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
822 gtk_widget_modify_style (wfixed
, style
);
824 /* GTK does not set any border, and they look bad with GTK. */
826 f
->internal_border_width
= 0;
833 /* Set the normal size hints for the window manager, for frame F.
834 FLAGS is the flags word to use--or 0 meaning preserve the flags
835 that the window now has.
836 If USER_POSITION is nonzero, we set the User Position
837 flag (this is useful when FLAGS is 0). */
840 x_wm_set_size_hint (f
, flags
, user_position
)
845 if (FRAME_GTK_OUTER_WIDGET (f
))
847 /* Must use GTK routines here, otherwise GTK resets the size hints
848 to its own defaults. */
849 GdkGeometry size_hints
;
851 int base_width
, base_height
;
852 int min_rows
= 0, min_cols
= 0;
853 int win_gravity
= f
->win_gravity
;
857 memset (&size_hints
, 0, sizeof (size_hints
));
858 f
->output_data
.x
->size_hints
= size_hints
;
859 f
->output_data
.x
->hint_flags
= hint_flags
;
862 flags
= f
->size_hint_flags
;
864 size_hints
= f
->output_data
.x
->size_hints
;
865 hint_flags
= f
->output_data
.x
->hint_flags
;
867 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
868 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
869 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
871 hint_flags
|= GDK_HINT_BASE_SIZE
;
872 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
873 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
874 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
876 check_frame_size (f
, &min_rows
, &min_cols
);
878 size_hints
.base_width
= base_width
;
879 size_hints
.base_height
= base_height
;
880 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
881 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
884 /* These currently have a one to one mapping with the X values, but I
885 don't think we should rely on that. */
886 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
887 size_hints
.win_gravity
= 0;
888 if (win_gravity
== NorthWestGravity
)
889 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
890 else if (win_gravity
== NorthGravity
)
891 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
892 else if (win_gravity
== NorthEastGravity
)
893 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
894 else if (win_gravity
== WestGravity
)
895 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
896 else if (win_gravity
== CenterGravity
)
897 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
898 else if (win_gravity
== EastGravity
)
899 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
900 else if (win_gravity
== SouthWestGravity
)
901 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
902 else if (win_gravity
== SouthGravity
)
903 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
904 else if (win_gravity
== SouthEastGravity
)
905 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
906 else if (win_gravity
== StaticGravity
)
907 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
909 if (flags
& PPosition
) hint_flags
|= GDK_HINT_POS
;
910 if (flags
& USPosition
) hint_flags
|= GDK_HINT_USER_POS
;
911 if (flags
& USSize
) hint_flags
|= GDK_HINT_USER_SIZE
;
915 hint_flags
&= ~GDK_HINT_POS
;
916 hint_flags
|= GDK_HINT_USER_POS
;
921 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
922 FRAME_GTK_OUTER_WIDGET (f
),
926 f
->output_data
.x
->size_hints
= size_hints
;
927 f
->output_data
.x
->hint_flags
= hint_flags
;
932 /* Change background color of a frame.
933 Since GTK uses the background colour to clear the window, we must
934 keep the GTK and X colors in sync.
935 F is the frame to change,
936 BG is the pixel value to change to. */
939 xg_set_background_color (f
, bg
)
943 if (FRAME_GTK_WIDGET (f
))
948 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
949 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
956 /***********************************************************************
958 ***********************************************************************/
959 /* Return the dialog title to use for a dialog of type KEY.
960 This is the encoding used by lwlib. We use the same for GTK. */
963 get_dialog_title (char key
)
973 title
= "Information";
992 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
993 the dialog, but return TRUE so the event does not propagate further
994 in GTK. This prevents GTK from destroying the dialog widget automatically
995 and we can always destrou the widget manually, regardles of how
996 it was popped down (button press or WM_DELETE_WINDOW).
997 W is the dialog widget.
998 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
999 user_data is NULL (not used).
1001 Returns TRUE to end propagation of event. */
1004 dialog_delete_callback (w
, event
, user_data
)
1009 gtk_widget_unmap (w
);
1013 /* Create a popup dialog window. See also xg_create_widget below.
1014 WV is a widget_value describing the dialog.
1015 SELECT_CB is the callback to use when a button has been pressed.
1016 DEACTIVATE_CB is the callback to use when the dialog pops down.
1018 Returns the GTK dialog widget. */
1021 create_dialog (wv
, select_cb
, deactivate_cb
)
1023 GCallback select_cb
;
1024 GCallback deactivate_cb
;
1026 char *title
= get_dialog_title (wv
->name
[0]);
1027 int total_buttons
= wv
->name
[1] - '0';
1028 int right_buttons
= wv
->name
[4] - '0';
1031 int button_spacing
= 10;
1032 GtkWidget
*wdialog
= gtk_dialog_new ();
1036 GtkWidget
*whbox_up
;
1037 GtkWidget
*whbox_down
;
1039 /* If the number of buttons is greater than 4, make two rows of buttons
1040 instead. This looks better. */
1041 int make_two_rows
= total_buttons
> 4;
1043 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1044 left_buttons
= total_buttons
- right_buttons
;
1046 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1047 gtk_widget_set_name (wdialog
, "emacs-dialog");
1049 cur_box
= GTK_BOX (GTK_DIALOG (wdialog
)->action_area
);
1053 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1054 whbox_up
= gtk_hbox_new (FALSE
, 0);
1055 whbox_down
= gtk_hbox_new (FALSE
, 0);
1057 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1058 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1059 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1061 cur_box
= GTK_BOX (whbox_up
);
1064 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1065 G_CALLBACK (dialog_delete_callback
), 0);
1069 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1070 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1073 for (item
= wv
->contents
; item
; item
= item
->next
)
1075 char *utf8_label
= get_utf8_string (item
->value
);
1079 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1081 /* This is the text part of the dialog. */
1082 w
= gtk_label_new (utf8_label
);
1083 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1086 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
), w
,
1088 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1090 /* Try to make dialog look better. Must realize first so
1091 the widget can calculate the size it needs. */
1092 gtk_widget_realize (w
);
1093 gtk_widget_size_request (w
, &req
);
1094 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1096 if (item
->value
&& strlen (item
->value
) > 0)
1097 button_spacing
= 2*req
.width
/strlen (item
->value
);
1101 /* This is one button to add to the dialog. */
1102 w
= gtk_button_new_with_label (utf8_label
);
1103 if (! item
->enabled
)
1104 gtk_widget_set_sensitive (w
, FALSE
);
1106 g_signal_connect (G_OBJECT (w
), "clicked",
1107 select_cb
, item
->call_data
);
1109 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1110 if (++button_nr
== left_buttons
)
1113 cur_box
= GTK_BOX (whbox_down
);
1115 gtk_box_pack_start (cur_box
,
1122 if (utf8_label
&& utf8_label
!= item
->value
)
1123 g_free (utf8_label
);
1131 /***********************************************************************
1132 File dialog functions
1133 ***********************************************************************/
1134 /* Function that is called when the file dialog pops down.
1135 W is the dialog widget, RESPONSE is the response code.
1136 USER_DATA is what we passed in to g_signal_connect (pointer to int). */
1139 xg_file_response_cb (w
,
1146 int *ptr
= (int *) user_data
;
1151 /* Destroy the dialog. This makes it pop down. */
1154 pop_down_file_dialog (arg
)
1157 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1159 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1164 typedef char * (*xg_get_file_func
) P_ ((GtkWidget
*));
1166 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1168 /* Return the selected file for file chooser dialog W.
1169 The returned string must be free:d. */
1172 xg_get_file_name_from_chooser (w
)
1175 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1178 /* Read a file name from the user using a file chooser dialog.
1179 F is the current frame.
1180 PROMPT is a prompt to show to the user. May not be NULL.
1181 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1182 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1183 file. *FUNC is set to a function that can be used to retrieve the
1184 selected file name from the returned widget.
1186 Returns the created widget. */
1189 xg_get_file_with_chooser (f
, prompt
, default_filename
,
1190 mustmatch_p
, only_dir_p
, func
)
1193 char *default_filename
;
1194 int mustmatch_p
, only_dir_p
;
1195 xg_get_file_func
*func
;
1198 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1199 GtkFileChooserAction action
= (mustmatch_p
?
1200 GTK_FILE_CHOOSER_ACTION_OPEN
:
1201 GTK_FILE_CHOOSER_ACTION_SAVE
);
1204 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1206 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1207 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1208 (mustmatch_p
|| only_dir_p
?
1209 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1212 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1214 if (default_filename
)
1217 struct gcpro gcpro1
;
1220 file
= build_string (default_filename
);
1222 /* File chooser does not understand ~/... in the file name. It must be
1223 an absolute name starting with /. */
1224 if (default_filename
[0] != '/')
1225 file
= Fexpand_file_name (file
, Qnil
);
1227 default_filename
= SDATA (file
);
1228 if (Ffile_directory_p (file
))
1229 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1232 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1238 *func
= xg_get_file_name_from_chooser
;
1241 #endif /* HAVE_GTK_FILE_CHOOSER_DIALOG_NEW */
1243 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1245 /* Return the selected file for file selector dialog W.
1246 The returned string must be free:d. */
1249 xg_get_file_name_from_selector (w
)
1252 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1253 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1256 /* Create a file selection dialog.
1257 F is the current frame.
1258 PROMPT is a prompt to show to the user. May not be NULL.
1259 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1260 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1261 file. *FUNC is set to a function that can be used to retrieve the
1262 selected file name from the returned widget.
1264 Returns the created widget. */
1267 xg_get_file_with_selection (f
, prompt
, default_filename
,
1268 mustmatch_p
, only_dir_p
, func
)
1271 char *default_filename
;
1272 int mustmatch_p
, only_dir_p
;
1273 xg_get_file_func
*func
;
1276 GtkFileSelection
*filesel
;
1278 filewin
= gtk_file_selection_new (prompt
);
1279 filesel
= GTK_FILE_SELECTION (filewin
);
1281 if (default_filename
)
1282 gtk_file_selection_set_filename (filesel
, default_filename
);
1286 /* The selection_entry part of filesel is not documented. */
1287 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1288 gtk_file_selection_hide_fileop_buttons (filesel
);
1291 *func
= xg_get_file_name_from_selector
;
1295 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1297 /* Read a file name from the user using a file dialog, either the old
1298 file selection dialog, or the new file chooser dialog. Which to use
1299 depends on what the GTK version used has, and what the value of
1300 gtk-use-old-file-dialog.
1301 F is the current frame.
1302 PROMPT is a prompt to show to the user. May not be NULL.
1303 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1304 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1307 Returns a file name or NULL if no file was selected.
1308 The returned string must be freed by the caller. */
1311 xg_get_file_name (f
, prompt
, default_filename
, mustmatch_p
, only_dir_p
)
1314 char *default_filename
;
1315 int mustmatch_p
, only_dir_p
;
1318 int count
= SPECPDL_INDEX ();
1320 int filesel_done
= 0;
1321 xg_get_file_func func
;
1322 extern int x_use_old_gtk_file_dialog
;
1324 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1325 /* I really don't know why this is needed, but without this the GLIBC add on
1326 library linuxthreads hangs when the Gnome file chooser backend creates
1328 sigblock (sigmask (__SIGRTMIN
));
1329 #endif /* HAVE_GTK_AND_PTHREAD */
1331 #ifdef HAVE_GTK_FILE_BOTH
1333 if (x_use_old_gtk_file_dialog
)
1334 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1335 mustmatch_p
, only_dir_p
, &func
);
1337 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1338 mustmatch_p
, only_dir_p
, &func
);
1340 #else /* not HAVE_GTK_FILE_BOTH */
1342 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1343 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1344 mustmatch_p
, only_dir_p
, &func
);
1346 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1347 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1348 mustmatch_p
, only_dir_p
, &func
);
1351 #endif /* HAVE_GTK_FILE_BOTH */
1353 xg_set_screen (w
, f
);
1354 gtk_widget_set_name (w
, "emacs-filedialog");
1355 gtk_window_set_transient_for (GTK_WINDOW (w
),
1356 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1357 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1358 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1360 g_signal_connect (G_OBJECT (w
),
1362 G_CALLBACK (xg_file_response_cb
),
1365 /* Don't destroy the widget if closed by the window manager close button. */
1366 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1368 gtk_widget_show (w
);
1370 record_unwind_protect (pop_down_file_dialog
, make_save_value (w
, 0));
1371 while (! filesel_done
)
1373 x_menu_wait_for_event (0);
1374 gtk_main_iteration ();
1377 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1378 sigunblock (sigmask (__SIGRTMIN
));
1381 if (filesel_done
== GTK_RESPONSE_OK
)
1384 unbind_to (count
, Qnil
);
1390 /***********************************************************************
1392 ***********************************************************************/
1394 /* The name of menu items that can be used for citomization. Since GTK
1395 RC files are very crude and primitive, we have to set this on all
1396 menu item names so a user can easily cutomize menu items. */
1398 #define MENU_ITEM_NAME "emacs-menuitem"
1401 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1402 during GC. The next member points to the items. */
1403 static xg_list_node xg_menu_cb_list
;
1405 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1406 during GC. The next member points to the items. */
1407 static xg_list_node xg_menu_item_cb_list
;
1409 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1410 F is the frame CL_DATA will be initialized for.
1411 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1413 The menu bar and all sub menus under the menu bar in a frame
1414 share the same structure, hence the reference count.
1416 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1417 allocated xg_menu_cb_data if CL_DATA is NULL. */
1419 static xg_menu_cb_data
*
1420 make_cl_data (cl_data
, f
, highlight_cb
)
1421 xg_menu_cb_data
*cl_data
;
1423 GCallback highlight_cb
;
1427 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1429 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1430 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1431 cl_data
->highlight_cb
= highlight_cb
;
1432 cl_data
->ref_count
= 0;
1434 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1437 cl_data
->ref_count
++;
1442 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1443 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1445 When the menu bar is updated, menu items may have been added and/or
1446 removed, so menu_bar_vector and menu_bar_items_used change. We must
1447 then update CL_DATA since it is used to determine which menu
1448 item that is invoked in the menu.
1449 HIGHLIGHT_CB could change, there is no check that the same
1450 function is given when modifying a menu bar as was given when
1451 creating the menu bar. */
1454 update_cl_data (cl_data
, f
, highlight_cb
)
1455 xg_menu_cb_data
*cl_data
;
1457 GCallback highlight_cb
;
1462 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1463 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1464 cl_data
->highlight_cb
= highlight_cb
;
1468 /* Decrease reference count for CL_DATA.
1469 If reference count is zero, free CL_DATA. */
1472 unref_cl_data (cl_data
)
1473 xg_menu_cb_data
*cl_data
;
1475 if (cl_data
&& cl_data
->ref_count
> 0)
1477 cl_data
->ref_count
--;
1478 if (cl_data
->ref_count
== 0)
1480 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1486 /* Function that marks all lisp data during GC. */
1493 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1494 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1496 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1498 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1500 if (! NILP (cb_data
->help
))
1501 mark_object (cb_data
->help
);
1506 /* Callback called when a menu item is destroyed. Used to free data.
1507 W is the widget that is being destroyed (not used).
1508 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1511 menuitem_destroy_callback (w
, client_data
)
1513 gpointer client_data
;
1517 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1518 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1523 /* Callback called when the pointer enters/leaves a menu item.
1525 EVENT is either an enter event or leave event.
1526 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W.
1528 Returns FALSE to tell GTK to keep processing this event. */
1531 menuitem_highlight_callback (w
, event
, client_data
)
1533 GdkEventCrossing
*event
;
1534 gpointer client_data
;
1538 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1539 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : client_data
;
1541 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1543 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1544 (*func
) (w
, call_data
);
1551 /* Callback called when a menu is destroyed. Used to free data.
1552 W is the widget that is being destroyed (not used).
1553 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1556 menu_destroy_callback (w
, client_data
)
1558 gpointer client_data
;
1560 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1563 /* Callback called when a menu does a grab or ungrab. That means the
1564 menu has been activated or deactivated.
1565 Used to start a timer so the small timeout the menus in GTK uses before
1566 popping down a menu is seen by Emacs (see xg_process_timeouts above).
1567 W is the widget that does the grab (not used).
1568 UNGRAB_P is TRUE if this is an ungrab, FALSE if it is a grab.
1569 CLIENT_DATA is NULL (not used). */
1572 menu_grab_callback (GtkWidget
*widget
,
1574 gpointer client_data
)
1576 /* Keep track of total number of grabs. */
1579 if (ungrab_p
) cnt
--;
1582 if (cnt
> 0 && ! xg_timer
) xg_start_timer ();
1583 else if (cnt
== 0 && xg_timer
) xg_stop_timer ();
1586 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1587 must be non-NULL) and can be inserted into a menu item.
1589 Returns the GtkHBox. */
1592 make_widget_for_menu_item (utf8_label
, utf8_key
)
1600 wbox
= gtk_hbox_new (FALSE
, 0);
1601 wlbl
= gtk_label_new (utf8_label
);
1602 wkey
= gtk_label_new (utf8_key
);
1604 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1605 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1607 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1608 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1610 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1611 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1612 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1617 /* Make and return a menu item widget with the key to the right.
1618 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1619 UTF8_KEY is the text representing the key binding.
1620 ITEM is the widget_value describing the menu item.
1622 GROUP is an in/out parameter. If the menu item to be created is not
1623 part of any radio menu group, *GROUP contains NULL on entry and exit.
1624 If the menu item to be created is part of a radio menu group, on entry
1625 *GROUP contains the group to use, or NULL if this is the first item
1626 in the group. On exit, *GROUP contains the radio item group.
1628 Unfortunately, keys don't line up as nicely as in Motif,
1629 but the MacOS X version doesn't either, so I guess that is OK. */
1632 make_menu_item (utf8_label
, utf8_key
, item
, group
)
1639 GtkWidget
*wtoadd
= 0;
1641 /* It has been observed that some menu items have a NULL name field.
1642 This will lead to this function being called with a NULL utf8_label.
1643 GTK crashes on that so we set a blank label. Why there is a NULL
1644 name remains to be investigated. */
1645 if (! utf8_label
) utf8_label
= " ";
1648 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1650 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1653 if (utf8_key
) w
= gtk_check_menu_item_new ();
1654 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1655 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1657 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1659 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1660 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1661 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1663 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1668 if (utf8_key
) w
= gtk_menu_item_new ();
1669 else w
= gtk_menu_item_new_with_label (utf8_label
);
1672 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1673 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1678 /* Return non-zero if LABEL specifies a separator (GTK only has one
1682 xg_separator_p (char *label
)
1684 if (! label
) return 0;
1685 else if (strlen (label
) > 3
1686 && strncmp (label
, "--", 2) == 0
1689 static char* separator_names
[] = {
1694 "single-dashed-line",
1695 "double-dashed-line",
1697 "shadow-etched-out",
1698 "shadow-etched-in-dash",
1699 "shadow-etched-out-dash",
1700 "shadow-double-etched-in",
1701 "shadow-double-etched-out",
1702 "shadow-double-etched-in-dash",
1703 "shadow-double-etched-out-dash",
1710 for (i
= 0; separator_names
[i
]; ++i
)
1711 if (strcmp (label
, separator_names
[i
]) == 0)
1716 /* Old-style separator, maybe. It's a separator if it contains
1718 while (*label
== '-')
1720 if (*label
== 0) return 1;
1726 static int xg_detached_menus
;
1728 /* Returns non-zero if there are detached menus. */
1731 xg_have_tear_offs ()
1733 return xg_detached_menus
> 0;
1736 /* Callback invoked when a detached menu window is removed. Here we
1737 decrease the xg_detached_menus count.
1738 WIDGET is the top level window that is removed (the parent of the menu).
1739 CLIENT_DATA is not used. */
1742 tearoff_remove (widget
, client_data
)
1744 gpointer client_data
;
1746 if (xg_detached_menus
> 0) --xg_detached_menus
;
1749 /* Callback invoked when a menu is detached. It increases the
1750 xg_detached_menus count.
1751 WIDGET is the GtkTearoffMenuItem.
1752 CLIENT_DATA is not used. */
1755 tearoff_activate (widget
, client_data
)
1757 gpointer client_data
;
1759 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
1760 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
1762 ++xg_detached_menus
;
1763 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
1765 G_CALLBACK (tearoff_remove
), 0);
1770 /* Create a menu item widget, and connect the callbacks.
1771 ITEM decribes the menu item.
1772 F is the frame the created menu belongs to.
1773 SELECT_CB is the callback to use when a menu item is selected.
1774 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1775 CL_DATA points to the callback data to be used for this menu.
1776 GROUP is an in/out parameter. If the menu item to be created is not
1777 part of any radio menu group, *GROUP contains NULL on entry and exit.
1778 If the menu item to be created is part of a radio menu group, on entry
1779 *GROUP contains the group to use, or NULL if this is the first item
1780 in the group. On exit, *GROUP contains the radio item group.
1782 Returns the created GtkWidget. */
1785 xg_create_one_menuitem (item
, f
, select_cb
, highlight_cb
, cl_data
, group
)
1788 GCallback select_cb
;
1789 GCallback highlight_cb
;
1790 xg_menu_cb_data
*cl_data
;
1796 xg_menu_item_cb_data
*cb_data
;
1798 utf8_label
= get_utf8_string (item
->name
);
1799 utf8_key
= get_utf8_string (item
->key
);
1801 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
1803 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
1804 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
1806 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
1808 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
1810 cb_data
->unhighlight_id
= cb_data
->highlight_id
= cb_data
->select_id
= 0;
1811 cb_data
->help
= item
->help
;
1812 cb_data
->cl_data
= cl_data
;
1813 cb_data
->call_data
= item
->call_data
;
1815 g_signal_connect (G_OBJECT (w
),
1817 G_CALLBACK (menuitem_destroy_callback
),
1820 /* Put cb_data in widget, so we can get at it when modifying menubar */
1821 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
1823 /* final item, not a submenu */
1824 if (item
->call_data
&& ! item
->contents
)
1828 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
1831 if (! NILP (item
->help
) && highlight_cb
)
1833 /* We use enter/leave notify instead of select/deselect because
1834 select/deselect doesn't go well with detached menus. */
1835 cb_data
->highlight_id
1836 = g_signal_connect (G_OBJECT (w
),
1837 "enter-notify-event",
1838 G_CALLBACK (menuitem_highlight_callback
),
1840 cb_data
->unhighlight_id
1841 = g_signal_connect (G_OBJECT (w
),
1842 "leave-notify-event",
1843 G_CALLBACK (menuitem_highlight_callback
),
1850 static GtkWidget
*create_menus
P_ ((widget_value
*, FRAME_PTR
, GCallback
,
1851 GCallback
, GCallback
, int, int, int,
1852 GtkWidget
*, xg_menu_cb_data
*, char *));
1854 /* Create a full menu tree specified by DATA.
1855 F is the frame the created menu belongs to.
1856 SELECT_CB is the callback to use when a menu item is selected.
1857 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
1858 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1859 POP_UP_P is non-zero if we shall create a popup menu.
1860 MENU_BAR_P is non-zero if we shall create a menu bar.
1861 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
1862 if MENU_BAR_P is non-zero.
1863 TOPMENU is the topmost GtkWidget that others shall be placed under.
1864 It may be NULL, in that case we create the appropriate widget
1865 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
1866 CL_DATA is the callback data we shall use for this menu, or NULL
1867 if we haven't set the first callback yet.
1868 NAME is the name to give to the top level menu if this function
1869 creates it. May be NULL to not set any name.
1871 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
1874 This function calls itself to create submenus. */
1877 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
1878 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
1881 GCallback select_cb
;
1882 GCallback deactivate_cb
;
1883 GCallback highlight_cb
;
1888 xg_menu_cb_data
*cl_data
;
1892 GtkWidget
*wmenu
= topmenu
;
1893 GSList
*group
= NULL
;
1899 wmenu
= gtk_menu_new ();
1900 xg_set_screen (wmenu
, f
);
1902 else wmenu
= gtk_menu_bar_new ();
1904 /* Put cl_data on the top menu for easier access. */
1905 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
1906 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
1907 g_signal_connect (G_OBJECT (wmenu
), "destroy",
1908 G_CALLBACK (menu_destroy_callback
), cl_data
);
1911 gtk_widget_set_name (wmenu
, name
);
1914 g_signal_connect (G_OBJECT (wmenu
),
1915 "selection-done", deactivate_cb
, 0);
1917 g_signal_connect (G_OBJECT (wmenu
),
1918 "grab-notify", G_CALLBACK (menu_grab_callback
), 0);
1921 if (! menu_bar_p
&& add_tearoff_p
)
1923 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
1924 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
1926 g_signal_connect (G_OBJECT (tearoff
), "activate",
1927 G_CALLBACK (tearoff_activate
), 0);
1930 for (item
= data
; item
; item
= item
->next
)
1934 if (pop_up_p
&& !item
->contents
&& !item
->call_data
1935 && !xg_separator_p (item
->name
))
1938 /* A title for a popup. We do the same as GTK does when
1939 creating titles, but it does not look good. */
1941 utf8_label
= get_utf8_string (item
->name
);
1943 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
1944 w
= gtk_menu_item_new_with_label (utf8_label
);
1945 gtk_widget_set_sensitive (w
, FALSE
);
1946 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
1948 else if (xg_separator_p (item
->name
))
1951 /* GTK only have one separator type. */
1952 w
= gtk_separator_menu_item_new ();
1956 w
= xg_create_one_menuitem (item
,
1958 item
->contents
? 0 : select_cb
,
1965 GtkWidget
*submenu
= create_menus (item
->contents
,
1976 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
1980 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
1981 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
1987 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
1988 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
1989 with some text and buttons.
1990 F is the frame the created item belongs to.
1991 NAME is the name to use for the top widget.
1992 VAL is a widget_value structure describing items to be created.
1993 SELECT_CB is the callback to use when a menu item is selected or
1994 a dialog button is pressed.
1995 DEACTIVATE_CB is the callback to use when an item is deactivated.
1996 For a menu, when a sub menu is not shown anymore, for a dialog it is
1997 called when the dialog is popped down.
1998 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2000 Returns the widget created. */
2003 xg_create_widget (type
, name
, f
, val
,
2004 select_cb
, deactivate_cb
, highlight_cb
)
2009 GCallback select_cb
;
2010 GCallback deactivate_cb
;
2011 GCallback highlight_cb
;
2014 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2015 int pop_up_p
= strcmp (type
, "popup") == 0;
2017 if (strcmp (type
, "dialog") == 0)
2019 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2020 xg_set_screen (w
, f
);
2021 gtk_window_set_transient_for (GTK_WINDOW (w
),
2022 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2023 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2024 gtk_widget_set_name (w
, "emacs-dialog");
2025 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2027 else if (menu_bar_p
|| pop_up_p
)
2029 w
= create_menus (val
->contents
,
2041 /* Set the cursor to an arrow for popup menus when they are mapped.
2042 This is done by default for menu bar menus. */
2045 /* Must realize so the GdkWindow inside the widget is created. */
2046 gtk_widget_realize (w
);
2047 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2052 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2059 /* Return the label for menu item WITEM. */
2062 xg_get_menu_item_label (witem
)
2065 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2066 return gtk_label_get_label (wlabel
);
2069 /* Return non-zero if the menu item WITEM has the text LABEL. */
2072 xg_item_label_same_p (witem
, label
)
2077 char *utf8_label
= get_utf8_string (label
);
2078 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2080 if (! old_label
&& ! utf8_label
)
2082 else if (old_label
&& utf8_label
)
2083 is_same
= strcmp (utf8_label
, old_label
) == 0;
2085 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2090 /* Destroy widgets in LIST. */
2093 xg_destroy_widgets (list
)
2098 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2100 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2102 /* Destroying the widget will remove it from the container it is in. */
2103 gtk_widget_destroy (w
);
2107 /* Update the top level names in MENUBAR (i.e. not submenus).
2108 F is the frame the menu bar belongs to.
2109 *LIST is a list with the current menu bar names (menu item widgets).
2110 ITER is the item within *LIST that shall be updated.
2111 POS is the numerical position, starting at 0, of ITER in *LIST.
2112 VAL describes what the menu bar shall look like after the update.
2113 SELECT_CB is the callback to use when a menu item is selected.
2114 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2115 CL_DATA points to the callback data to be used for this menu bar.
2117 This function calls itself to walk through the menu bar names. */
2120 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2121 select_cb
, highlight_cb
, cl_data
)
2128 GCallback select_cb
;
2129 GCallback highlight_cb
;
2130 xg_menu_cb_data
*cl_data
;
2132 if (! iter
&& ! val
)
2134 else if (iter
&& ! val
)
2136 /* Item(s) have been removed. Remove all remaining items. */
2137 xg_destroy_widgets (iter
);
2143 else if (! iter
&& val
)
2145 /* Item(s) added. Add all new items in one call. */
2146 create_menus (val
, f
, select_cb
, 0, highlight_cb
,
2147 0, 1, 0, menubar
, cl_data
, 0);
2153 /* Below this neither iter or val is NULL */
2154 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2156 /* This item is still the same, check next item. */
2158 iter
= g_list_next (iter
);
2161 else /* This item is changed. */
2163 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2164 GtkMenuItem
*witem2
= 0;
2165 int val_in_menubar
= 0;
2166 int iter_in_new_menubar
= 0;
2170 /* See if the changed entry (val) is present later in the menu bar */
2172 iter2
&& ! val_in_menubar
;
2173 iter2
= g_list_next (iter2
))
2175 witem2
= GTK_MENU_ITEM (iter2
->data
);
2176 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2179 /* See if the current entry (iter) is present later in the
2180 specification for the new menu bar. */
2181 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2182 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2184 if (val_in_menubar
&& ! iter_in_new_menubar
)
2188 /* This corresponds to:
2193 gtk_widget_ref (GTK_WIDGET (witem
));
2194 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2195 gtk_widget_destroy (GTK_WIDGET (witem
));
2197 /* Must get new list since the old changed. */
2198 g_list_free (*list
);
2199 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2200 while (nr
-- > 0) iter
= g_list_next (iter
);
2202 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2204 /* This corresponds to:
2207 Rename B to X. This might seem to be a strange thing to do,
2208 since if there is a menu under B it will be totally wrong for X.
2209 But consider editing a C file. Then there is a C-mode menu
2210 (corresponds to B above).
2211 If then doing C-x C-f the minibuf menu (X above) replaces the
2212 C-mode menu. When returning from the minibuffer, we get
2213 back the C-mode menu. Thus we do:
2214 Rename B to X (C-mode to minibuf menu)
2215 Rename X to B (minibuf to C-mode menu).
2216 If the X menu hasn't been invoked, the menu under B
2217 is up to date when leaving the minibuffer. */
2218 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2219 char *utf8_label
= get_utf8_string (val
->name
);
2220 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2222 gtk_label_set_text (wlabel
, utf8_label
);
2224 /* If this item has a submenu that has been detached, change
2225 the title in the WM decorations also. */
2226 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2227 /* Set the title of the detached window. */
2228 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2230 iter
= g_list_next (iter
);
2234 else if (! val_in_menubar
&& iter_in_new_menubar
)
2236 /* This corresponds to:
2243 GtkWidget
*w
= xg_create_one_menuitem (val
,
2250 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2251 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2253 g_list_free (*list
);
2254 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2255 while (nr
-- > 0) iter
= g_list_next (iter
);
2256 iter
= g_list_next (iter
);
2260 else /* if (val_in_menubar && iter_in_new_menubar) */
2263 /* This corresponds to:
2268 gtk_widget_ref (GTK_WIDGET (witem2
));
2269 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2270 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2271 GTK_WIDGET (witem2
), pos
);
2272 gtk_widget_unref (GTK_WIDGET (witem2
));
2274 g_list_free (*list
);
2275 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2276 while (nr
-- > 0) iter
= g_list_next (iter
);
2282 /* Update the rest of the menu bar. */
2283 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2284 select_cb
, highlight_cb
, cl_data
);
2287 /* Update the menu item W so it corresponds to VAL.
2288 SELECT_CB is the callback to use when a menu item is selected.
2289 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2290 CL_DATA is the data to set in the widget for menu invokation. */
2293 xg_update_menu_item (val
, w
, select_cb
, highlight_cb
, cl_data
)
2296 GCallback select_cb
;
2297 GCallback highlight_cb
;
2298 xg_menu_cb_data
*cl_data
;
2305 const char *old_label
= 0;
2306 const char *old_key
= 0;
2307 xg_menu_item_cb_data
*cb_data
;
2309 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2310 utf8_label
= get_utf8_string (val
->name
);
2311 utf8_key
= get_utf8_string (val
->key
);
2313 /* See if W is a menu item with a key. See make_menu_item above. */
2314 if (GTK_IS_HBOX (wchild
))
2316 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2318 wlbl
= GTK_LABEL (list
->data
);
2319 wkey
= GTK_LABEL (list
->next
->data
);
2324 /* Remove the key and keep just the label. */
2325 gtk_widget_ref (GTK_WIDGET (wlbl
));
2326 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2327 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2332 else /* Just a label. */
2334 wlbl
= GTK_LABEL (wchild
);
2336 /* Check if there is now a key. */
2339 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2340 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2342 wlbl
= GTK_LABEL (list
->data
);
2343 wkey
= GTK_LABEL (list
->next
->data
);
2346 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2347 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2352 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2353 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2355 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2356 gtk_label_set_text (wkey
, utf8_key
);
2358 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2359 gtk_label_set_text (wlbl
, utf8_label
);
2361 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2362 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2364 if (! val
->enabled
&& GTK_WIDGET_SENSITIVE (w
))
2365 gtk_widget_set_sensitive (w
, FALSE
);
2366 else if (val
->enabled
&& ! GTK_WIDGET_SENSITIVE (w
))
2367 gtk_widget_set_sensitive (w
, TRUE
);
2369 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2373 cb_data
->call_data
= val
->call_data
;
2374 cb_data
->help
= val
->help
;
2375 cb_data
->cl_data
= cl_data
;
2377 /* We assume the callback functions don't change. */
2378 if (val
->call_data
&& ! val
->contents
)
2380 /* This item shall have a select callback. */
2381 if (! cb_data
->select_id
)
2383 = g_signal_connect (G_OBJECT (w
), "activate",
2384 select_cb
, cb_data
);
2386 else if (cb_data
->select_id
)
2388 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2389 cb_data
->select_id
= 0;
2392 if (NILP (cb_data
->help
))
2394 /* Shall not have help. Remove if any existed previously. */
2395 if (cb_data
->highlight_id
)
2397 g_signal_handler_disconnect (G_OBJECT (w
),
2398 cb_data
->highlight_id
);
2399 cb_data
->highlight_id
= 0;
2401 if (cb_data
->unhighlight_id
)
2403 g_signal_handler_disconnect (G_OBJECT (w
),
2404 cb_data
->unhighlight_id
);
2405 cb_data
->unhighlight_id
= 0;
2408 else if (! cb_data
->highlight_id
&& highlight_cb
)
2410 /* Have help now, but didn't previously. Add callback. */
2411 cb_data
->highlight_id
2412 = g_signal_connect (G_OBJECT (w
),
2413 "enter-notify-event",
2414 G_CALLBACK (menuitem_highlight_callback
),
2416 cb_data
->unhighlight_id
2417 = g_signal_connect (G_OBJECT (w
),
2418 "leave-notify-event",
2419 G_CALLBACK (menuitem_highlight_callback
),
2425 /* Update the toggle menu item W so it corresponds to VAL. */
2428 xg_update_toggle_item (val
, w
)
2432 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2435 /* Update the radio menu item W so it corresponds to VAL. */
2438 xg_update_radio_item (val
, w
)
2442 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2445 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2446 SUBMENU may be NULL, in that case a new menu is created.
2447 F is the frame the menu bar belongs to.
2448 VAL describes the contents of the menu bar.
2449 SELECT_CB is the callback to use when a menu item is selected.
2450 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2451 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2452 CL_DATA is the call back data to use for any newly created items.
2454 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2458 xg_update_submenu (submenu
, f
, val
,
2459 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2463 GCallback select_cb
;
2464 GCallback deactivate_cb
;
2465 GCallback highlight_cb
;
2466 xg_menu_cb_data
*cl_data
;
2468 GtkWidget
*newsub
= submenu
;
2472 int has_tearoff_p
= 0;
2473 GList
*first_radio
= 0;
2476 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2478 for (cur
= val
, iter
= list
;
2480 iter
= g_list_next (iter
), cur
= cur
->next
)
2482 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2484 /* Skip tearoff items, they have no counterpart in val. */
2485 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2488 iter
= g_list_next (iter
);
2489 if (iter
) w
= GTK_WIDGET (iter
->data
);
2493 /* Remember first radio button in a group. If we get a mismatch in
2494 a radio group we must rebuild the whole group so that the connections
2495 in GTK becomes correct. */
2496 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2498 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2499 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2502 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2504 if (! xg_separator_p (cur
->name
))
2507 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2509 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2511 xg_update_toggle_item (cur
, w
);
2512 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2514 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2516 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2518 xg_update_radio_item (cur
, w
);
2519 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2521 else if (GTK_IS_MENU_ITEM (w
))
2523 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2526 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2527 xg_separator_p (cur
->name
))
2530 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2532 sub
= gtk_menu_item_get_submenu (witem
);
2533 if (sub
&& ! cur
->contents
)
2535 /* Not a submenu anymore. */
2536 gtk_widget_ref (sub
);
2537 gtk_menu_item_remove_submenu (witem
);
2538 gtk_widget_destroy (sub
);
2540 else if (cur
->contents
)
2544 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2545 select_cb
, deactivate_cb
,
2546 highlight_cb
, cl_data
);
2548 /* If this item just became a submenu, we must set it. */
2550 gtk_menu_item_set_submenu (witem
, nsub
);
2555 /* Structural difference. Remove everything from here and down
2561 /* Remove widgets from first structual change. */
2564 /* If we are adding new menu items below, we must remove from
2565 first radio button so that radio groups become correct. */
2566 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2567 else xg_destroy_widgets (iter
);
2572 /* More items added. Create them. */
2573 newsub
= create_menus (cur
,
2586 if (list
) g_list_free (list
);
2591 /* Update the MENUBAR.
2592 F is the frame the menu bar belongs to.
2593 VAL describes the contents of the menu bar.
2594 If DEEP_P is non-zero, rebuild all but the top level menu names in
2595 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2596 SELECT_CB is the callback to use when a menu item is selected.
2597 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2598 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2601 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2602 select_cb
, deactivate_cb
, highlight_cb
)
2607 GCallback select_cb
;
2608 GCallback deactivate_cb
;
2609 GCallback highlight_cb
;
2611 xg_menu_cb_data
*cl_data
;
2612 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2616 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2619 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2620 select_cb
, highlight_cb
, cl_data
);
2626 /* Update all sub menus.
2627 We must keep the submenus (GTK menu item widgets) since the
2628 X Window in the XEvent that activates the menu are those widgets. */
2630 /* Update cl_data, menu_item things in F may have changed. */
2631 update_cl_data (cl_data
, f
, highlight_cb
);
2633 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2640 /* Find sub menu that corresponds to val and update it. */
2641 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2643 witem
= GTK_MENU_ITEM (iter
->data
);
2644 if (xg_item_label_same_p (witem
, cur
->name
))
2646 sub
= gtk_menu_item_get_submenu (witem
);
2651 newsub
= xg_update_submenu (sub
,
2658 /* sub may still be NULL. If we just updated non deep and added
2659 a new menu bar item, it has no sub menu yet. So we set the
2660 newly created sub menu under witem. */
2663 xg_set_screen (newsub
, f
);
2664 gtk_menu_item_set_submenu (witem
, newsub
);
2670 gtk_widget_show_all (menubar
);
2673 /* Recompute all the widgets of frame F, when the menu bar has been
2674 changed. Value is non-zero if widgets were updated. */
2677 xg_update_frame_menubar (f
)
2680 struct x_output
*x
= f
->output_data
.x
;
2683 if (!x
->menubar_widget
|| GTK_WIDGET_MAPPED (x
->menubar_widget
))
2688 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2690 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2692 gtk_widget_show_all (x
->menubar_widget
);
2693 gtk_widget_size_request (x
->menubar_widget
, &req
);
2695 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2697 /* The height has changed, resize outer widget and set columns
2698 rows to what we had before adding the menu bar. */
2699 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2701 SET_FRAME_GARBAGED (f
);
2707 /* Get rid of the menu bar of frame F, and free its storage.
2708 This is used when deleting a frame, and when turning off the menu bar. */
2711 free_frame_menubar (f
)
2714 struct x_output
*x
= f
->output_data
.x
;
2716 if (x
->menubar_widget
)
2720 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2721 /* The menubar and its children shall be deleted when removed from
2723 x
->menubar_widget
= 0;
2724 FRAME_MENUBAR_HEIGHT (f
) = 0;
2726 /* The height has changed, resize outer widget and set columns
2727 rows to what we had before removing the menu bar. */
2728 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2730 SET_FRAME_GARBAGED (f
);
2737 /***********************************************************************
2738 Scroll bar functions
2739 ***********************************************************************/
2742 /* Setting scroll bar values invokes the callback. Use this variable
2743 to indicate that callback should do nothing. */
2745 int xg_ignore_gtk_scrollbar
;
2747 /* SET_SCROLL_BAR_X_WINDOW assumes the second argument fits in
2748 32 bits. But we want to store pointers, and they may be larger
2749 than 32 bits. Keep a mapping from integer index to widget pointers
2750 to get around the 32 bit limitation. */
2754 GtkWidget
**widgets
;
2759 /* Grow this much every time we need to allocate more */
2761 #define ID_TO_WIDGET_INCR 32
2763 /* Store the widget pointer W in id_to_widget and return the integer index. */
2766 xg_store_widget_in_map (w
)
2771 if (id_to_widget
.max_size
== id_to_widget
.used
)
2773 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
2775 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
2776 sizeof (GtkWidget
*)*new_size
);
2778 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
2779 id_to_widget
.widgets
[i
] = 0;
2780 id_to_widget
.max_size
= new_size
;
2783 /* Just loop over the array and find a free place. After all,
2784 how many scroll bars are we creating? Should be a small number.
2785 The check above guarantees we will find a free place. */
2786 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
2788 if (! id_to_widget
.widgets
[i
])
2790 id_to_widget
.widgets
[i
] = w
;
2791 ++id_to_widget
.used
;
2797 /* Should never end up here */
2801 /* Remove pointer at IDX from id_to_widget.
2802 Called when scroll bar is destroyed. */
2805 xg_remove_widget_from_map (idx
)
2808 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2810 id_to_widget
.widgets
[idx
] = 0;
2811 --id_to_widget
.used
;
2815 /* Get the widget pointer at IDX from id_to_widget. */
2818 xg_get_widget_from_map (idx
)
2821 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2822 return id_to_widget
.widgets
[idx
];
2827 /* Return the scrollbar id for X Window WID on display DPY.
2828 Return -1 if WID not in id_to_widget. */
2831 xg_get_scroll_id_for_window (dpy
, wid
)
2838 w
= xg_win_to_widget (dpy
, wid
);
2842 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
2843 if (id_to_widget
.widgets
[idx
] == w
)
2850 /* Callback invoked when scroll bar WIDGET is destroyed.
2851 DATA is the index into id_to_widget for WIDGET.
2852 We free pointer to last scroll bar values here and remove the index. */
2855 xg_gtk_scroll_destroy (widget
, data
)
2860 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
2862 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
2864 xg_remove_widget_from_map (id
);
2867 /* Callback for button press/release events. Used to start timer so that
2868 the scroll bar repetition timer in GTK gets handeled.
2869 Also, sets bar->dragging to Qnil when dragging (button release) is done.
2870 WIDGET is the scroll bar widget the event is for (not used).
2871 EVENT contains the event.
2872 USER_DATA points to the struct scrollbar structure.
2874 Returns FALSE to tell GTK that it shall continue propagate the event
2878 scroll_bar_button_cb (widget
, event
, user_data
)
2880 GdkEventButton
*event
;
2883 if (event
->type
== GDK_BUTTON_PRESS
&& ! xg_timer
)
2885 else if (event
->type
== GDK_BUTTON_RELEASE
)
2887 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
2888 if (xg_timer
) xg_stop_timer ();
2889 bar
->dragging
= Qnil
;
2895 /* Create a scroll bar widget for frame F. Store the scroll bar
2897 SCROLL_CALLBACK is the callback to invoke when the value of the
2899 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
2900 to set resources for the widget. */
2903 xg_create_scroll_bar (f
, bar
, scroll_callback
, scroll_bar_name
)
2905 struct scroll_bar
*bar
;
2906 GCallback scroll_callback
;
2907 char *scroll_bar_name
;
2914 /* Page, step increment values are not so important here, they
2915 will be corrected in x_set_toolkit_scroll_bar_thumb. */
2916 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
2919 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
2920 webox
= gtk_event_box_new ();
2921 gtk_widget_set_name (wscroll
, scroll_bar_name
);
2922 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
2924 scroll_id
= xg_store_widget_in_map (wscroll
);
2926 g_signal_connect (G_OBJECT (wscroll
),
2930 /* The EMACS_INT cast avoids a warning. */
2931 g_signal_connect (G_OBJECT (wscroll
),
2933 G_CALLBACK (xg_gtk_scroll_destroy
),
2934 (gpointer
) (EMACS_INT
) scroll_id
);
2936 /* Connect to button press and button release to detect if any scroll bar
2938 g_signal_connect (G_OBJECT (wscroll
),
2939 "button-press-event",
2940 G_CALLBACK (scroll_bar_button_cb
),
2942 g_signal_connect (G_OBJECT (wscroll
),
2943 "button-release-event",
2944 G_CALLBACK (scroll_bar_button_cb
),
2947 /* The scroll bar widget does not draw on a window of its own. Instead
2948 it draws on the parent window, in this case the edit widget. So
2949 whenever the edit widget is cleared, the scroll bar needs to redraw
2950 also, which causes flicker. Put an event box between the edit widget
2951 and the scroll bar, so the scroll bar instead draws itself on the
2952 event box window. */
2953 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
2954 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
2957 /* Set the cursor to an arrow. */
2958 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2960 SET_SCROLL_BAR_X_WINDOW (bar
, scroll_id
);
2963 /* Make the scroll bar represented by SCROLLBAR_ID visible. */
2966 xg_show_scroll_bar (scrollbar_id
)
2969 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
2971 gtk_widget_show_all (gtk_widget_get_parent (w
));
2974 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
2977 xg_remove_scroll_bar (f
, scrollbar_id
)
2981 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
2984 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
2985 gtk_widget_destroy (w
);
2986 gtk_widget_destroy (wparent
);
2987 SET_FRAME_GARBAGED (f
);
2991 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
2993 TOP/LEFT are the new pixel positions where the bar shall appear.
2994 WIDTH, HEIGHT is the size in pixels the bar shall have. */
2997 xg_update_scrollbar_pos (f
, scrollbar_id
, top
, left
, width
, height
)
3006 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3010 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3011 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3013 /* Move and resize to new values. */
3014 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3015 gtk_widget_set_size_request (wscroll
, width
, height
);
3016 gtk_widget_queue_draw (wparent
);
3017 gdk_window_process_all_updates ();
3018 /* GTK does not redraw until the main loop is entered again, but
3019 if there are no X events pending we will not enter it. So we sync
3020 here to get some events. */
3022 SET_FRAME_GARBAGED (f
);
3023 cancel_mouse_face (f
);
3027 /* Set the thumb size and position of scroll bar BAR. We are currently
3028 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3031 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
3032 struct scroll_bar
*bar
;
3033 int portion
, position
, whole
;
3035 GtkWidget
*wscroll
= xg_get_widget_from_map (SCROLL_BAR_X_WINDOW (bar
));
3037 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3039 if (wscroll
&& NILP (bar
->dragging
))
3048 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3050 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3051 rather than the real portion value. This makes the thumb less likely
3052 to resize and that looks better. */
3053 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3054 /* When the thumb is at the bottom, position == whole.
3055 So we need to increase `whole' to make space for the thumb. */
3062 top
= (gdouble
) position
/ whole
;
3063 shown
= (gdouble
) portion
/ whole
;
3066 size
= shown
* XG_SB_RANGE
;
3067 size
= min (size
, XG_SB_RANGE
);
3068 size
= max (size
, 1);
3070 value
= top
* XG_SB_RANGE
;
3071 value
= min (value
, XG_SB_MAX
- size
);
3072 value
= max (value
, XG_SB_MIN
);
3074 /* Assume all lines are of equal size. */
3075 new_step
= size
/ max (1, FRAME_LINES (f
));
3077 if ((int) adj
->page_size
!= size
3078 || (int) adj
->step_increment
!= new_step
)
3080 adj
->page_size
= size
;
3081 adj
->step_increment
= new_step
;
3082 /* Assume a page increment is about 95% of the page size */
3083 adj
->page_increment
= (int) (0.95*adj
->page_size
);
3087 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3089 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3093 /* gtk_range_set_value invokes the callback. Set
3094 ignore_gtk_scrollbar to make the callback do nothing */
3095 xg_ignore_gtk_scrollbar
= 1;
3097 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3098 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3100 gtk_adjustment_changed (adj
);
3102 xg_ignore_gtk_scrollbar
= 0;
3110 /***********************************************************************
3112 ***********************************************************************/
3113 /* The key for the data we put in the GtkImage widgets. The data is
3114 the image used by Emacs. We use this to see if we need to update
3115 the GtkImage with a new image. */
3116 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3118 /* Callback function invoked when a tool bar item is pressed.
3119 W is the button widget in the tool bar that got pressed,
3120 CLIENT_DATA is an integer that is the index of the button in the
3121 tool bar. 0 is the first button. */
3124 xg_tool_bar_callback (w
, client_data
)
3126 gpointer client_data
;
3128 /* The EMACS_INT cast avoids a warning. */
3129 int idx
= (int) (EMACS_INT
) client_data
;
3130 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3131 Lisp_Object key
, frame
;
3132 struct input_event event
;
3135 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3138 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3140 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3141 XSETFRAME (frame
, f
);
3142 event
.kind
= TOOL_BAR_EVENT
;
3143 event
.frame_or_window
= frame
;
3145 kbd_buffer_store_event (&event
);
3147 event
.kind
= TOOL_BAR_EVENT
;
3148 event
.frame_or_window
= frame
;
3150 event
.modifiers
= 0; /* These are not available. */
3151 kbd_buffer_store_event (&event
);
3154 /* This callback is called when a tool bar is detached. We must set
3155 the height of the tool bar to zero when this happens so frame sizes
3156 are correctly calculated.
3157 WBOX is the handle box widget that enables detach/attach of the tool bar.
3158 W is the tool bar widget.
3159 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3162 xg_tool_bar_detach_callback (wbox
, w
, client_data
)
3165 gpointer client_data
;
3167 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3171 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3173 /* When detaching a tool bar, not everything dissapear. There are
3174 a few pixels left that are used to drop the tool bar back into
3176 FRAME_TOOLBAR_HEIGHT (f
) = 2;
3178 /* The height has changed, resize outer widget and set columns
3179 rows to what we had before detaching the tool bar. */
3180 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3184 /* This callback is called when a tool bar is reattached. We must set
3185 the height of the tool bar when this happens so frame sizes
3186 are correctly calculated.
3187 WBOX is the handle box widget that enables detach/attach of the tool bar.
3188 W is the tool bar widget.
3189 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3192 xg_tool_bar_attach_callback (wbox
, w
, client_data
)
3195 gpointer client_data
;
3197 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3203 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3205 gtk_widget_size_request (w
, &req
);
3206 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3208 /* The height has changed, resize outer widget and set columns
3209 rows to what we had before attaching the tool bar. */
3210 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3214 /* This callback is called when the mouse enters or leaves a tool bar item.
3215 It is used for displaying and hiding the help text.
3216 W is the tool bar item, a button.
3217 EVENT is either an enter event or leave event.
3218 CLIENT_DATA is an integer that is the index of the button in the
3219 tool bar. 0 is the first button.
3221 Returns FALSE to tell GTK to keep processing this event. */
3224 xg_tool_bar_help_callback (w
, event
, client_data
)
3226 GdkEventCrossing
*event
;
3227 gpointer client_data
;
3229 /* The EMACS_INT cast avoids a warning. */
3230 int idx
= (int) (EMACS_INT
) client_data
;
3231 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3232 Lisp_Object help
, frame
;
3234 if (! GTK_IS_BUTTON (w
))
3239 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3242 if (event
->type
== GDK_ENTER_NOTIFY
)
3244 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3245 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3248 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3253 XSETFRAME (frame
, f
);
3254 kbd_buffer_store_help_event (frame
, help
);
3260 /* This callback is called when a tool bar item shall be redrawn.
3261 It modifies the expose event so that the GtkImage widget redraws the
3262 whole image. This to overcome a bug that makes GtkImage draw the image
3263 in the wrong place when it tries to redraw just a part of the image.
3264 W is the GtkImage to be redrawn.
3265 EVENT is the expose event for W.
3266 CLIENT_DATA is unused.
3268 Returns FALSE to tell GTK to keep processing this event. */
3271 xg_tool_bar_item_expose_callback (w
, event
, client_data
)
3273 GdkEventExpose
*event
;
3274 gpointer client_data
;
3278 gdk_drawable_get_size (event
->window
, &width
, &height
);
3280 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3281 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3283 event
->area
.x
= max (0, event
->area
.x
);
3284 event
->area
.y
= max (0, event
->area
.y
);
3286 event
->area
.width
= max (width
, event
->area
.width
);
3287 event
->area
.height
= max (height
, event
->area
.height
);
3292 /* This callback is called when a tool bar shall be redrawn.
3293 We need to update the tool bar from here in case the image cache
3294 has deleted the pixmaps used in the tool bar.
3295 W is the GtkToolbar to be redrawn.
3296 EVENT is the expose event for W.
3297 CLIENT_DATA is pointing to the frame for this tool bar.
3299 Returns FALSE to tell GTK to keep processing this event. */
3302 xg_tool_bar_expose_callback (w
, event
, client_data
)
3304 GdkEventExpose
*event
;
3305 gpointer client_data
;
3307 update_frame_tool_bar ((FRAME_PTR
) client_data
);
3311 /* Create a tool bar for frame F. */
3314 xg_create_tool_bar (f
)
3317 struct x_output
*x
= f
->output_data
.x
;
3319 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3321 x
->toolbar_widget
= gtk_toolbar_new ();
3322 x
->handlebox_widget
= gtk_handle_box_new ();
3323 x
->toolbar_detached
= 0;
3325 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3328 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3331 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3334 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3336 /* We only have icons, so override any user setting. We could
3337 use the caption property of the toolbar item (see update_frame_tool_bar
3338 below), but some of those strings are long, making the toolbar so
3339 long it does not fit on the screen. The GtkToolbar widget makes every
3340 item equal size, so the longest caption determine the size of every
3341 tool bar item. I think the creators of the GtkToolbar widget
3342 counted on 4 or 5 character long strings. */
3343 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3344 gtk_toolbar_set_orientation (GTK_TOOLBAR (x
->toolbar_widget
),
3345 GTK_ORIENTATION_HORIZONTAL
);
3347 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3348 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3349 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3350 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3351 g_signal_connect (G_OBJECT (x
->toolbar_widget
),
3353 G_CALLBACK (xg_tool_bar_expose_callback
),
3356 gtk_widget_show_all (x
->handlebox_widget
);
3358 gtk_widget_size_request (x
->toolbar_widget
, &req
);
3359 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3361 /* The height has changed, resize outer widget and set columns
3362 rows to what we had before adding the tool bar. */
3363 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3365 SET_FRAME_GARBAGED (f
);
3368 /* Update the tool bar for frame F. Add new buttons and remove old. */
3371 update_frame_tool_bar (f
)
3375 GtkRequisition old_req
, new_req
;
3378 struct x_output
*x
= f
->output_data
.x
;
3379 int hmargin
, vmargin
;
3381 if (! FRAME_GTK_WIDGET (f
))
3386 if (INTEGERP (Vtool_bar_button_margin
)
3387 && XINT (Vtool_bar_button_margin
) > 0)
3389 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3390 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3392 else if (CONSP (Vtool_bar_button_margin
))
3394 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3395 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3396 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3398 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3399 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3400 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3403 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3404 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3405 i.e. zero. This means that margins less than
3406 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3407 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3408 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3410 if (! x
->toolbar_widget
)
3411 xg_create_tool_bar (f
);
3413 gtk_widget_size_request (x
->toolbar_widget
, &old_req
);
3415 icon_list
= gtk_container_get_children (GTK_CONTAINER (x
->toolbar_widget
));
3418 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3420 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3422 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3423 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3428 GtkWidget
*wicon
= iter
? GTK_WIDGET (iter
->data
) : 0;
3430 if (iter
) iter
= g_list_next (iter
);
3432 /* If image is a vector, choose the image according to the
3434 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3435 if (VECTORP (image
))
3439 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3440 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3443 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3444 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3446 xassert (ASIZE (image
) >= idx
);
3447 image
= AREF (image
, idx
);
3452 /* Ignore invalid image specifications. */
3453 if (!valid_image_p (image
))
3455 if (wicon
) gtk_widget_hide (wicon
);
3459 img_id
= lookup_image (f
, image
);
3460 img
= IMAGE_FROM_ID (f
, img_id
);
3461 prepare_image_for_display (f
, img
);
3463 if (img
->load_failed_p
|| img
->pixmap
== None
)
3465 if (wicon
) gtk_widget_hide (wicon
);
3471 GtkWidget
*w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
3473 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
3475 /* The EMACS_INT cast avoids a warning. */
3476 gtk_toolbar_append_item (GTK_TOOLBAR (x
->toolbar_widget
),
3479 GTK_SIGNAL_FUNC (xg_tool_bar_callback
),
3480 (gpointer
) (EMACS_INT
) i
);
3482 /* Save the image so we can see if an update is needed when
3483 this function is called again. */
3484 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
3485 (gpointer
)img
->pixmap
);
3487 /* Catch expose events to overcome an annoying redraw bug, see
3488 comment for xg_tool_bar_item_expose_callback. */
3489 g_signal_connect (G_OBJECT (w
),
3491 G_CALLBACK (xg_tool_bar_item_expose_callback
),
3494 /* We must set sensitive on the button that is the parent
3495 of the GtkImage parent. Go upwards until we find the button. */
3496 while (! GTK_IS_BUTTON (w
))
3497 w
= gtk_widget_get_parent (w
);
3501 /* Save the frame in the button so the xg_tool_bar_callback
3503 g_object_set_data (G_OBJECT (w
), XG_FRAME_DATA
, (gpointer
)f
);
3504 gtk_widget_set_sensitive (w
, enabled_p
);
3506 /* Use enter/leave notify to show help. We use the events
3507 rather than the GtkButton specific signals "enter" and
3508 "leave", so we can have only one callback. The event
3509 will tell us what kind of event it is. */
3510 /* The EMACS_INT cast avoids a warning. */
3511 g_signal_connect (G_OBJECT (w
),
3512 "enter-notify-event",
3513 G_CALLBACK (xg_tool_bar_help_callback
),
3514 (gpointer
) (EMACS_INT
) i
);
3515 g_signal_connect (G_OBJECT (w
),
3516 "leave-notify-event",
3517 G_CALLBACK (xg_tool_bar_help_callback
),
3518 (gpointer
) (EMACS_INT
) i
);
3523 /* The child of the tool bar is a button. Inside that button
3524 is a vbox. Inside that vbox is the GtkImage. */
3525 GtkWidget
*wvbox
= gtk_bin_get_child (GTK_BIN (wicon
));
3526 GList
*chlist
= gtk_container_get_children (GTK_CONTAINER (wvbox
));
3527 GtkImage
*wimage
= GTK_IMAGE (chlist
->data
);
3528 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
3529 XG_TOOL_BAR_IMAGE_DATA
);
3530 g_list_free (chlist
);
3532 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
3534 if (old_img
!= img
->pixmap
)
3535 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
3537 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
3538 (gpointer
)img
->pixmap
);
3540 gtk_widget_set_sensitive (wicon
, enabled_p
);
3541 gtk_widget_show (wicon
);
3547 /* Remove buttons not longer needed. We just hide them so they
3548 can be reused later on. */
3551 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3552 gtk_widget_hide (w
);
3553 iter
= g_list_next (iter
);
3556 gtk_widget_size_request (x
->toolbar_widget
, &new_req
);
3557 if (old_req
.height
!= new_req
.height
3558 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
3560 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
3561 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3564 if (icon_list
) g_list_free (icon_list
);
3569 /* Deallocate all resources for the tool bar on frame F.
3570 Remove the tool bar. */
3573 free_frame_tool_bar (f
)
3576 struct x_output
*x
= f
->output_data
.x
;
3578 if (x
->toolbar_widget
)
3581 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
3582 x
->handlebox_widget
);
3583 x
->toolbar_widget
= 0;
3584 x
->handlebox_widget
= 0;
3585 FRAME_TOOLBAR_HEIGHT (f
) = 0;
3587 /* The height has changed, resize outer widget and set columns
3588 rows to what we had before removing the tool bar. */
3589 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3591 SET_FRAME_GARBAGED (f
);
3598 /***********************************************************************
3600 ***********************************************************************/
3604 GtkBindingSet
*binding_set
;
3606 xg_ignore_gtk_scrollbar
= 0;
3607 xg_detached_menus
= 0;
3608 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
3609 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
3611 id_to_widget
.max_size
= id_to_widget
.used
= 0;
3612 id_to_widget
.widgets
= 0;
3614 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
3615 bindings. It doesn't seem to be any way to remove properties,
3616 so we set it to VoidSymbol which in X means "no key". */
3617 gtk_settings_set_string_property (gtk_settings_get_default (),
3618 "gtk-menu-bar-accel",
3622 /* Make GTK text input widgets use Emacs style keybindings. This is
3624 gtk_settings_set_string_property (gtk_settings_get_default (),
3625 "gtk-key-theme-name",
3629 /* Make dialogs close on C-g. Since file dialog inherits from
3630 dialog, this works for them also. */
3631 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_DIALOG
));
3632 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3635 /* Make menus close on C-g. */
3636 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_MENU_SHELL
));
3637 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3641 #endif /* USE_GTK */
3643 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
3644 (do not change this comment) */