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))
44 /* Avoid "differ in sign" warnings */
45 #define SSDATA(x) ((char *) SDATA (x))
48 /***********************************************************************
49 Display handling functions
50 ***********************************************************************/
52 #ifdef HAVE_GTK_MULTIDISPLAY
54 /* Return the GdkDisplay that corresponds to the X display DPY. */
57 xg_get_gdk_display (dpy
)
60 return gdk_x11_lookup_xdisplay (dpy
);
63 /* When the GTK widget W is to be created on a display for F that
64 is not the default display, set the display for W.
65 W can be a GtkMenu or a GtkWindow widget. */
72 if (FRAME_X_DISPLAY (f
) != GDK_DISPLAY ())
74 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
75 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
78 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
80 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
85 #else /* not HAVE_GTK_MULTIDISPLAY */
87 /* Make some defines so we can use the GTK 2.2 functions when
88 compiling with GTK 2.0. */
90 #define xg_set_screen(w, f)
91 #define gdk_xid_table_lookup_for_display(dpy, w) gdk_xid_table_lookup (w)
92 #define gdk_pixmap_foreign_new_for_display(dpy, p) gdk_pixmap_foreign_new (p)
93 #define gdk_cursor_new_for_display(dpy, c) gdk_cursor_new (c)
94 #define gdk_x11_lookup_xdisplay(dpy) 0
95 #define GdkDisplay void
97 #endif /* not HAVE_GTK_MULTIDISPLAY */
99 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
100 *DPY is set to NULL if the display can't be opened.
102 Returns non-zero if display could be opened, zero if display could not
103 be opened, and less than zero if the GTK version doesn't support
107 xg_display_open (display_name
, dpy
)
111 #ifdef HAVE_GTK_MULTIDISPLAY
114 gdpy
= gdk_display_open (display_name
);
115 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
119 #else /* not HAVE_GTK_MULTIDISPLAY */
122 #endif /* not HAVE_GTK_MULTIDISPLAY */
126 /* Close display DPY. */
129 xg_display_close (Display
*dpy
)
131 #ifdef HAVE_GTK_MULTIDISPLAY
132 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
134 /* GTK 2.2 has a bug that makes gdk_display_close crash (bug
135 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way
136 we can continue running, but there will be memory leaks. */
138 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 4
140 /* If this is the default display, we must change it before calling
141 dispose, otherwise it will crash. */
142 if (gdk_display_get_default () == gdpy
)
144 struct x_display_info
*dpyinfo
;
145 Display
*new_dpy
= 0;
146 GdkDisplay
*gdpy_new
;
148 /* Find another display. */
149 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
150 if (dpyinfo
->display
!= dpy
)
152 new_dpy
= dpyinfo
->display
;
156 if (! new_dpy
) return; /* Emacs will exit anyway. */
158 gdpy_new
= gdk_x11_lookup_xdisplay (new_dpy
);
159 gdk_display_manager_set_default_display (gdk_display_manager_get (),
163 g_object_run_dispose (G_OBJECT (gdpy
));
166 /* I hope this will be fixed in GTK 2.4. It is what bug 85715 says. */
167 gdk_display_close (gdpy
);
169 #endif /* HAVE_GTK_MULTIDISPLAY */
173 /***********************************************************************
175 ***********************************************************************/
176 /* The timer for scroll bar repetition and menu bar timeouts.
177 NULL if no timer is started. */
178 static struct atimer
*xg_timer
;
181 /* The next two variables and functions are taken from lwlib. */
182 static widget_value
*widget_value_free_list
;
183 static int malloc_cpt
;
185 /* Allocate a widget_value structure, either by taking one from the
186 widget_value_free_list or by malloc:ing a new one.
188 Return a pointer to the allocated structure. */
191 malloc_widget_value ()
194 if (widget_value_free_list
)
196 wv
= widget_value_free_list
;
197 widget_value_free_list
= wv
->free_list
;
202 wv
= (widget_value
*) malloc (sizeof (widget_value
));
205 memset (wv
, 0, sizeof (widget_value
));
209 /* This is analogous to free. It frees only what was allocated
210 by malloc_widget_value, and no substructures. */
213 free_widget_value (wv
)
221 /* When the number of already allocated cells is too big,
228 wv
->free_list
= widget_value_free_list
;
229 widget_value_free_list
= wv
;
234 /* Create and return the cursor to be used for popup menus and
235 scroll bars on display DPY. */
238 xg_create_default_cursor (dpy
)
241 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
242 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
245 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
248 xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
)
253 int x
, y
, width
, height
, rowstride
, mask_rowstride
;
254 GdkPixbuf
*icon_buf
, *tmp_buf
;
258 gdk_drawable_get_size (gpix
, &width
, &height
);
259 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
260 0, 0, 0, 0, width
, height
);
261 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
262 g_object_unref (G_OBJECT (tmp_buf
));
266 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
271 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
272 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
273 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
274 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
277 for (y
= 0; y
< height
; ++y
)
279 guchar
*iconptr
, *maskptr
;
282 iconptr
= pixels
+ y
* rowstride
;
283 maskptr
= mask_pixels
+ y
* mask_rowstride
;
285 for (x
= 0; x
< width
; ++x
)
287 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
288 just R is sufficient. */
290 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
292 iconptr
+= rowstride
/width
;
293 maskptr
+= mask_rowstride
/width
;
297 g_object_unref (G_OBJECT (mask_buf
));
303 /* For the image defined in IMG, make and return a GtkImage. For displays with
304 8 planes or less we must make a GdkPixbuf and apply the mask manually.
305 Otherwise the highlightning and dimming the tool bar code in GTK does
306 will look bad. For display with more than 8 planes we just use the
307 pixmap and mask directly. For monochrome displays, GTK doesn't seem
308 able to use external pixmaps, it looks bad whatever we do.
309 The image is defined on the display where frame F is.
310 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
311 If OLD_WIDGET is NULL, a new widget is constructed and returned.
312 If OLD_WIDGET is not NULL, that widget is modified. */
315 xg_get_image_for_pixmap (f
, img
, widget
, old_widget
)
319 GtkImage
*old_widget
;
325 /* If we are on a one bit display, let GTK do all the image handling.
326 This seems to be the only way to make insensitive and activated icons
328 if (x_screen_planes (f
) == 1)
330 Lisp_Object specified_file
= Qnil
;
332 extern Lisp_Object QCfile
;
334 for (tail
= XCDR (img
->spec
);
335 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
336 tail
= XCDR (XCDR (tail
)))
337 if (EQ (XCAR (tail
), QCfile
))
338 specified_file
= XCAR (XCDR (tail
));
340 if (STRINGP (specified_file
))
343 Lisp_Object file
= Qnil
;
347 file
= x_find_image_file (specified_file
);
348 /* We already loaded the image once before calling this
349 function, so this should not fail. */
350 xassert (STRINGP (file
) != 0);
353 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
355 gtk_image_set_from_file (old_widget
, SSDATA (file
));
358 return GTK_WIDGET (old_widget
);
362 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
363 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
364 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
366 if (x_screen_planes (f
) > 8 || x_screen_planes (f
) == 1)
369 old_widget
= GTK_IMAGE (gtk_image_new_from_pixmap (gpix
, gmask
));
371 gtk_image_set_from_pixmap (old_widget
, gpix
, gmask
);
376 /* This is a workaround to make icons look good on pseudo color
377 displays. Apparently GTK expects the images to have an alpha
378 channel. If they don't, insensitive and activated icons will
379 look bad. This workaround does not work on monochrome displays,
380 and is not needed on true color/static color displays (i.e.
381 16 bits and higher). */
382 GdkColormap
*cmap
= gtk_widget_get_colormap (widget
);
383 GdkPixbuf
*icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
386 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
388 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
390 g_object_unref (G_OBJECT (icon_buf
));
393 g_object_unref (G_OBJECT (gpix
));
394 if (gmask
) g_object_unref (G_OBJECT (gmask
));
396 return GTK_WIDGET (old_widget
);
400 /* Set CURSOR on W and all widgets W contain. We must do like this
401 for scroll bars and menu because they create widgets internally,
402 and it is those widgets that are visible. */
405 xg_set_cursor (w
, cursor
)
409 GList
*children
= gdk_window_peek_children (w
->window
);
411 gdk_window_set_cursor (w
->window
, cursor
);
413 /* The scroll bar widget has more than one GDK window (had to look at
414 the source to figure this out), and there is no way to set cursor
415 on widgets in GTK. So we must set the cursor for all GDK windows.
418 for ( ; children
; children
= g_list_next (children
))
419 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
422 /* Timer function called when a timeout occurs for xg_timer.
423 This function processes all GTK events in a recursive event loop.
424 This is done because GTK timer events are not seen by Emacs event
425 detection, Emacs only looks for X events. When a scroll bar has the
426 pointer (detected by button press/release events below) an Emacs
427 timer is started, and this function can then check if the GTK timer
428 has expired by calling the GTK event loop.
429 Also, when a menu is active, it has a small timeout before it
430 pops down the sub menu under it. */
433 xg_process_timeouts (timer
)
434 struct atimer
*timer
;
437 /* Ideally we would like to just handle timer events, like the Xt version
438 of this does in xterm.c, but there is no such feature in GTK. */
439 while (gtk_events_pending ())
440 gtk_main_iteration ();
444 /* Start the xg_timer with an interval of 0.1 seconds, if not already started.
445 xg_process_timeouts is called when the timer expires. The timer
446 started is continuous, i.e. runs until xg_stop_timer is called. */
454 EMACS_SET_SECS_USECS (interval
, 0, 100000);
455 xg_timer
= start_atimer (ATIMER_CONTINUOUS
,
462 /* Stop the xg_timer if started. */
469 cancel_atimer (xg_timer
);
474 /* Insert NODE into linked LIST. */
477 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
479 xg_list_node
*list_start
= list
->next
;
481 if (list_start
) list_start
->prev
= node
;
482 node
->next
= list_start
;
487 /* Remove NODE from linked LIST. */
490 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
492 xg_list_node
*list_start
= list
->next
;
493 if (node
== list_start
)
495 list
->next
= node
->next
;
496 if (list
->next
) list
->next
->prev
= 0;
500 node
->prev
->next
= node
->next
;
501 if (node
->next
) node
->next
->prev
= node
->prev
;
505 /* Allocate and return a utf8 version of STR. If STR is already
506 utf8 or NULL, just return STR.
507 If not, a new string is allocated and the caller must free the result
511 get_utf8_string (str
)
514 char *utf8_str
= str
;
516 /* If not UTF-8, try current locale. */
517 if (str
&& !g_utf8_validate (str
, -1, NULL
))
518 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
525 /***********************************************************************
526 General functions for creating widgets, resizing, events, e.t.c.
527 ***********************************************************************/
529 /* Make a geometry string and pass that to GTK. It seems this is the
530 only way to get geometry position right if the user explicitly
531 asked for a position when starting Emacs.
532 F is the frame we shall set geometry for. */
538 if (f
->size_hint_flags
& USPosition
)
540 int left
= f
->left_pos
;
541 int xneg
= f
->size_hint_flags
& XNegative
;
542 int top
= f
->top_pos
;
543 int yneg
= f
->size_hint_flags
& YNegative
;
551 sprintf (geom_str
, "=%dx%d%c%d%c%d",
552 FRAME_PIXEL_WIDTH (f
),
553 FRAME_TOTAL_PIXEL_HEIGHT (f
),
554 (xneg
? '-' : '+'), left
,
555 (yneg
? '-' : '+'), top
);
557 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
559 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
560 } else if (f
->size_hint_flags
& PPosition
) {
561 gtk_window_move (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
562 f
->left_pos
, f
->top_pos
);
567 /* Resize the outer window of frame F after chainging the height.
568 This happend when the menu bar or the tool bar is added or removed.
569 COLUMNS/ROWS is the size the edit area shall have after the resize. */
572 xg_resize_outer_widget (f
, columns
, rows
)
577 /* If we are not mapped yet, set geometry once again, as window
578 height now have changed. */
579 if (! GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f
)))
582 xg_frame_set_char_size (f
, columns
, rows
);
583 gdk_window_process_all_updates ();
586 /* Function to handle resize of our widgets. Since Emacs has some layouts
587 that does not fit well with GTK standard containers, we do most layout
589 F is the frame to resize.
590 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
593 xg_resize_widgets (f
, pixelwidth
, pixelheight
)
595 int pixelwidth
, pixelheight
;
597 int mbheight
= FRAME_MENUBAR_HEIGHT (f
);
598 int tbheight
= FRAME_TOOLBAR_HEIGHT (f
);
599 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, (pixelheight
600 - mbheight
- tbheight
));
601 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
603 if (FRAME_GTK_WIDGET (f
)
604 && (columns
!= FRAME_COLS (f
)
605 || rows
!= FRAME_LINES (f
)
606 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
607 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
)))
609 struct x_output
*x
= f
->output_data
.x
;
612 all
.y
= mbheight
+ tbheight
;
615 all
.width
= pixelwidth
;
616 all
.height
= pixelheight
- mbheight
- tbheight
;
618 gtk_widget_size_allocate (x
->edit_widget
, &all
);
620 change_frame_size (f
, rows
, columns
, 0, 1, 0);
621 SET_FRAME_GARBAGED (f
);
622 cancel_mouse_face (f
);
627 /* Update our widget size to be COLS/ROWS characters for frame F. */
630 xg_frame_set_char_size (f
, cols
, rows
)
635 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
636 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
639 /* Take into account the size of the scroll bar. Always use the
640 number of columns occupied by the scroll bar here otherwise we
641 might end up with a frame width that is not a multiple of the
642 frame's character width which is bad for vertically split
644 f
->scroll_bar_actual_width
645 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
647 compute_fringe_widths (f
, 0);
649 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
650 after calculating that value. */
651 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
653 /* Must resize our top level widget. Font size may have changed,
654 but not rows/cols. */
655 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
656 pixelwidth
, pixelheight
);
657 xg_resize_widgets (f
, pixelwidth
, pixelheight
);
658 x_wm_set_size_hint (f
, 0, 0);
659 SET_FRAME_GARBAGED (f
);
660 cancel_mouse_face (f
);
663 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
664 Must be done like this, because GtkWidget:s can have "hidden"
665 X Window that aren't accessible.
667 Return 0 if no widget match WDESC. */
670 xg_win_to_widget (dpy
, wdesc
)
675 GtkWidget
*gwdesc
= 0;
679 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
684 event
.any
.window
= gdkwin
;
685 gwdesc
= gtk_get_event_widget (&event
);
692 /* Fill in the GdkColor C so that it represents PIXEL.
693 W is the widget that color will be used for. Used to find colormap. */
696 xg_pix_to_gcolor (w
, pixel
, c
)
701 GdkColormap
*map
= gtk_widget_get_colormap (w
);
702 gdk_colormap_query_color (map
, pixel
, c
);
705 /* Create and set up the GTK widgets for frame F.
706 Return 0 if creation failed, non-zero otherwise. */
709 xg_create_frame_widgets (f
)
722 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
723 xg_set_screen (wtop
, f
);
725 wvbox
= gtk_vbox_new (FALSE
, 0);
726 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
728 if (! wtop
|| ! wvbox
|| ! wfixed
)
730 if (wtop
) gtk_widget_destroy (wtop
);
731 if (wvbox
) gtk_widget_destroy (wvbox
);
732 if (wfixed
) gtk_widget_destroy (wfixed
);
738 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
739 gtk_widget_set_name (wtop
, EMACS_CLASS
);
740 gtk_widget_set_name (wvbox
, "pane");
741 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
743 /* If this frame has a title or name, set it in the title bar. */
744 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
745 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
747 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
749 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
750 FRAME_GTK_WIDGET (f
) = wfixed
;
751 f
->output_data
.x
->vbox_widget
= wvbox
;
753 gtk_fixed_set_has_window (GTK_FIXED (wfixed
), TRUE
);
755 gtk_widget_set_size_request (wfixed
, FRAME_PIXEL_WIDTH (f
),
756 FRAME_PIXEL_HEIGHT (f
));
758 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
759 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
761 if (FRAME_EXTERNAL_TOOL_BAR (f
))
762 update_frame_tool_bar (f
);
764 /* The tool bar is created but first there are no items in it.
765 This causes it to be zero height. Later items are added, but then
766 the frame is already mapped, so there is a "jumping" resize.
767 This makes geometry handling difficult, for example -0-0 will end
768 up in the wrong place as tool bar height has not been taken into account.
769 So we cheat a bit by setting a height that is what it will have
770 later on when tool bar items are added. */
771 if (FRAME_EXTERNAL_TOOL_BAR (f
) && f
->n_tool_bar_items
== 0)
772 FRAME_TOOLBAR_HEIGHT (f
) = 38;
775 /* We don't want this widget double buffered, because we draw on it
776 with regular X drawing primitives, so from a GTK/GDK point of
777 view, the widget is totally blank. When an expose comes, this
778 will make the widget blank, and then Emacs redraws it. This flickers
779 a lot, so we turn off double buffering. */
780 gtk_widget_set_double_buffered (wfixed
, FALSE
);
782 /* GTK documents says use gtk_window_set_resizable. But then a user
783 can't shrink the window from its starting size. */
784 gtk_window_set_policy (GTK_WINDOW (wtop
), TRUE
, TRUE
, TRUE
);
785 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
786 SSDATA (Vx_resource_name
),
787 SSDATA (Vx_resource_class
));
789 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
790 GTK is to destroy the widget. We want Emacs to do that instead. */
791 g_signal_connect (G_OBJECT (wtop
), "delete-event",
792 G_CALLBACK (gtk_true
), 0);
794 /* Convert our geometry parameters into a geometry string
796 GTK will itself handle calculating the real position this way. */
799 gtk_widget_add_events (wfixed
,
800 GDK_POINTER_MOTION_MASK
802 | GDK_BUTTON_PRESS_MASK
803 | GDK_BUTTON_RELEASE_MASK
805 | GDK_ENTER_NOTIFY_MASK
806 | GDK_LEAVE_NOTIFY_MASK
807 | GDK_FOCUS_CHANGE_MASK
809 | GDK_VISIBILITY_NOTIFY_MASK
);
811 /* Must realize the windows so the X window gets created. It is used
812 by callers of this function. */
813 gtk_widget_realize (wfixed
);
814 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
816 /* Since GTK clears its window by filling with the background color,
817 we must keep X and GTK background in sync. */
818 xg_pix_to_gcolor (wfixed
, f
->output_data
.x
->background_pixel
, &bg
);
819 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
821 /* Also, do not let any background pixmap to be set, this looks very
822 bad as Emacs overwrites the background pixmap with its own idea
823 of background color. */
824 style
= gtk_widget_get_modifier_style (wfixed
);
826 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
827 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
828 gtk_widget_modify_style (wfixed
, style
);
830 /* GTK does not set any border, and they look bad with GTK. */
832 f
->internal_border_width
= 0;
839 /* Set the normal size hints for the window manager, for frame F.
840 FLAGS is the flags word to use--or 0 meaning preserve the flags
841 that the window now has.
842 If USER_POSITION is nonzero, we set the User Position
843 flag (this is useful when FLAGS is 0). */
846 x_wm_set_size_hint (f
, flags
, user_position
)
851 if (FRAME_GTK_OUTER_WIDGET (f
))
853 /* Must use GTK routines here, otherwise GTK resets the size hints
854 to its own defaults. */
855 GdkGeometry size_hints
;
857 int base_width
, base_height
;
858 int min_rows
= 0, min_cols
= 0;
859 int win_gravity
= f
->win_gravity
;
863 memset (&size_hints
, 0, sizeof (size_hints
));
864 f
->output_data
.x
->size_hints
= size_hints
;
865 f
->output_data
.x
->hint_flags
= hint_flags
;
868 flags
= f
->size_hint_flags
;
870 size_hints
= f
->output_data
.x
->size_hints
;
871 hint_flags
= f
->output_data
.x
->hint_flags
;
873 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
874 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
875 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
877 hint_flags
|= GDK_HINT_BASE_SIZE
;
878 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
879 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
880 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
882 check_frame_size (f
, &min_rows
, &min_cols
);
884 size_hints
.base_width
= base_width
;
885 size_hints
.base_height
= base_height
;
886 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
887 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
890 /* These currently have a one to one mapping with the X values, but I
891 don't think we should rely on that. */
892 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
893 size_hints
.win_gravity
= 0;
894 if (win_gravity
== NorthWestGravity
)
895 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
896 else if (win_gravity
== NorthGravity
)
897 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
898 else if (win_gravity
== NorthEastGravity
)
899 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
900 else if (win_gravity
== WestGravity
)
901 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
902 else if (win_gravity
== CenterGravity
)
903 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
904 else if (win_gravity
== EastGravity
)
905 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
906 else if (win_gravity
== SouthWestGravity
)
907 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
908 else if (win_gravity
== SouthGravity
)
909 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
910 else if (win_gravity
== SouthEastGravity
)
911 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
912 else if (win_gravity
== StaticGravity
)
913 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
915 if (flags
& PPosition
) hint_flags
|= GDK_HINT_POS
;
916 if (flags
& USPosition
) hint_flags
|= GDK_HINT_USER_POS
;
917 if (flags
& USSize
) hint_flags
|= GDK_HINT_USER_SIZE
;
921 hint_flags
&= ~GDK_HINT_POS
;
922 hint_flags
|= GDK_HINT_USER_POS
;
927 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
928 FRAME_GTK_OUTER_WIDGET (f
),
932 f
->output_data
.x
->size_hints
= size_hints
;
933 f
->output_data
.x
->hint_flags
= hint_flags
;
938 /* Change background color of a frame.
939 Since GTK uses the background colour to clear the window, we must
940 keep the GTK and X colors in sync.
941 F is the frame to change,
942 BG is the pixel value to change to. */
945 xg_set_background_color (f
, bg
)
949 if (FRAME_GTK_WIDGET (f
))
954 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
955 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
961 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
962 functions so GTK does not overwrite the icon. */
965 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
)
970 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
971 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
972 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
973 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
975 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
980 /***********************************************************************
982 ***********************************************************************/
983 /* Return the dialog title to use for a dialog of type KEY.
984 This is the encoding used by lwlib. We use the same for GTK. */
987 get_dialog_title (char key
)
997 title
= "Information";
1016 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1017 the dialog, but return TRUE so the event does not propagate further
1018 in GTK. This prevents GTK from destroying the dialog widget automatically
1019 and we can always destrou the widget manually, regardles of how
1020 it was popped down (button press or WM_DELETE_WINDOW).
1021 W is the dialog widget.
1022 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1023 user_data is NULL (not used).
1025 Returns TRUE to end propagation of event. */
1028 dialog_delete_callback (w
, event
, user_data
)
1033 gtk_widget_unmap (w
);
1037 /* Create a popup dialog window. See also xg_create_widget below.
1038 WV is a widget_value describing the dialog.
1039 SELECT_CB is the callback to use when a button has been pressed.
1040 DEACTIVATE_CB is the callback to use when the dialog pops down.
1042 Returns the GTK dialog widget. */
1045 create_dialog (wv
, select_cb
, deactivate_cb
)
1047 GCallback select_cb
;
1048 GCallback deactivate_cb
;
1050 char *title
= get_dialog_title (wv
->name
[0]);
1051 int total_buttons
= wv
->name
[1] - '0';
1052 int right_buttons
= wv
->name
[4] - '0';
1055 int button_spacing
= 10;
1056 GtkWidget
*wdialog
= gtk_dialog_new ();
1060 GtkWidget
*whbox_up
;
1061 GtkWidget
*whbox_down
;
1063 /* If the number of buttons is greater than 4, make two rows of buttons
1064 instead. This looks better. */
1065 int make_two_rows
= total_buttons
> 4;
1067 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1068 left_buttons
= total_buttons
- right_buttons
;
1070 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1071 gtk_widget_set_name (wdialog
, "emacs-dialog");
1073 cur_box
= GTK_BOX (GTK_DIALOG (wdialog
)->action_area
);
1077 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1078 whbox_up
= gtk_hbox_new (FALSE
, 0);
1079 whbox_down
= gtk_hbox_new (FALSE
, 0);
1081 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1082 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1083 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1085 cur_box
= GTK_BOX (whbox_up
);
1088 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1089 G_CALLBACK (dialog_delete_callback
), 0);
1093 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1094 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1097 for (item
= wv
->contents
; item
; item
= item
->next
)
1099 char *utf8_label
= get_utf8_string (item
->value
);
1103 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1105 /* This is the text part of the dialog. */
1106 w
= gtk_label_new (utf8_label
);
1107 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1110 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
), w
,
1112 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1114 /* Try to make dialog look better. Must realize first so
1115 the widget can calculate the size it needs. */
1116 gtk_widget_realize (w
);
1117 gtk_widget_size_request (w
, &req
);
1118 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1120 if (item
->value
&& strlen (item
->value
) > 0)
1121 button_spacing
= 2*req
.width
/strlen (item
->value
);
1125 /* This is one button to add to the dialog. */
1126 w
= gtk_button_new_with_label (utf8_label
);
1127 if (! item
->enabled
)
1128 gtk_widget_set_sensitive (w
, FALSE
);
1130 g_signal_connect (G_OBJECT (w
), "clicked",
1131 select_cb
, item
->call_data
);
1133 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1134 if (++button_nr
== left_buttons
)
1137 cur_box
= GTK_BOX (whbox_down
);
1139 gtk_box_pack_start (cur_box
,
1146 if (utf8_label
&& utf8_label
!= item
->value
)
1147 g_free (utf8_label
);
1155 /***********************************************************************
1156 File dialog functions
1157 ***********************************************************************/
1158 /* Return non-zero if the old file selection dialog is being used.
1159 Return zero if not. */
1162 xg_uses_old_file_dialog ()
1164 #ifdef HAVE_GTK_FILE_BOTH
1165 extern int x_use_old_gtk_file_dialog
;
1166 return x_use_old_gtk_file_dialog
;
1167 #else /* ! HAVE_GTK_FILE_BOTH */
1169 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1175 #endif /* ! HAVE_GTK_FILE_BOTH */
1179 /* Function that is called when the file dialog pops down.
1180 W is the dialog widget, RESPONSE is the response code.
1181 USER_DATA is what we passed in to g_signal_connect (pointer to int). */
1184 xg_file_response_cb (w
,
1191 int *ptr
= (int *) user_data
;
1196 /* Destroy the dialog. This makes it pop down. */
1199 pop_down_file_dialog (arg
)
1202 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1204 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1209 typedef char * (*xg_get_file_func
) P_ ((GtkWidget
*));
1211 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1213 /* Return the selected file for file chooser dialog W.
1214 The returned string must be free:d. */
1217 xg_get_file_name_from_chooser (w
)
1220 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1224 xg_toggle_visibility_cb (widget
, data
)
1228 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1230 extern int x_gtk_show_hidden_files
;
1231 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1232 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1233 x_gtk_show_hidden_files
= !visible
;
1236 /* Read a file name from the user using a file chooser dialog.
1237 F is the current frame.
1238 PROMPT is a prompt to show to the user. May not be NULL.
1239 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1240 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1241 file. *FUNC is set to a function that can be used to retrieve the
1242 selected file name from the returned widget.
1244 Returns the created widget. */
1247 xg_get_file_with_chooser (f
, prompt
, default_filename
,
1248 mustmatch_p
, only_dir_p
, func
)
1251 char *default_filename
;
1252 int mustmatch_p
, only_dir_p
;
1253 xg_get_file_func
*func
;
1257 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1258 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1259 GtkFileChooserAction action
= (mustmatch_p
?
1260 GTK_FILE_CHOOSER_ACTION_OPEN
:
1261 GTK_FILE_CHOOSER_ACTION_SAVE
);
1262 extern int x_gtk_show_hidden_files
;
1265 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1267 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1268 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1269 (mustmatch_p
|| only_dir_p
?
1270 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1273 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1275 wbox
= gtk_vbox_new (FALSE
, 0);
1276 gtk_widget_show (wbox
);
1277 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1279 if (x_gtk_show_hidden_files
)
1281 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1282 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1284 gtk_widget_show (wtoggle
);
1285 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1286 G_CALLBACK (xg_toggle_visibility_cb
), G_OBJECT(filewin
));
1288 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1289 strcpy (message
, "If you find this file dialog inconvinient "
1290 "you can customize\n"
1291 "x-use-old-gtk-file-dialog to get the old file dialog,\n"
1292 "or you can customize use-file-dialog to disable file dialogs,\n"
1293 "or just use C-x C-f to open files.");
1295 strcpy (message
, "If you find this file dialog inconvinient "
1296 "you can customize\n"
1297 "use-file-dialog to disable file dialogs,\n"
1298 "or just use C-x C-f to open files.");
1300 if (action
== GTK_FILE_CHOOSER_ACTION_OPEN
)
1301 strcat (message
, "\nUse C-l to bring up a text input area.");
1303 wmessage
= gtk_label_new (message
);
1304 gtk_widget_show (wmessage
);
1305 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1306 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1307 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1309 if (default_filename
)
1312 struct gcpro gcpro1
;
1315 file
= build_string (default_filename
);
1317 /* File chooser does not understand ~/... in the file name. It must be
1318 an absolute name starting with /. */
1319 if (default_filename
[0] != '/')
1320 file
= Fexpand_file_name (file
, Qnil
);
1322 default_filename
= SSDATA (file
);
1323 if (Ffile_directory_p (file
))
1324 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1327 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1333 *func
= xg_get_file_name_from_chooser
;
1336 #endif /* HAVE_GTK_FILE_CHOOSER_DIALOG_NEW */
1338 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1340 /* Return the selected file for file selector dialog W.
1341 The returned string must be free:d. */
1344 xg_get_file_name_from_selector (w
)
1347 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1348 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1351 /* Create a file selection dialog.
1352 F is the current frame.
1353 PROMPT is a prompt to show to the user. May not be NULL.
1354 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1355 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1356 file. *FUNC is set to a function that can be used to retrieve the
1357 selected file name from the returned widget.
1359 Returns the created widget. */
1362 xg_get_file_with_selection (f
, prompt
, default_filename
,
1363 mustmatch_p
, only_dir_p
, func
)
1366 char *default_filename
;
1367 int mustmatch_p
, only_dir_p
;
1368 xg_get_file_func
*func
;
1371 GtkFileSelection
*filesel
;
1373 filewin
= gtk_file_selection_new (prompt
);
1374 filesel
= GTK_FILE_SELECTION (filewin
);
1376 if (default_filename
)
1377 gtk_file_selection_set_filename (filesel
, default_filename
);
1381 /* The selection_entry part of filesel is not documented. */
1382 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1383 gtk_file_selection_hide_fileop_buttons (filesel
);
1386 *func
= xg_get_file_name_from_selector
;
1390 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1392 /* Read a file name from the user using a file dialog, either the old
1393 file selection dialog, or the new file chooser dialog. Which to use
1394 depends on what the GTK version used has, and what the value of
1395 gtk-use-old-file-dialog.
1396 F is the current frame.
1397 PROMPT is a prompt to show to the user. May not be NULL.
1398 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1399 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1402 Returns a file name or NULL if no file was selected.
1403 The returned string must be freed by the caller. */
1406 xg_get_file_name (f
, prompt
, default_filename
, mustmatch_p
, only_dir_p
)
1409 char *default_filename
;
1410 int mustmatch_p
, only_dir_p
;
1413 int count
= SPECPDL_INDEX ();
1415 int filesel_done
= 0;
1416 xg_get_file_func func
;
1418 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1419 /* I really don't know why this is needed, but without this the GLIBC add on
1420 library linuxthreads hangs when the Gnome file chooser backend creates
1422 sigblock (sigmask (__SIGRTMIN
));
1423 #endif /* HAVE_GTK_AND_PTHREAD */
1425 #ifdef HAVE_GTK_FILE_BOTH
1427 if (xg_uses_old_file_dialog ())
1428 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1429 mustmatch_p
, only_dir_p
, &func
);
1431 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1432 mustmatch_p
, only_dir_p
, &func
);
1434 #else /* not HAVE_GTK_FILE_BOTH */
1436 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1437 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1438 mustmatch_p
, only_dir_p
, &func
);
1440 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1441 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1442 mustmatch_p
, only_dir_p
, &func
);
1445 #endif /* HAVE_GTK_FILE_BOTH */
1447 xg_set_screen (w
, f
);
1448 gtk_widget_set_name (w
, "emacs-filedialog");
1449 gtk_window_set_transient_for (GTK_WINDOW (w
),
1450 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1451 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1452 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1454 g_signal_connect (G_OBJECT (w
),
1456 G_CALLBACK (xg_file_response_cb
),
1459 /* Don't destroy the widget if closed by the window manager close button. */
1460 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1462 gtk_widget_show (w
);
1464 record_unwind_protect (pop_down_file_dialog
, make_save_value (w
, 0));
1465 while (! filesel_done
)
1467 x_menu_wait_for_event (0);
1468 gtk_main_iteration ();
1471 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1472 sigunblock (sigmask (__SIGRTMIN
));
1475 if (filesel_done
== GTK_RESPONSE_OK
)
1478 unbind_to (count
, Qnil
);
1484 /***********************************************************************
1486 ***********************************************************************/
1488 /* The name of menu items that can be used for citomization. Since GTK
1489 RC files are very crude and primitive, we have to set this on all
1490 menu item names so a user can easily cutomize menu items. */
1492 #define MENU_ITEM_NAME "emacs-menuitem"
1495 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1496 during GC. The next member points to the items. */
1497 static xg_list_node xg_menu_cb_list
;
1499 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1500 during GC. The next member points to the items. */
1501 static xg_list_node xg_menu_item_cb_list
;
1503 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1504 F is the frame CL_DATA will be initialized for.
1505 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1507 The menu bar and all sub menus under the menu bar in a frame
1508 share the same structure, hence the reference count.
1510 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1511 allocated xg_menu_cb_data if CL_DATA is NULL. */
1513 static xg_menu_cb_data
*
1514 make_cl_data (cl_data
, f
, highlight_cb
)
1515 xg_menu_cb_data
*cl_data
;
1517 GCallback highlight_cb
;
1521 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1523 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1524 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1525 cl_data
->highlight_cb
= highlight_cb
;
1526 cl_data
->ref_count
= 0;
1528 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1531 cl_data
->ref_count
++;
1536 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1537 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1539 When the menu bar is updated, menu items may have been added and/or
1540 removed, so menu_bar_vector and menu_bar_items_used change. We must
1541 then update CL_DATA since it is used to determine which menu
1542 item that is invoked in the menu.
1543 HIGHLIGHT_CB could change, there is no check that the same
1544 function is given when modifying a menu bar as was given when
1545 creating the menu bar. */
1548 update_cl_data (cl_data
, f
, highlight_cb
)
1549 xg_menu_cb_data
*cl_data
;
1551 GCallback highlight_cb
;
1556 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1557 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1558 cl_data
->highlight_cb
= highlight_cb
;
1562 /* Decrease reference count for CL_DATA.
1563 If reference count is zero, free CL_DATA. */
1566 unref_cl_data (cl_data
)
1567 xg_menu_cb_data
*cl_data
;
1569 if (cl_data
&& cl_data
->ref_count
> 0)
1571 cl_data
->ref_count
--;
1572 if (cl_data
->ref_count
== 0)
1574 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1580 /* Function that marks all lisp data during GC. */
1587 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1588 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1590 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1592 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1594 if (! NILP (cb_data
->help
))
1595 mark_object (cb_data
->help
);
1600 /* Callback called when a menu item is destroyed. Used to free data.
1601 W is the widget that is being destroyed (not used).
1602 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1605 menuitem_destroy_callback (w
, client_data
)
1607 gpointer client_data
;
1611 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1612 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1617 /* Callback called when the pointer enters/leaves a menu item.
1619 EVENT is either an enter event or leave event.
1620 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W.
1622 Returns FALSE to tell GTK to keep processing this event. */
1625 menuitem_highlight_callback (w
, event
, client_data
)
1627 GdkEventCrossing
*event
;
1628 gpointer client_data
;
1632 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1633 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : client_data
;
1635 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1637 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1638 (*func
) (w
, call_data
);
1645 /* Callback called when a menu is destroyed. Used to free data.
1646 W is the widget that is being destroyed (not used).
1647 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1650 menu_destroy_callback (w
, client_data
)
1652 gpointer client_data
;
1654 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1657 /* Callback called when a menu does a grab or ungrab. That means the
1658 menu has been activated or deactivated.
1659 Used to start a timer so the small timeout the menus in GTK uses before
1660 popping down a menu is seen by Emacs (see xg_process_timeouts above).
1661 W is the widget that does the grab (not used).
1662 UNGRAB_P is TRUE if this is an ungrab, FALSE if it is a grab.
1663 CLIENT_DATA is NULL (not used). */
1666 menu_grab_callback (GtkWidget
*widget
,
1668 gpointer client_data
)
1670 /* Keep track of total number of grabs. */
1673 if (ungrab_p
) cnt
--;
1676 if (cnt
> 0 && ! xg_timer
) xg_start_timer ();
1677 else if (cnt
== 0 && xg_timer
) xg_stop_timer ();
1680 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1681 must be non-NULL) and can be inserted into a menu item.
1683 Returns the GtkHBox. */
1686 make_widget_for_menu_item (utf8_label
, utf8_key
)
1694 wbox
= gtk_hbox_new (FALSE
, 0);
1695 wlbl
= gtk_label_new (utf8_label
);
1696 wkey
= gtk_label_new (utf8_key
);
1698 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1699 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1701 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1702 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1704 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1705 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1706 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1711 /* Make and return a menu item widget with the key to the right.
1712 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1713 UTF8_KEY is the text representing the key binding.
1714 ITEM is the widget_value describing the menu item.
1716 GROUP is an in/out parameter. If the menu item to be created is not
1717 part of any radio menu group, *GROUP contains NULL on entry and exit.
1718 If the menu item to be created is part of a radio menu group, on entry
1719 *GROUP contains the group to use, or NULL if this is the first item
1720 in the group. On exit, *GROUP contains the radio item group.
1722 Unfortunately, keys don't line up as nicely as in Motif,
1723 but the MacOS X version doesn't either, so I guess that is OK. */
1726 make_menu_item (utf8_label
, utf8_key
, item
, group
)
1733 GtkWidget
*wtoadd
= 0;
1735 /* It has been observed that some menu items have a NULL name field.
1736 This will lead to this function being called with a NULL utf8_label.
1737 GTK crashes on that so we set a blank label. Why there is a NULL
1738 name remains to be investigated. */
1739 if (! utf8_label
) utf8_label
= " ";
1742 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1744 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1747 if (utf8_key
) w
= gtk_check_menu_item_new ();
1748 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1749 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1751 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1753 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1754 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1755 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1757 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1762 if (utf8_key
) w
= gtk_menu_item_new ();
1763 else w
= gtk_menu_item_new_with_label (utf8_label
);
1766 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1767 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1772 /* Return non-zero if LABEL specifies a separator (GTK only has one
1776 xg_separator_p (char *label
)
1778 if (! label
) return 0;
1779 else if (strlen (label
) > 3
1780 && strncmp (label
, "--", 2) == 0
1783 static char* separator_names
[] = {
1788 "single-dashed-line",
1789 "double-dashed-line",
1791 "shadow-etched-out",
1792 "shadow-etched-in-dash",
1793 "shadow-etched-out-dash",
1794 "shadow-double-etched-in",
1795 "shadow-double-etched-out",
1796 "shadow-double-etched-in-dash",
1797 "shadow-double-etched-out-dash",
1804 for (i
= 0; separator_names
[i
]; ++i
)
1805 if (strcmp (label
, separator_names
[i
]) == 0)
1810 /* Old-style separator, maybe. It's a separator if it contains
1812 while (*label
== '-')
1814 if (*label
== 0) return 1;
1820 static int xg_detached_menus
;
1822 /* Returns non-zero if there are detached menus. */
1825 xg_have_tear_offs ()
1827 return xg_detached_menus
> 0;
1830 /* Callback invoked when a detached menu window is removed. Here we
1831 decrease the xg_detached_menus count.
1832 WIDGET is the top level window that is removed (the parent of the menu).
1833 CLIENT_DATA is not used. */
1836 tearoff_remove (widget
, client_data
)
1838 gpointer client_data
;
1840 if (xg_detached_menus
> 0) --xg_detached_menus
;
1843 /* Callback invoked when a menu is detached. It increases the
1844 xg_detached_menus count.
1845 WIDGET is the GtkTearoffMenuItem.
1846 CLIENT_DATA is not used. */
1849 tearoff_activate (widget
, client_data
)
1851 gpointer client_data
;
1853 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
1854 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
1856 ++xg_detached_menus
;
1857 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
1859 G_CALLBACK (tearoff_remove
), 0);
1864 /* Create a menu item widget, and connect the callbacks.
1865 ITEM decribes the menu item.
1866 F is the frame the created menu belongs to.
1867 SELECT_CB is the callback to use when a menu item is selected.
1868 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1869 CL_DATA points to the callback data to be used for this menu.
1870 GROUP is an in/out parameter. If the menu item to be created is not
1871 part of any radio menu group, *GROUP contains NULL on entry and exit.
1872 If the menu item to be created is part of a radio menu group, on entry
1873 *GROUP contains the group to use, or NULL if this is the first item
1874 in the group. On exit, *GROUP contains the radio item group.
1876 Returns the created GtkWidget. */
1879 xg_create_one_menuitem (item
, f
, select_cb
, highlight_cb
, cl_data
, group
)
1882 GCallback select_cb
;
1883 GCallback highlight_cb
;
1884 xg_menu_cb_data
*cl_data
;
1890 xg_menu_item_cb_data
*cb_data
;
1892 utf8_label
= get_utf8_string (item
->name
);
1893 utf8_key
= get_utf8_string (item
->key
);
1895 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
1897 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
1898 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
1900 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
1902 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
1904 cb_data
->unhighlight_id
= cb_data
->highlight_id
= cb_data
->select_id
= 0;
1905 cb_data
->help
= item
->help
;
1906 cb_data
->cl_data
= cl_data
;
1907 cb_data
->call_data
= item
->call_data
;
1909 g_signal_connect (G_OBJECT (w
),
1911 G_CALLBACK (menuitem_destroy_callback
),
1914 /* Put cb_data in widget, so we can get at it when modifying menubar */
1915 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
1917 /* final item, not a submenu */
1918 if (item
->call_data
&& ! item
->contents
)
1922 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
1925 if (! NILP (item
->help
) && highlight_cb
)
1927 /* We use enter/leave notify instead of select/deselect because
1928 select/deselect doesn't go well with detached menus. */
1929 cb_data
->highlight_id
1930 = g_signal_connect (G_OBJECT (w
),
1931 "enter-notify-event",
1932 G_CALLBACK (menuitem_highlight_callback
),
1934 cb_data
->unhighlight_id
1935 = g_signal_connect (G_OBJECT (w
),
1936 "leave-notify-event",
1937 G_CALLBACK (menuitem_highlight_callback
),
1944 static GtkWidget
*create_menus
P_ ((widget_value
*, FRAME_PTR
, GCallback
,
1945 GCallback
, GCallback
, int, int, int,
1946 GtkWidget
*, xg_menu_cb_data
*, char *));
1948 /* Create a full menu tree specified by DATA.
1949 F is the frame the created menu belongs to.
1950 SELECT_CB is the callback to use when a menu item is selected.
1951 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
1952 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1953 POP_UP_P is non-zero if we shall create a popup menu.
1954 MENU_BAR_P is non-zero if we shall create a menu bar.
1955 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
1956 if MENU_BAR_P is non-zero.
1957 TOPMENU is the topmost GtkWidget that others shall be placed under.
1958 It may be NULL, in that case we create the appropriate widget
1959 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
1960 CL_DATA is the callback data we shall use for this menu, or NULL
1961 if we haven't set the first callback yet.
1962 NAME is the name to give to the top level menu if this function
1963 creates it. May be NULL to not set any name.
1965 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
1968 This function calls itself to create submenus. */
1971 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
1972 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
1975 GCallback select_cb
;
1976 GCallback deactivate_cb
;
1977 GCallback highlight_cb
;
1982 xg_menu_cb_data
*cl_data
;
1986 GtkWidget
*wmenu
= topmenu
;
1987 GSList
*group
= NULL
;
1993 wmenu
= gtk_menu_new ();
1994 xg_set_screen (wmenu
, f
);
1996 else wmenu
= gtk_menu_bar_new ();
1998 /* Put cl_data on the top menu for easier access. */
1999 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2000 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2001 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2002 G_CALLBACK (menu_destroy_callback
), cl_data
);
2005 gtk_widget_set_name (wmenu
, name
);
2008 g_signal_connect (G_OBJECT (wmenu
),
2009 "selection-done", deactivate_cb
, 0);
2011 g_signal_connect (G_OBJECT (wmenu
),
2012 "grab-notify", G_CALLBACK (menu_grab_callback
), 0);
2015 if (! menu_bar_p
&& add_tearoff_p
)
2017 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2018 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2020 g_signal_connect (G_OBJECT (tearoff
), "activate",
2021 G_CALLBACK (tearoff_activate
), 0);
2024 for (item
= data
; item
; item
= item
->next
)
2028 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2029 && !xg_separator_p (item
->name
))
2032 /* A title for a popup. We do the same as GTK does when
2033 creating titles, but it does not look good. */
2035 utf8_label
= get_utf8_string (item
->name
);
2037 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2038 w
= gtk_menu_item_new_with_label (utf8_label
);
2039 gtk_widget_set_sensitive (w
, FALSE
);
2040 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2042 else if (xg_separator_p (item
->name
))
2045 /* GTK only have one separator type. */
2046 w
= gtk_separator_menu_item_new ();
2050 w
= xg_create_one_menuitem (item
,
2052 item
->contents
? 0 : select_cb
,
2059 GtkWidget
*submenu
= create_menus (item
->contents
,
2070 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2074 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2075 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2081 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2082 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2083 with some text and buttons.
2084 F is the frame the created item belongs to.
2085 NAME is the name to use for the top widget.
2086 VAL is a widget_value structure describing items to be created.
2087 SELECT_CB is the callback to use when a menu item is selected or
2088 a dialog button is pressed.
2089 DEACTIVATE_CB is the callback to use when an item is deactivated.
2090 For a menu, when a sub menu is not shown anymore, for a dialog it is
2091 called when the dialog is popped down.
2092 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2094 Returns the widget created. */
2097 xg_create_widget (type
, name
, f
, val
,
2098 select_cb
, deactivate_cb
, highlight_cb
)
2103 GCallback select_cb
;
2104 GCallback deactivate_cb
;
2105 GCallback highlight_cb
;
2108 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2109 int pop_up_p
= strcmp (type
, "popup") == 0;
2111 if (strcmp (type
, "dialog") == 0)
2113 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2114 xg_set_screen (w
, f
);
2115 gtk_window_set_transient_for (GTK_WINDOW (w
),
2116 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2117 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2118 gtk_widget_set_name (w
, "emacs-dialog");
2119 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2121 else if (menu_bar_p
|| pop_up_p
)
2123 w
= create_menus (val
->contents
,
2135 /* Set the cursor to an arrow for popup menus when they are mapped.
2136 This is done by default for menu bar menus. */
2139 /* Must realize so the GdkWindow inside the widget is created. */
2140 gtk_widget_realize (w
);
2141 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2146 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2153 /* Return the label for menu item WITEM. */
2156 xg_get_menu_item_label (witem
)
2159 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2160 return gtk_label_get_label (wlabel
);
2163 /* Return non-zero if the menu item WITEM has the text LABEL. */
2166 xg_item_label_same_p (witem
, label
)
2171 char *utf8_label
= get_utf8_string (label
);
2172 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2174 if (! old_label
&& ! utf8_label
)
2176 else if (old_label
&& utf8_label
)
2177 is_same
= strcmp (utf8_label
, old_label
) == 0;
2179 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2184 /* Destroy widgets in LIST. */
2187 xg_destroy_widgets (list
)
2192 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2194 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2196 /* Destroying the widget will remove it from the container it is in. */
2197 gtk_widget_destroy (w
);
2201 /* Update the top level names in MENUBAR (i.e. not submenus).
2202 F is the frame the menu bar belongs to.
2203 *LIST is a list with the current menu bar names (menu item widgets).
2204 ITER is the item within *LIST that shall be updated.
2205 POS is the numerical position, starting at 0, of ITER in *LIST.
2206 VAL describes what the menu bar shall look like after the update.
2207 SELECT_CB is the callback to use when a menu item is selected.
2208 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2209 CL_DATA points to the callback data to be used for this menu bar.
2211 This function calls itself to walk through the menu bar names. */
2214 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2215 select_cb
, highlight_cb
, cl_data
)
2222 GCallback select_cb
;
2223 GCallback highlight_cb
;
2224 xg_menu_cb_data
*cl_data
;
2226 if (! iter
&& ! val
)
2228 else if (iter
&& ! val
)
2230 /* Item(s) have been removed. Remove all remaining items. */
2231 xg_destroy_widgets (iter
);
2237 else if (! iter
&& val
)
2239 /* Item(s) added. Add all new items in one call. */
2240 create_menus (val
, f
, select_cb
, 0, highlight_cb
,
2241 0, 1, 0, menubar
, cl_data
, 0);
2247 /* Below this neither iter or val is NULL */
2248 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2250 /* This item is still the same, check next item. */
2252 iter
= g_list_next (iter
);
2255 else /* This item is changed. */
2257 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2258 GtkMenuItem
*witem2
= 0;
2259 int val_in_menubar
= 0;
2260 int iter_in_new_menubar
= 0;
2264 /* See if the changed entry (val) is present later in the menu bar */
2266 iter2
&& ! val_in_menubar
;
2267 iter2
= g_list_next (iter2
))
2269 witem2
= GTK_MENU_ITEM (iter2
->data
);
2270 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2273 /* See if the current entry (iter) is present later in the
2274 specification for the new menu bar. */
2275 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2276 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2278 if (val_in_menubar
&& ! iter_in_new_menubar
)
2282 /* This corresponds to:
2287 gtk_widget_ref (GTK_WIDGET (witem
));
2288 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2289 gtk_widget_destroy (GTK_WIDGET (witem
));
2291 /* Must get new list since the old changed. */
2292 g_list_free (*list
);
2293 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2294 while (nr
-- > 0) iter
= g_list_next (iter
);
2296 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2298 /* This corresponds to:
2301 Rename B to X. This might seem to be a strange thing to do,
2302 since if there is a menu under B it will be totally wrong for X.
2303 But consider editing a C file. Then there is a C-mode menu
2304 (corresponds to B above).
2305 If then doing C-x C-f the minibuf menu (X above) replaces the
2306 C-mode menu. When returning from the minibuffer, we get
2307 back the C-mode menu. Thus we do:
2308 Rename B to X (C-mode to minibuf menu)
2309 Rename X to B (minibuf to C-mode menu).
2310 If the X menu hasn't been invoked, the menu under B
2311 is up to date when leaving the minibuffer. */
2312 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2313 char *utf8_label
= get_utf8_string (val
->name
);
2314 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2316 gtk_label_set_text (wlabel
, utf8_label
);
2318 /* If this item has a submenu that has been detached, change
2319 the title in the WM decorations also. */
2320 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2321 /* Set the title of the detached window. */
2322 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2324 iter
= g_list_next (iter
);
2328 else if (! val_in_menubar
&& iter_in_new_menubar
)
2330 /* This corresponds to:
2337 GtkWidget
*w
= xg_create_one_menuitem (val
,
2344 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2345 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2347 g_list_free (*list
);
2348 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2349 while (nr
-- > 0) iter
= g_list_next (iter
);
2350 iter
= g_list_next (iter
);
2354 else /* if (val_in_menubar && iter_in_new_menubar) */
2357 /* This corresponds to:
2362 gtk_widget_ref (GTK_WIDGET (witem2
));
2363 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2364 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2365 GTK_WIDGET (witem2
), pos
);
2366 gtk_widget_unref (GTK_WIDGET (witem2
));
2368 g_list_free (*list
);
2369 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2370 while (nr
-- > 0) iter
= g_list_next (iter
);
2376 /* Update the rest of the menu bar. */
2377 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2378 select_cb
, highlight_cb
, cl_data
);
2381 /* Update the menu item W so it corresponds to VAL.
2382 SELECT_CB is the callback to use when a menu item is selected.
2383 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2384 CL_DATA is the data to set in the widget for menu invokation. */
2387 xg_update_menu_item (val
, w
, select_cb
, highlight_cb
, cl_data
)
2390 GCallback select_cb
;
2391 GCallback highlight_cb
;
2392 xg_menu_cb_data
*cl_data
;
2399 const char *old_label
= 0;
2400 const char *old_key
= 0;
2401 xg_menu_item_cb_data
*cb_data
;
2403 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2404 utf8_label
= get_utf8_string (val
->name
);
2405 utf8_key
= get_utf8_string (val
->key
);
2407 /* See if W is a menu item with a key. See make_menu_item above. */
2408 if (GTK_IS_HBOX (wchild
))
2410 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2412 wlbl
= GTK_LABEL (list
->data
);
2413 wkey
= GTK_LABEL (list
->next
->data
);
2418 /* Remove the key and keep just the label. */
2419 gtk_widget_ref (GTK_WIDGET (wlbl
));
2420 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2421 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2426 else /* Just a label. */
2428 wlbl
= GTK_LABEL (wchild
);
2430 /* Check if there is now a key. */
2433 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2434 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2436 wlbl
= GTK_LABEL (list
->data
);
2437 wkey
= GTK_LABEL (list
->next
->data
);
2440 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2441 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2446 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2447 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2449 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2450 gtk_label_set_text (wkey
, utf8_key
);
2452 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2453 gtk_label_set_text (wlbl
, utf8_label
);
2455 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2456 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2458 if (! val
->enabled
&& GTK_WIDGET_SENSITIVE (w
))
2459 gtk_widget_set_sensitive (w
, FALSE
);
2460 else if (val
->enabled
&& ! GTK_WIDGET_SENSITIVE (w
))
2461 gtk_widget_set_sensitive (w
, TRUE
);
2463 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2467 cb_data
->call_data
= val
->call_data
;
2468 cb_data
->help
= val
->help
;
2469 cb_data
->cl_data
= cl_data
;
2471 /* We assume the callback functions don't change. */
2472 if (val
->call_data
&& ! val
->contents
)
2474 /* This item shall have a select callback. */
2475 if (! cb_data
->select_id
)
2477 = g_signal_connect (G_OBJECT (w
), "activate",
2478 select_cb
, cb_data
);
2480 else if (cb_data
->select_id
)
2482 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2483 cb_data
->select_id
= 0;
2486 if (NILP (cb_data
->help
))
2488 /* Shall not have help. Remove if any existed previously. */
2489 if (cb_data
->highlight_id
)
2491 g_signal_handler_disconnect (G_OBJECT (w
),
2492 cb_data
->highlight_id
);
2493 cb_data
->highlight_id
= 0;
2495 if (cb_data
->unhighlight_id
)
2497 g_signal_handler_disconnect (G_OBJECT (w
),
2498 cb_data
->unhighlight_id
);
2499 cb_data
->unhighlight_id
= 0;
2502 else if (! cb_data
->highlight_id
&& highlight_cb
)
2504 /* Have help now, but didn't previously. Add callback. */
2505 cb_data
->highlight_id
2506 = g_signal_connect (G_OBJECT (w
),
2507 "enter-notify-event",
2508 G_CALLBACK (menuitem_highlight_callback
),
2510 cb_data
->unhighlight_id
2511 = g_signal_connect (G_OBJECT (w
),
2512 "leave-notify-event",
2513 G_CALLBACK (menuitem_highlight_callback
),
2519 /* Update the toggle menu item W so it corresponds to VAL. */
2522 xg_update_toggle_item (val
, w
)
2526 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2529 /* Update the radio menu item W so it corresponds to VAL. */
2532 xg_update_radio_item (val
, w
)
2536 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2539 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2540 SUBMENU may be NULL, in that case a new menu is created.
2541 F is the frame the menu bar belongs to.
2542 VAL describes the contents of the menu bar.
2543 SELECT_CB is the callback to use when a menu item is selected.
2544 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2545 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2546 CL_DATA is the call back data to use for any newly created items.
2548 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2552 xg_update_submenu (submenu
, f
, val
,
2553 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2557 GCallback select_cb
;
2558 GCallback deactivate_cb
;
2559 GCallback highlight_cb
;
2560 xg_menu_cb_data
*cl_data
;
2562 GtkWidget
*newsub
= submenu
;
2566 int has_tearoff_p
= 0;
2567 GList
*first_radio
= 0;
2570 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2572 for (cur
= val
, iter
= list
;
2574 iter
= g_list_next (iter
), cur
= cur
->next
)
2576 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2578 /* Skip tearoff items, they have no counterpart in val. */
2579 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2582 iter
= g_list_next (iter
);
2583 if (iter
) w
= GTK_WIDGET (iter
->data
);
2587 /* Remember first radio button in a group. If we get a mismatch in
2588 a radio group we must rebuild the whole group so that the connections
2589 in GTK becomes correct. */
2590 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2592 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2593 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2596 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2598 if (! xg_separator_p (cur
->name
))
2601 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2603 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2605 xg_update_toggle_item (cur
, w
);
2606 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2608 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2610 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2612 xg_update_radio_item (cur
, w
);
2613 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2615 else if (GTK_IS_MENU_ITEM (w
))
2617 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2620 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2621 xg_separator_p (cur
->name
))
2624 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2626 sub
= gtk_menu_item_get_submenu (witem
);
2627 if (sub
&& ! cur
->contents
)
2629 /* Not a submenu anymore. */
2630 gtk_widget_ref (sub
);
2631 gtk_menu_item_remove_submenu (witem
);
2632 gtk_widget_destroy (sub
);
2634 else if (cur
->contents
)
2638 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2639 select_cb
, deactivate_cb
,
2640 highlight_cb
, cl_data
);
2642 /* If this item just became a submenu, we must set it. */
2644 gtk_menu_item_set_submenu (witem
, nsub
);
2649 /* Structural difference. Remove everything from here and down
2655 /* Remove widgets from first structual change. */
2658 /* If we are adding new menu items below, we must remove from
2659 first radio button so that radio groups become correct. */
2660 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2661 else xg_destroy_widgets (iter
);
2666 /* More items added. Create them. */
2667 newsub
= create_menus (cur
,
2680 if (list
) g_list_free (list
);
2685 /* Update the MENUBAR.
2686 F is the frame the menu bar belongs to.
2687 VAL describes the contents of the menu bar.
2688 If DEEP_P is non-zero, rebuild all but the top level menu names in
2689 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2690 SELECT_CB is the callback to use when a menu item is selected.
2691 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2692 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2695 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2696 select_cb
, deactivate_cb
, highlight_cb
)
2701 GCallback select_cb
;
2702 GCallback deactivate_cb
;
2703 GCallback highlight_cb
;
2705 xg_menu_cb_data
*cl_data
;
2706 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2710 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2713 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2714 select_cb
, highlight_cb
, cl_data
);
2720 /* Update all sub menus.
2721 We must keep the submenus (GTK menu item widgets) since the
2722 X Window in the XEvent that activates the menu are those widgets. */
2724 /* Update cl_data, menu_item things in F may have changed. */
2725 update_cl_data (cl_data
, f
, highlight_cb
);
2727 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2734 /* Find sub menu that corresponds to val and update it. */
2735 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2737 witem
= GTK_MENU_ITEM (iter
->data
);
2738 if (xg_item_label_same_p (witem
, cur
->name
))
2740 sub
= gtk_menu_item_get_submenu (witem
);
2745 newsub
= xg_update_submenu (sub
,
2752 /* sub may still be NULL. If we just updated non deep and added
2753 a new menu bar item, it has no sub menu yet. So we set the
2754 newly created sub menu under witem. */
2757 xg_set_screen (newsub
, f
);
2758 gtk_menu_item_set_submenu (witem
, newsub
);
2764 gtk_widget_show_all (menubar
);
2767 /* Recompute all the widgets of frame F, when the menu bar has been
2768 changed. Value is non-zero if widgets were updated. */
2771 xg_update_frame_menubar (f
)
2774 struct x_output
*x
= f
->output_data
.x
;
2777 if (!x
->menubar_widget
|| GTK_WIDGET_MAPPED (x
->menubar_widget
))
2782 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2784 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2786 gtk_widget_show_all (x
->menubar_widget
);
2787 gtk_widget_size_request (x
->menubar_widget
, &req
);
2789 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2791 /* The height has changed, resize outer widget and set columns
2792 rows to what we had before adding the menu bar. */
2793 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2795 SET_FRAME_GARBAGED (f
);
2801 /* Get rid of the menu bar of frame F, and free its storage.
2802 This is used when deleting a frame, and when turning off the menu bar. */
2805 free_frame_menubar (f
)
2808 struct x_output
*x
= f
->output_data
.x
;
2810 if (x
->menubar_widget
)
2814 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2815 /* The menubar and its children shall be deleted when removed from
2817 x
->menubar_widget
= 0;
2818 FRAME_MENUBAR_HEIGHT (f
) = 0;
2820 /* The height has changed, resize outer widget and set columns
2821 rows to what we had before removing the menu bar. */
2822 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2824 SET_FRAME_GARBAGED (f
);
2831 /***********************************************************************
2832 Scroll bar functions
2833 ***********************************************************************/
2836 /* Setting scroll bar values invokes the callback. Use this variable
2837 to indicate that callback should do nothing. */
2839 int xg_ignore_gtk_scrollbar
;
2841 /* SET_SCROLL_BAR_X_WINDOW assumes the second argument fits in
2842 32 bits. But we want to store pointers, and they may be larger
2843 than 32 bits. Keep a mapping from integer index to widget pointers
2844 to get around the 32 bit limitation. */
2848 GtkWidget
**widgets
;
2853 /* Grow this much every time we need to allocate more */
2855 #define ID_TO_WIDGET_INCR 32
2857 /* Store the widget pointer W in id_to_widget and return the integer index. */
2860 xg_store_widget_in_map (w
)
2865 if (id_to_widget
.max_size
== id_to_widget
.used
)
2867 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
2869 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
2870 sizeof (GtkWidget
*)*new_size
);
2872 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
2873 id_to_widget
.widgets
[i
] = 0;
2874 id_to_widget
.max_size
= new_size
;
2877 /* Just loop over the array and find a free place. After all,
2878 how many scroll bars are we creating? Should be a small number.
2879 The check above guarantees we will find a free place. */
2880 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
2882 if (! id_to_widget
.widgets
[i
])
2884 id_to_widget
.widgets
[i
] = w
;
2885 ++id_to_widget
.used
;
2891 /* Should never end up here */
2895 /* Remove pointer at IDX from id_to_widget.
2896 Called when scroll bar is destroyed. */
2899 xg_remove_widget_from_map (idx
)
2902 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2904 id_to_widget
.widgets
[idx
] = 0;
2905 --id_to_widget
.used
;
2909 /* Get the widget pointer at IDX from id_to_widget. */
2912 xg_get_widget_from_map (idx
)
2915 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2916 return id_to_widget
.widgets
[idx
];
2921 /* Return the scrollbar id for X Window WID on display DPY.
2922 Return -1 if WID not in id_to_widget. */
2925 xg_get_scroll_id_for_window (dpy
, wid
)
2932 w
= xg_win_to_widget (dpy
, wid
);
2936 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
2937 if (id_to_widget
.widgets
[idx
] == w
)
2944 /* Callback invoked when scroll bar WIDGET is destroyed.
2945 DATA is the index into id_to_widget for WIDGET.
2946 We free pointer to last scroll bar values here and remove the index. */
2949 xg_gtk_scroll_destroy (widget
, data
)
2954 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
2956 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
2958 xg_remove_widget_from_map (id
);
2961 /* Callback for button press/release events. Used to start timer so that
2962 the scroll bar repetition timer in GTK gets handeled.
2963 Also, sets bar->dragging to Qnil when dragging (button release) is done.
2964 WIDGET is the scroll bar widget the event is for (not used).
2965 EVENT contains the event.
2966 USER_DATA points to the struct scrollbar structure.
2968 Returns FALSE to tell GTK that it shall continue propagate the event
2972 scroll_bar_button_cb (widget
, event
, user_data
)
2974 GdkEventButton
*event
;
2977 if (event
->type
== GDK_BUTTON_PRESS
&& ! xg_timer
)
2979 else if (event
->type
== GDK_BUTTON_RELEASE
)
2981 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
2982 if (xg_timer
) xg_stop_timer ();
2983 bar
->dragging
= Qnil
;
2989 /* Create a scroll bar widget for frame F. Store the scroll bar
2991 SCROLL_CALLBACK is the callback to invoke when the value of the
2993 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
2994 to set resources for the widget. */
2997 xg_create_scroll_bar (f
, bar
, scroll_callback
, scroll_bar_name
)
2999 struct scroll_bar
*bar
;
3000 GCallback scroll_callback
;
3001 char *scroll_bar_name
;
3008 /* Page, step increment values are not so important here, they
3009 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3010 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3013 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3014 webox
= gtk_event_box_new ();
3015 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3016 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3018 scroll_id
= xg_store_widget_in_map (wscroll
);
3020 g_signal_connect (G_OBJECT (wscroll
),
3024 /* The EMACS_INT cast avoids a warning. */
3025 g_signal_connect (G_OBJECT (wscroll
),
3027 G_CALLBACK (xg_gtk_scroll_destroy
),
3028 (gpointer
) (EMACS_INT
) scroll_id
);
3030 /* Connect to button press and button release to detect if any scroll bar
3032 g_signal_connect (G_OBJECT (wscroll
),
3033 "button-press-event",
3034 G_CALLBACK (scroll_bar_button_cb
),
3036 g_signal_connect (G_OBJECT (wscroll
),
3037 "button-release-event",
3038 G_CALLBACK (scroll_bar_button_cb
),
3041 /* The scroll bar widget does not draw on a window of its own. Instead
3042 it draws on the parent window, in this case the edit widget. So
3043 whenever the edit widget is cleared, the scroll bar needs to redraw
3044 also, which causes flicker. Put an event box between the edit widget
3045 and the scroll bar, so the scroll bar instead draws itself on the
3046 event box window. */
3047 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3048 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3051 /* Set the cursor to an arrow. */
3052 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3054 SET_SCROLL_BAR_X_WINDOW (bar
, scroll_id
);
3057 /* Make the scroll bar represented by SCROLLBAR_ID visible. */
3060 xg_show_scroll_bar (scrollbar_id
)
3063 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3065 gtk_widget_show_all (gtk_widget_get_parent (w
));
3068 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3071 xg_remove_scroll_bar (f
, scrollbar_id
)
3075 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3078 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3079 gtk_widget_destroy (w
);
3080 gtk_widget_destroy (wparent
);
3081 SET_FRAME_GARBAGED (f
);
3085 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3087 TOP/LEFT are the new pixel positions where the bar shall appear.
3088 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3091 xg_update_scrollbar_pos (f
, scrollbar_id
, top
, left
, width
, height
)
3100 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3104 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3105 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3107 /* Move and resize to new values. */
3108 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3109 gtk_widget_set_size_request (wscroll
, width
, height
);
3110 gtk_widget_queue_draw (wparent
);
3111 gdk_window_process_all_updates ();
3112 /* GTK does not redraw until the main loop is entered again, but
3113 if there are no X events pending we will not enter it. So we sync
3114 here to get some events. */
3116 SET_FRAME_GARBAGED (f
);
3117 cancel_mouse_face (f
);
3121 /* Set the thumb size and position of scroll bar BAR. We are currently
3122 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3125 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
3126 struct scroll_bar
*bar
;
3127 int portion
, position
, whole
;
3129 GtkWidget
*wscroll
= xg_get_widget_from_map (SCROLL_BAR_X_WINDOW (bar
));
3131 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3133 if (wscroll
&& NILP (bar
->dragging
))
3142 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3144 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3145 rather than the real portion value. This makes the thumb less likely
3146 to resize and that looks better. */
3147 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3148 /* When the thumb is at the bottom, position == whole.
3149 So we need to increase `whole' to make space for the thumb. */
3156 top
= (gdouble
) position
/ whole
;
3157 shown
= (gdouble
) portion
/ whole
;
3160 size
= shown
* XG_SB_RANGE
;
3161 size
= min (size
, XG_SB_RANGE
);
3162 size
= max (size
, 1);
3164 value
= top
* XG_SB_RANGE
;
3165 value
= min (value
, XG_SB_MAX
- size
);
3166 value
= max (value
, XG_SB_MIN
);
3168 /* Assume all lines are of equal size. */
3169 new_step
= size
/ max (1, FRAME_LINES (f
));
3171 if ((int) adj
->page_size
!= size
3172 || (int) adj
->step_increment
!= new_step
)
3174 adj
->page_size
= size
;
3175 adj
->step_increment
= new_step
;
3176 /* Assume a page increment is about 95% of the page size */
3177 adj
->page_increment
= (int) (0.95*adj
->page_size
);
3181 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3183 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3187 /* gtk_range_set_value invokes the callback. Set
3188 ignore_gtk_scrollbar to make the callback do nothing */
3189 xg_ignore_gtk_scrollbar
= 1;
3191 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3192 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3194 gtk_adjustment_changed (adj
);
3196 xg_ignore_gtk_scrollbar
= 0;
3204 /***********************************************************************
3206 ***********************************************************************/
3207 /* The key for the data we put in the GtkImage widgets. The data is
3208 the image used by Emacs. We use this to see if we need to update
3209 the GtkImage with a new image. */
3210 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3212 /* Callback function invoked when a tool bar item is pressed.
3213 W is the button widget in the tool bar that got pressed,
3214 CLIENT_DATA is an integer that is the index of the button in the
3215 tool bar. 0 is the first button. */
3218 xg_tool_bar_callback (w
, client_data
)
3220 gpointer client_data
;
3222 /* The EMACS_INT cast avoids a warning. */
3223 int idx
= (int) (EMACS_INT
) client_data
;
3224 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3225 Lisp_Object key
, frame
;
3226 struct input_event event
;
3229 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3232 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3234 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3235 XSETFRAME (frame
, f
);
3236 event
.kind
= TOOL_BAR_EVENT
;
3237 event
.frame_or_window
= frame
;
3239 kbd_buffer_store_event (&event
);
3241 event
.kind
= TOOL_BAR_EVENT
;
3242 event
.frame_or_window
= frame
;
3244 event
.modifiers
= 0; /* These are not available. */
3245 kbd_buffer_store_event (&event
);
3248 /* This callback is called when a tool bar is detached. We must set
3249 the height of the tool bar to zero when this happens so frame sizes
3250 are correctly calculated.
3251 WBOX is the handle box widget that enables detach/attach of the tool bar.
3252 W is the tool bar widget.
3253 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3256 xg_tool_bar_detach_callback (wbox
, w
, client_data
)
3259 gpointer client_data
;
3261 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3265 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3267 /* When detaching a tool bar, not everything dissapear. There are
3268 a few pixels left that are used to drop the tool bar back into
3270 FRAME_TOOLBAR_HEIGHT (f
) = 2;
3272 /* The height has changed, resize outer widget and set columns
3273 rows to what we had before detaching the tool bar. */
3274 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3278 /* This callback is called when a tool bar is reattached. We must set
3279 the height of the tool bar when this happens so frame sizes
3280 are correctly calculated.
3281 WBOX is the handle box widget that enables detach/attach of the tool bar.
3282 W is the tool bar widget.
3283 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3286 xg_tool_bar_attach_callback (wbox
, w
, client_data
)
3289 gpointer client_data
;
3291 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3297 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3299 gtk_widget_size_request (w
, &req
);
3300 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3302 /* The height has changed, resize outer widget and set columns
3303 rows to what we had before attaching the tool bar. */
3304 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3308 /* This callback is called when the mouse enters or leaves a tool bar item.
3309 It is used for displaying and hiding the help text.
3310 W is the tool bar item, a button.
3311 EVENT is either an enter event or leave event.
3312 CLIENT_DATA is an integer that is the index of the button in the
3313 tool bar. 0 is the first button.
3315 Returns FALSE to tell GTK to keep processing this event. */
3318 xg_tool_bar_help_callback (w
, event
, client_data
)
3320 GdkEventCrossing
*event
;
3321 gpointer client_data
;
3323 /* The EMACS_INT cast avoids a warning. */
3324 int idx
= (int) (EMACS_INT
) client_data
;
3325 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3326 Lisp_Object help
, frame
;
3328 if (! GTK_IS_BUTTON (w
))
3333 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3336 if (event
->type
== GDK_ENTER_NOTIFY
)
3338 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3339 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3342 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3347 XSETFRAME (frame
, f
);
3348 kbd_buffer_store_help_event (frame
, help
);
3354 /* This callback is called when a tool bar item shall be redrawn.
3355 It modifies the expose event so that the GtkImage widget redraws the
3356 whole image. This to overcome a bug that makes GtkImage draw the image
3357 in the wrong place when it tries to redraw just a part of the image.
3358 W is the GtkImage to be redrawn.
3359 EVENT is the expose event for W.
3360 CLIENT_DATA is unused.
3362 Returns FALSE to tell GTK to keep processing this event. */
3365 xg_tool_bar_item_expose_callback (w
, event
, client_data
)
3367 GdkEventExpose
*event
;
3368 gpointer client_data
;
3372 gdk_drawable_get_size (event
->window
, &width
, &height
);
3374 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3375 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3377 event
->area
.x
= max (0, event
->area
.x
);
3378 event
->area
.y
= max (0, event
->area
.y
);
3380 event
->area
.width
= max (width
, event
->area
.width
);
3381 event
->area
.height
= max (height
, event
->area
.height
);
3386 /* This callback is called when a tool bar shall be redrawn.
3387 We need to update the tool bar from here in case the image cache
3388 has deleted the pixmaps used in the tool bar.
3389 W is the GtkToolbar to be redrawn.
3390 EVENT is the expose event for W.
3391 CLIENT_DATA is pointing to the frame for this tool bar.
3393 Returns FALSE to tell GTK to keep processing this event. */
3396 xg_tool_bar_expose_callback (w
, event
, client_data
)
3398 GdkEventExpose
*event
;
3399 gpointer client_data
;
3401 update_frame_tool_bar ((FRAME_PTR
) client_data
);
3405 /* Create a tool bar for frame F. */
3408 xg_create_tool_bar (f
)
3411 struct x_output
*x
= f
->output_data
.x
;
3413 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3415 x
->toolbar_widget
= gtk_toolbar_new ();
3416 x
->handlebox_widget
= gtk_handle_box_new ();
3417 x
->toolbar_detached
= 0;
3419 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3422 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3425 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3428 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3430 /* We only have icons, so override any user setting. We could
3431 use the caption property of the toolbar item (see update_frame_tool_bar
3432 below), but some of those strings are long, making the toolbar so
3433 long it does not fit on the screen. The GtkToolbar widget makes every
3434 item equal size, so the longest caption determine the size of every
3435 tool bar item. I think the creators of the GtkToolbar widget
3436 counted on 4 or 5 character long strings. */
3437 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3438 gtk_toolbar_set_orientation (GTK_TOOLBAR (x
->toolbar_widget
),
3439 GTK_ORIENTATION_HORIZONTAL
);
3441 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3442 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3443 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3444 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3445 g_signal_connect (G_OBJECT (x
->toolbar_widget
),
3447 G_CALLBACK (xg_tool_bar_expose_callback
),
3450 gtk_widget_show_all (x
->handlebox_widget
);
3452 gtk_widget_size_request (x
->toolbar_widget
, &req
);
3453 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3455 /* The height has changed, resize outer widget and set columns
3456 rows to what we had before adding the tool bar. */
3457 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3459 SET_FRAME_GARBAGED (f
);
3462 /* Update the tool bar for frame F. Add new buttons and remove old. */
3465 update_frame_tool_bar (f
)
3469 GtkRequisition old_req
, new_req
;
3472 struct x_output
*x
= f
->output_data
.x
;
3473 int hmargin
, vmargin
;
3475 if (! FRAME_GTK_WIDGET (f
))
3480 if (INTEGERP (Vtool_bar_button_margin
)
3481 && XINT (Vtool_bar_button_margin
) > 0)
3483 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3484 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3486 else if (CONSP (Vtool_bar_button_margin
))
3488 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3489 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3490 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3492 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3493 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3494 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3497 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3498 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3499 i.e. zero. This means that margins less than
3500 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3501 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3502 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3504 if (! x
->toolbar_widget
)
3505 xg_create_tool_bar (f
);
3507 gtk_widget_size_request (x
->toolbar_widget
, &old_req
);
3509 icon_list
= gtk_container_get_children (GTK_CONTAINER (x
->toolbar_widget
));
3512 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3514 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3516 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3517 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3522 GtkWidget
*wicon
= iter
? GTK_WIDGET (iter
->data
) : 0;
3524 if (iter
) iter
= g_list_next (iter
);
3526 /* If image is a vector, choose the image according to the
3528 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3529 if (VECTORP (image
))
3533 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3534 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3537 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3538 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3540 xassert (ASIZE (image
) >= idx
);
3541 image
= AREF (image
, idx
);
3546 /* Ignore invalid image specifications. */
3547 if (!valid_image_p (image
))
3549 if (wicon
) gtk_widget_hide (wicon
);
3553 img_id
= lookup_image (f
, image
);
3554 img
= IMAGE_FROM_ID (f
, img_id
);
3555 prepare_image_for_display (f
, img
);
3557 if (img
->load_failed_p
|| img
->pixmap
== None
)
3559 if (wicon
) gtk_widget_hide (wicon
);
3565 GtkWidget
*w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
3567 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
3569 /* The EMACS_INT cast avoids a warning. */
3570 gtk_toolbar_append_item (GTK_TOOLBAR (x
->toolbar_widget
),
3573 GTK_SIGNAL_FUNC (xg_tool_bar_callback
),
3574 (gpointer
) (EMACS_INT
) i
);
3576 /* Save the image so we can see if an update is needed when
3577 this function is called again. */
3578 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
3579 (gpointer
)img
->pixmap
);
3581 /* Catch expose events to overcome an annoying redraw bug, see
3582 comment for xg_tool_bar_item_expose_callback. */
3583 g_signal_connect (G_OBJECT (w
),
3585 G_CALLBACK (xg_tool_bar_item_expose_callback
),
3588 /* We must set sensitive on the button that is the parent
3589 of the GtkImage parent. Go upwards until we find the button. */
3590 while (! GTK_IS_BUTTON (w
))
3591 w
= gtk_widget_get_parent (w
);
3595 /* Save the frame in the button so the xg_tool_bar_callback
3597 g_object_set_data (G_OBJECT (w
), XG_FRAME_DATA
, (gpointer
)f
);
3598 gtk_widget_set_sensitive (w
, enabled_p
);
3600 /* Use enter/leave notify to show help. We use the events
3601 rather than the GtkButton specific signals "enter" and
3602 "leave", so we can have only one callback. The event
3603 will tell us what kind of event it is. */
3604 /* The EMACS_INT cast avoids a warning. */
3605 g_signal_connect (G_OBJECT (w
),
3606 "enter-notify-event",
3607 G_CALLBACK (xg_tool_bar_help_callback
),
3608 (gpointer
) (EMACS_INT
) i
);
3609 g_signal_connect (G_OBJECT (w
),
3610 "leave-notify-event",
3611 G_CALLBACK (xg_tool_bar_help_callback
),
3612 (gpointer
) (EMACS_INT
) i
);
3617 /* The child of the tool bar is a button. Inside that button
3618 is a vbox. Inside that vbox is the GtkImage. */
3619 GtkWidget
*wvbox
= gtk_bin_get_child (GTK_BIN (wicon
));
3620 GList
*chlist
= gtk_container_get_children (GTK_CONTAINER (wvbox
));
3621 GtkImage
*wimage
= GTK_IMAGE (chlist
->data
);
3622 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
3623 XG_TOOL_BAR_IMAGE_DATA
);
3624 g_list_free (chlist
);
3626 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
3628 if (old_img
!= img
->pixmap
)
3629 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
3631 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
3632 (gpointer
)img
->pixmap
);
3634 gtk_widget_set_sensitive (wicon
, enabled_p
);
3635 gtk_widget_show (wicon
);
3641 /* Remove buttons not longer needed. We just hide them so they
3642 can be reused later on. */
3645 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3646 gtk_widget_hide (w
);
3647 iter
= g_list_next (iter
);
3650 gtk_widget_size_request (x
->toolbar_widget
, &new_req
);
3651 if (old_req
.height
!= new_req
.height
3652 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
3654 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
3655 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3658 if (icon_list
) g_list_free (icon_list
);
3663 /* Deallocate all resources for the tool bar on frame F.
3664 Remove the tool bar. */
3667 free_frame_tool_bar (f
)
3670 struct x_output
*x
= f
->output_data
.x
;
3672 if (x
->toolbar_widget
)
3675 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
3676 x
->handlebox_widget
);
3677 x
->toolbar_widget
= 0;
3678 x
->handlebox_widget
= 0;
3679 FRAME_TOOLBAR_HEIGHT (f
) = 0;
3681 /* The height has changed, resize outer widget and set columns
3682 rows to what we had before removing the tool bar. */
3683 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3685 SET_FRAME_GARBAGED (f
);
3692 /***********************************************************************
3694 ***********************************************************************/
3698 GtkBindingSet
*binding_set
;
3700 xg_ignore_gtk_scrollbar
= 0;
3701 xg_detached_menus
= 0;
3702 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
3703 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
3705 id_to_widget
.max_size
= id_to_widget
.used
= 0;
3706 id_to_widget
.widgets
= 0;
3708 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
3709 bindings. It doesn't seem to be any way to remove properties,
3710 so we set it to VoidSymbol which in X means "no key". */
3711 gtk_settings_set_string_property (gtk_settings_get_default (),
3712 "gtk-menu-bar-accel",
3716 /* Make GTK text input widgets use Emacs style keybindings. This is
3718 gtk_settings_set_string_property (gtk_settings_get_default (),
3719 "gtk-key-theme-name",
3723 /* Make dialogs close on C-g. Since file dialog inherits from
3724 dialog, this works for them also. */
3725 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_DIALOG
));
3726 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3729 /* Make menus close on C-g. */
3730 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_MENU_SHELL
));
3731 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3735 #endif /* USE_GTK */
3737 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
3738 (do not change this comment) */