1 /* Functions for creating and updating GTK widgets.
2 Copyright (C) 2003, 2004, 2005, 2006 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
*) xmalloc (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 have a file, let GTK do all the image handling.
326 This seems to be the only way to make insensitive and activated icons
327 look good in all cases. */
328 Lisp_Object specified_file
= Qnil
;
331 extern Lisp_Object QCfile
;
333 for (tail
= XCDR (img
->spec
);
334 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
335 tail
= XCDR (XCDR (tail
)))
336 if (EQ (XCAR (tail
), QCfile
))
337 specified_file
= XCAR (XCDR (tail
));
339 /* We already loaded the image once before calling this
340 function, so this only fails if the image file has been removed.
341 In that case, use the pixmap already loaded. */
343 if (STRINGP (specified_file
)
344 && STRINGP (file
= x_find_image_file (specified_file
)))
347 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
349 gtk_image_set_from_file (old_widget
, SSDATA (file
));
351 return GTK_WIDGET (old_widget
);
354 /* No file, do the image handling ourselves. This will look very bad
355 on a monochrome display, and sometimes bad on all displays with
358 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
359 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
360 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
362 if (x_screen_planes (f
) > 8 || x_screen_planes (f
) == 1)
365 old_widget
= GTK_IMAGE (gtk_image_new_from_pixmap (gpix
, gmask
));
367 gtk_image_set_from_pixmap (old_widget
, gpix
, gmask
);
372 /* This is a workaround to make icons look good on pseudo color
373 displays. Apparently GTK expects the images to have an alpha
374 channel. If they don't, insensitive and activated icons will
375 look bad. This workaround does not work on monochrome displays,
376 and is not needed on true color/static color displays (i.e.
377 16 bits and higher). */
378 GdkColormap
*cmap
= gtk_widget_get_colormap (widget
);
379 GdkPixbuf
*icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
382 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
384 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
386 g_object_unref (G_OBJECT (icon_buf
));
389 g_object_unref (G_OBJECT (gpix
));
390 if (gmask
) g_object_unref (G_OBJECT (gmask
));
392 return GTK_WIDGET (old_widget
);
396 /* Set CURSOR on W and all widgets W contain. We must do like this
397 for scroll bars and menu because they create widgets internally,
398 and it is those widgets that are visible. */
401 xg_set_cursor (w
, cursor
)
405 GList
*children
= gdk_window_peek_children (w
->window
);
407 gdk_window_set_cursor (w
->window
, cursor
);
409 /* The scroll bar widget has more than one GDK window (had to look at
410 the source to figure this out), and there is no way to set cursor
411 on widgets in GTK. So we must set the cursor for all GDK windows.
414 for ( ; children
; children
= g_list_next (children
))
415 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
418 /* Timer function called when a timeout occurs for xg_timer.
419 This function processes all GTK events in a recursive event loop.
420 This is done because GTK timer events are not seen by Emacs event
421 detection, Emacs only looks for X events. When a scroll bar has the
422 pointer (detected by button press/release events below) an Emacs
423 timer is started, and this function can then check if the GTK timer
424 has expired by calling the GTK event loop.
425 Also, when a menu is active, it has a small timeout before it
426 pops down the sub menu under it. */
429 xg_process_timeouts (timer
)
430 struct atimer
*timer
;
433 /* Ideally we would like to just handle timer events, like the Xt version
434 of this does in xterm.c, but there is no such feature in GTK. */
435 while (gtk_events_pending ())
436 gtk_main_iteration ();
440 /* Start the xg_timer with an interval of 0.1 seconds, if not already started.
441 xg_process_timeouts is called when the timer expires. The timer
442 started is continuous, i.e. runs until xg_stop_timer is called. */
450 EMACS_SET_SECS_USECS (interval
, 0, 100000);
451 xg_timer
= start_atimer (ATIMER_CONTINUOUS
,
458 /* Stop the xg_timer if started. */
465 cancel_atimer (xg_timer
);
470 /* Insert NODE into linked LIST. */
473 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
475 xg_list_node
*list_start
= list
->next
;
477 if (list_start
) list_start
->prev
= node
;
478 node
->next
= list_start
;
483 /* Remove NODE from linked LIST. */
486 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
488 xg_list_node
*list_start
= list
->next
;
489 if (node
== list_start
)
491 list
->next
= node
->next
;
492 if (list
->next
) list
->next
->prev
= 0;
496 node
->prev
->next
= node
->next
;
497 if (node
->next
) node
->next
->prev
= node
->prev
;
501 /* Allocate and return a utf8 version of STR. If STR is already
502 utf8 or NULL, just return STR.
503 If not, a new string is allocated and the caller must free the result
507 get_utf8_string (str
)
510 char *utf8_str
= str
;
512 /* If not UTF-8, try current locale. */
513 if (str
&& !g_utf8_validate (str
, -1, NULL
))
514 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
521 /***********************************************************************
522 General functions for creating widgets, resizing, events, e.t.c.
523 ***********************************************************************/
525 /* Make a geometry string and pass that to GTK. It seems this is the
526 only way to get geometry position right if the user explicitly
527 asked for a position when starting Emacs.
528 F is the frame we shall set geometry for. */
534 if (f
->size_hint_flags
& USPosition
)
536 int left
= f
->left_pos
;
537 int xneg
= f
->size_hint_flags
& XNegative
;
538 int top
= f
->top_pos
;
539 int yneg
= f
->size_hint_flags
& YNegative
;
547 sprintf (geom_str
, "=%dx%d%c%d%c%d",
548 FRAME_PIXEL_WIDTH (f
),
549 FRAME_TOTAL_PIXEL_HEIGHT (f
),
550 (xneg
? '-' : '+'), left
,
551 (yneg
? '-' : '+'), top
);
553 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
555 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
556 } else if (f
->size_hint_flags
& PPosition
) {
557 gtk_window_move (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
558 f
->left_pos
, f
->top_pos
);
563 /* Resize the outer window of frame F after chainging the height.
564 This happend when the menu bar or the tool bar is added or removed.
565 COLUMNS/ROWS is the size the edit area shall have after the resize. */
568 xg_resize_outer_widget (f
, columns
, rows
)
573 /* If we are not mapped yet, set geometry once again, as window
574 height now have changed. */
575 if (! GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f
)))
578 xg_frame_set_char_size (f
, columns
, rows
);
579 gdk_window_process_all_updates ();
582 /* Function to handle resize of our widgets. Since Emacs has some layouts
583 that does not fit well with GTK standard containers, we do most layout
585 F is the frame to resize.
586 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
589 xg_resize_widgets (f
, pixelwidth
, pixelheight
)
591 int pixelwidth
, pixelheight
;
593 int mbheight
= FRAME_MENUBAR_HEIGHT (f
);
594 int tbheight
= FRAME_TOOLBAR_HEIGHT (f
);
595 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, (pixelheight
596 - mbheight
- tbheight
));
597 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
599 if (FRAME_GTK_WIDGET (f
)
600 && (columns
!= FRAME_COLS (f
)
601 || rows
!= FRAME_LINES (f
)
602 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
603 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
)))
605 struct x_output
*x
= f
->output_data
.x
;
608 all
.y
= mbheight
+ tbheight
;
611 all
.width
= pixelwidth
;
612 all
.height
= pixelheight
- mbheight
- tbheight
;
614 gtk_widget_size_allocate (x
->edit_widget
, &all
);
616 change_frame_size (f
, rows
, columns
, 0, 1, 0);
617 SET_FRAME_GARBAGED (f
);
618 cancel_mouse_face (f
);
623 /* Update our widget size to be COLS/ROWS characters for frame F. */
626 xg_frame_set_char_size (f
, cols
, rows
)
631 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
632 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
635 /* Take into account the size of the scroll bar. Always use the
636 number of columns occupied by the scroll bar here otherwise we
637 might end up with a frame width that is not a multiple of the
638 frame's character width which is bad for vertically split
640 f
->scroll_bar_actual_width
641 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
643 compute_fringe_widths (f
, 0);
645 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
646 after calculating that value. */
647 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
649 /* Must resize our top level widget. Font size may have changed,
650 but not rows/cols. */
651 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
652 pixelwidth
, pixelheight
);
653 xg_resize_widgets (f
, pixelwidth
, pixelheight
);
654 x_wm_set_size_hint (f
, 0, 0);
655 SET_FRAME_GARBAGED (f
);
656 cancel_mouse_face (f
);
659 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
660 Must be done like this, because GtkWidget:s can have "hidden"
661 X Window that aren't accessible.
663 Return 0 if no widget match WDESC. */
666 xg_win_to_widget (dpy
, wdesc
)
671 GtkWidget
*gwdesc
= 0;
675 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
680 event
.any
.window
= gdkwin
;
681 gwdesc
= gtk_get_event_widget (&event
);
688 /* Fill in the GdkColor C so that it represents PIXEL.
689 W is the widget that color will be used for. Used to find colormap. */
692 xg_pix_to_gcolor (w
, pixel
, c
)
697 GdkColormap
*map
= gtk_widget_get_colormap (w
);
698 gdk_colormap_query_color (map
, pixel
, c
);
701 /* Create and set up the GTK widgets for frame F.
702 Return 0 if creation failed, non-zero otherwise. */
705 xg_create_frame_widgets (f
)
718 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
719 xg_set_screen (wtop
, f
);
721 wvbox
= gtk_vbox_new (FALSE
, 0);
722 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
724 if (! wtop
|| ! wvbox
|| ! wfixed
)
726 if (wtop
) gtk_widget_destroy (wtop
);
727 if (wvbox
) gtk_widget_destroy (wvbox
);
728 if (wfixed
) gtk_widget_destroy (wfixed
);
734 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
735 gtk_widget_set_name (wtop
, EMACS_CLASS
);
736 gtk_widget_set_name (wvbox
, "pane");
737 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
739 /* If this frame has a title or name, set it in the title bar. */
740 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
741 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
743 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
745 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
746 FRAME_GTK_WIDGET (f
) = wfixed
;
747 f
->output_data
.x
->vbox_widget
= wvbox
;
749 gtk_fixed_set_has_window (GTK_FIXED (wfixed
), TRUE
);
751 gtk_widget_set_size_request (wfixed
, FRAME_PIXEL_WIDTH (f
),
752 FRAME_PIXEL_HEIGHT (f
));
754 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
755 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
757 if (FRAME_EXTERNAL_TOOL_BAR (f
))
758 update_frame_tool_bar (f
);
760 /* The tool bar is created but first there are no items in it.
761 This causes it to be zero height. Later items are added, but then
762 the frame is already mapped, so there is a "jumping" resize.
763 This makes geometry handling difficult, for example -0-0 will end
764 up in the wrong place as tool bar height has not been taken into account.
765 So we cheat a bit by setting a height that is what it will have
766 later on when tool bar items are added. */
767 if (FRAME_EXTERNAL_TOOL_BAR (f
) && f
->n_tool_bar_items
== 0)
768 FRAME_TOOLBAR_HEIGHT (f
) = 38;
771 /* We don't want this widget double buffered, because we draw on it
772 with regular X drawing primitives, so from a GTK/GDK point of
773 view, the widget is totally blank. When an expose comes, this
774 will make the widget blank, and then Emacs redraws it. This flickers
775 a lot, so we turn off double buffering. */
776 gtk_widget_set_double_buffered (wfixed
, FALSE
);
778 /* GTK documents says use gtk_window_set_resizable. But then a user
779 can't shrink the window from its starting size. */
780 gtk_window_set_policy (GTK_WINDOW (wtop
), TRUE
, TRUE
, TRUE
);
781 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
782 SSDATA (Vx_resource_name
),
783 SSDATA (Vx_resource_class
));
785 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
786 GTK is to destroy the widget. We want Emacs to do that instead. */
787 g_signal_connect (G_OBJECT (wtop
), "delete-event",
788 G_CALLBACK (gtk_true
), 0);
790 /* Convert our geometry parameters into a geometry string
792 GTK will itself handle calculating the real position this way. */
795 gtk_widget_add_events (wfixed
,
796 GDK_POINTER_MOTION_MASK
798 | GDK_BUTTON_PRESS_MASK
799 | GDK_BUTTON_RELEASE_MASK
801 | GDK_ENTER_NOTIFY_MASK
802 | GDK_LEAVE_NOTIFY_MASK
803 | GDK_FOCUS_CHANGE_MASK
805 | GDK_VISIBILITY_NOTIFY_MASK
);
807 /* Must realize the windows so the X window gets created. It is used
808 by callers of this function. */
809 gtk_widget_realize (wfixed
);
810 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
812 /* Since GTK clears its window by filling with the background color,
813 we must keep X and GTK background in sync. */
814 xg_pix_to_gcolor (wfixed
, f
->output_data
.x
->background_pixel
, &bg
);
815 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
817 /* Also, do not let any background pixmap to be set, this looks very
818 bad as Emacs overwrites the background pixmap with its own idea
819 of background color. */
820 style
= gtk_widget_get_modifier_style (wfixed
);
822 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
823 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
824 gtk_widget_modify_style (wfixed
, style
);
826 /* GTK does not set any border, and they look bad with GTK. */
828 f
->internal_border_width
= 0;
835 /* Set the normal size hints for the window manager, for frame F.
836 FLAGS is the flags word to use--or 0 meaning preserve the flags
837 that the window now has.
838 If USER_POSITION is nonzero, we set the User Position
839 flag (this is useful when FLAGS is 0). */
842 x_wm_set_size_hint (f
, flags
, user_position
)
847 if (FRAME_GTK_OUTER_WIDGET (f
))
849 /* Must use GTK routines here, otherwise GTK resets the size hints
850 to its own defaults. */
851 GdkGeometry size_hints
;
853 int base_width
, base_height
;
854 int min_rows
= 0, min_cols
= 0;
855 int win_gravity
= f
->win_gravity
;
859 memset (&size_hints
, 0, sizeof (size_hints
));
860 f
->output_data
.x
->size_hints
= size_hints
;
861 f
->output_data
.x
->hint_flags
= hint_flags
;
864 flags
= f
->size_hint_flags
;
866 size_hints
= f
->output_data
.x
->size_hints
;
867 hint_flags
= f
->output_data
.x
->hint_flags
;
869 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
870 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
871 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
873 hint_flags
|= GDK_HINT_BASE_SIZE
;
874 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
875 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
876 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
878 check_frame_size (f
, &min_rows
, &min_cols
);
880 size_hints
.base_width
= base_width
;
881 size_hints
.base_height
= base_height
;
882 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
883 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
886 /* These currently have a one to one mapping with the X values, but I
887 don't think we should rely on that. */
888 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
889 size_hints
.win_gravity
= 0;
890 if (win_gravity
== NorthWestGravity
)
891 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
892 else if (win_gravity
== NorthGravity
)
893 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
894 else if (win_gravity
== NorthEastGravity
)
895 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
896 else if (win_gravity
== WestGravity
)
897 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
898 else if (win_gravity
== CenterGravity
)
899 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
900 else if (win_gravity
== EastGravity
)
901 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
902 else if (win_gravity
== SouthWestGravity
)
903 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
904 else if (win_gravity
== SouthGravity
)
905 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
906 else if (win_gravity
== SouthEastGravity
)
907 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
908 else if (win_gravity
== StaticGravity
)
909 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
911 if (flags
& PPosition
) hint_flags
|= GDK_HINT_POS
;
912 if (flags
& USPosition
) hint_flags
|= GDK_HINT_USER_POS
;
913 if (flags
& USSize
) hint_flags
|= GDK_HINT_USER_SIZE
;
917 hint_flags
&= ~GDK_HINT_POS
;
918 hint_flags
|= GDK_HINT_USER_POS
;
923 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
924 FRAME_GTK_OUTER_WIDGET (f
),
928 f
->output_data
.x
->size_hints
= size_hints
;
929 f
->output_data
.x
->hint_flags
= hint_flags
;
934 /* Change background color of a frame.
935 Since GTK uses the background colour to clear the window, we must
936 keep the GTK and X colors in sync.
937 F is the frame to change,
938 BG is the pixel value to change to. */
941 xg_set_background_color (f
, bg
)
945 if (FRAME_GTK_WIDGET (f
))
950 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
951 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
957 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
958 functions so GTK does not overwrite the icon. */
961 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
)
966 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
967 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
968 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
969 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
971 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
976 /***********************************************************************
978 ***********************************************************************/
979 /* Return the dialog title to use for a dialog of type KEY.
980 This is the encoding used by lwlib. We use the same for GTK. */
983 get_dialog_title (char key
)
993 title
= "Information";
1012 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1013 the dialog, but return TRUE so the event does not propagate further
1014 in GTK. This prevents GTK from destroying the dialog widget automatically
1015 and we can always destrou the widget manually, regardles of how
1016 it was popped down (button press or WM_DELETE_WINDOW).
1017 W is the dialog widget.
1018 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1019 user_data is NULL (not used).
1021 Returns TRUE to end propagation of event. */
1024 dialog_delete_callback (w
, event
, user_data
)
1029 gtk_widget_unmap (w
);
1033 /* Create a popup dialog window. See also xg_create_widget below.
1034 WV is a widget_value describing the dialog.
1035 SELECT_CB is the callback to use when a button has been pressed.
1036 DEACTIVATE_CB is the callback to use when the dialog pops down.
1038 Returns the GTK dialog widget. */
1041 create_dialog (wv
, select_cb
, deactivate_cb
)
1043 GCallback select_cb
;
1044 GCallback deactivate_cb
;
1046 char *title
= get_dialog_title (wv
->name
[0]);
1047 int total_buttons
= wv
->name
[1] - '0';
1048 int right_buttons
= wv
->name
[4] - '0';
1051 int button_spacing
= 10;
1052 GtkWidget
*wdialog
= gtk_dialog_new ();
1056 GtkWidget
*whbox_up
;
1057 GtkWidget
*whbox_down
;
1059 /* If the number of buttons is greater than 4, make two rows of buttons
1060 instead. This looks better. */
1061 int make_two_rows
= total_buttons
> 4;
1063 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1064 left_buttons
= total_buttons
- right_buttons
;
1066 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1067 gtk_widget_set_name (wdialog
, "emacs-dialog");
1069 cur_box
= GTK_BOX (GTK_DIALOG (wdialog
)->action_area
);
1073 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1074 whbox_up
= gtk_hbox_new (FALSE
, 0);
1075 whbox_down
= gtk_hbox_new (FALSE
, 0);
1077 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1078 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1079 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1081 cur_box
= GTK_BOX (whbox_up
);
1084 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1085 G_CALLBACK (dialog_delete_callback
), 0);
1089 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1090 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1093 for (item
= wv
->contents
; item
; item
= item
->next
)
1095 char *utf8_label
= get_utf8_string (item
->value
);
1099 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1101 /* This is the text part of the dialog. */
1102 w
= gtk_label_new (utf8_label
);
1103 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1106 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
), w
,
1108 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1110 /* Try to make dialog look better. Must realize first so
1111 the widget can calculate the size it needs. */
1112 gtk_widget_realize (w
);
1113 gtk_widget_size_request (w
, &req
);
1114 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1116 if (item
->value
&& strlen (item
->value
) > 0)
1117 button_spacing
= 2*req
.width
/strlen (item
->value
);
1121 /* This is one button to add to the dialog. */
1122 w
= gtk_button_new_with_label (utf8_label
);
1123 if (! item
->enabled
)
1124 gtk_widget_set_sensitive (w
, FALSE
);
1126 g_signal_connect (G_OBJECT (w
), "clicked",
1127 select_cb
, item
->call_data
);
1129 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1130 if (++button_nr
== left_buttons
)
1133 cur_box
= GTK_BOX (whbox_down
);
1135 gtk_box_pack_start (cur_box
,
1142 if (utf8_label
&& utf8_label
!= item
->value
)
1143 g_free (utf8_label
);
1151 /***********************************************************************
1152 File dialog functions
1153 ***********************************************************************/
1154 /* Return non-zero if the old file selection dialog is being used.
1155 Return zero if not. */
1158 xg_uses_old_file_dialog ()
1160 #ifdef HAVE_GTK_FILE_BOTH
1161 extern int x_use_old_gtk_file_dialog
;
1162 return x_use_old_gtk_file_dialog
;
1163 #else /* ! HAVE_GTK_FILE_BOTH */
1165 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1171 #endif /* ! HAVE_GTK_FILE_BOTH */
1175 /* Function that is called when the file dialog pops down.
1176 W is the dialog widget, RESPONSE is the response code.
1177 USER_DATA is what we passed in to g_signal_connect (pointer to int). */
1180 xg_file_response_cb (w
,
1187 int *ptr
= (int *) user_data
;
1192 /* Destroy the dialog. This makes it pop down. */
1195 pop_down_file_dialog (arg
)
1198 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1200 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1205 typedef char * (*xg_get_file_func
) P_ ((GtkWidget
*));
1207 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1209 /* Return the selected file for file chooser dialog W.
1210 The returned string must be free:d. */
1213 xg_get_file_name_from_chooser (w
)
1216 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1219 /* Callback called when the "Show hidden files" toggle is pressed.
1220 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1223 xg_toggle_visibility_cb (widget
, data
)
1227 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1229 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1230 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1234 /* Callback called when a property changes in a file chooser.
1235 GOBJECT is the file chooser dialog, ARG1 describes the property.
1236 USER_DATA is the toggle widget in the file chooser dialog.
1237 We use this to update the "Show hidden files" toggle when the user
1238 changes that property by right clicking in the file list. */
1241 xg_toggle_notify_cb (gobject
, arg1
, user_data
)
1246 extern int x_gtk_show_hidden_files
;
1248 if (strcmp (arg1
->name
, "show-hidden") == 0)
1250 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (gobject
);
1251 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1252 gboolean visible
, toggle_on
;
1254 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1255 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1257 if (!!visible
!= !!toggle_on
)
1259 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1260 G_CALLBACK (xg_toggle_visibility_cb
),
1262 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1263 g_signal_handlers_unblock_by_func
1264 (G_OBJECT (wtoggle
),
1265 G_CALLBACK (xg_toggle_visibility_cb
),
1268 x_gtk_show_hidden_files
= visible
;
1272 /* Read a file name from the user using a file chooser dialog.
1273 F is the current frame.
1274 PROMPT is a prompt to show to the user. May not be NULL.
1275 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1276 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1277 file. *FUNC is set to a function that can be used to retrieve the
1278 selected file name from the returned widget.
1280 Returns the created widget. */
1283 xg_get_file_with_chooser (f
, prompt
, default_filename
,
1284 mustmatch_p
, only_dir_p
, func
)
1287 char *default_filename
;
1288 int mustmatch_p
, only_dir_p
;
1289 xg_get_file_func
*func
;
1293 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1294 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1295 GtkFileChooserAction action
= (mustmatch_p
?
1296 GTK_FILE_CHOOSER_ACTION_OPEN
:
1297 GTK_FILE_CHOOSER_ACTION_SAVE
);
1298 extern int x_gtk_show_hidden_files
;
1301 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1303 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1304 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1305 (mustmatch_p
|| only_dir_p
?
1306 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1309 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1311 wbox
= gtk_vbox_new (FALSE
, 0);
1312 gtk_widget_show (wbox
);
1313 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1315 if (x_gtk_show_hidden_files
)
1317 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1318 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1320 gtk_widget_show (wtoggle
);
1321 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1322 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1323 g_signal_connect (G_OBJECT (filewin
), "notify",
1324 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1327 if (action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1328 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1329 strcat (message
, "\nIf you don't like this file selector, customize "
1330 "use-file-dialog\nto turn it off, or type C-x C-f to visit files.");
1332 wmessage
= gtk_label_new (message
);
1333 gtk_widget_show (wmessage
);
1334 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1335 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1336 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1338 if (default_filename
)
1341 struct gcpro gcpro1
;
1344 file
= build_string (default_filename
);
1346 /* File chooser does not understand ~/... in the file name. It must be
1347 an absolute name starting with /. */
1348 if (default_filename
[0] != '/')
1349 file
= Fexpand_file_name (file
, Qnil
);
1351 default_filename
= SSDATA (file
);
1352 if (Ffile_directory_p (file
))
1353 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1356 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1362 *func
= xg_get_file_name_from_chooser
;
1365 #endif /* HAVE_GTK_FILE_CHOOSER_DIALOG_NEW */
1367 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1369 /* Return the selected file for file selector dialog W.
1370 The returned string must be free:d. */
1373 xg_get_file_name_from_selector (w
)
1376 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1377 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1380 /* Create a file selection dialog.
1381 F is the current frame.
1382 PROMPT is a prompt to show to the user. May not be NULL.
1383 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1384 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1385 file. *FUNC is set to a function that can be used to retrieve the
1386 selected file name from the returned widget.
1388 Returns the created widget. */
1391 xg_get_file_with_selection (f
, prompt
, default_filename
,
1392 mustmatch_p
, only_dir_p
, func
)
1395 char *default_filename
;
1396 int mustmatch_p
, only_dir_p
;
1397 xg_get_file_func
*func
;
1400 GtkFileSelection
*filesel
;
1402 filewin
= gtk_file_selection_new (prompt
);
1403 filesel
= GTK_FILE_SELECTION (filewin
);
1405 if (default_filename
)
1406 gtk_file_selection_set_filename (filesel
, default_filename
);
1410 /* The selection_entry part of filesel is not documented. */
1411 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1412 gtk_file_selection_hide_fileop_buttons (filesel
);
1415 *func
= xg_get_file_name_from_selector
;
1419 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1421 /* Read a file name from the user using a file dialog, either the old
1422 file selection dialog, or the new file chooser dialog. Which to use
1423 depends on what the GTK version used has, and what the value of
1424 gtk-use-old-file-dialog.
1425 F is the current frame.
1426 PROMPT is a prompt to show to the user. May not be NULL.
1427 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1428 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1431 Returns a file name or NULL if no file was selected.
1432 The returned string must be freed by the caller. */
1435 xg_get_file_name (f
, prompt
, default_filename
, mustmatch_p
, only_dir_p
)
1438 char *default_filename
;
1439 int mustmatch_p
, only_dir_p
;
1442 int count
= SPECPDL_INDEX ();
1444 int filesel_done
= 0;
1445 xg_get_file_func func
;
1447 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1448 /* I really don't know why this is needed, but without this the GLIBC add on
1449 library linuxthreads hangs when the Gnome file chooser backend creates
1451 sigblock (sigmask (__SIGRTMIN
));
1452 #endif /* HAVE_GTK_AND_PTHREAD */
1454 #ifdef HAVE_GTK_FILE_BOTH
1456 if (xg_uses_old_file_dialog ())
1457 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1458 mustmatch_p
, only_dir_p
, &func
);
1460 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1461 mustmatch_p
, only_dir_p
, &func
);
1463 #else /* not HAVE_GTK_FILE_BOTH */
1465 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1466 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1467 mustmatch_p
, only_dir_p
, &func
);
1469 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1470 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1471 mustmatch_p
, only_dir_p
, &func
);
1474 #endif /* HAVE_GTK_FILE_BOTH */
1476 xg_set_screen (w
, f
);
1477 gtk_widget_set_name (w
, "emacs-filedialog");
1478 gtk_window_set_transient_for (GTK_WINDOW (w
),
1479 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1480 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1481 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1483 g_signal_connect (G_OBJECT (w
),
1485 G_CALLBACK (xg_file_response_cb
),
1488 /* Don't destroy the widget if closed by the window manager close button. */
1489 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1491 gtk_widget_show (w
);
1493 record_unwind_protect (pop_down_file_dialog
, make_save_value (w
, 0));
1494 while (! filesel_done
)
1496 x_menu_wait_for_event (0);
1497 gtk_main_iteration ();
1500 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1501 sigunblock (sigmask (__SIGRTMIN
));
1504 if (filesel_done
== GTK_RESPONSE_OK
)
1507 unbind_to (count
, Qnil
);
1513 /***********************************************************************
1515 ***********************************************************************/
1517 /* The name of menu items that can be used for citomization. Since GTK
1518 RC files are very crude and primitive, we have to set this on all
1519 menu item names so a user can easily cutomize menu items. */
1521 #define MENU_ITEM_NAME "emacs-menuitem"
1524 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1525 during GC. The next member points to the items. */
1526 static xg_list_node xg_menu_cb_list
;
1528 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1529 during GC. The next member points to the items. */
1530 static xg_list_node xg_menu_item_cb_list
;
1532 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1533 F is the frame CL_DATA will be initialized for.
1534 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1536 The menu bar and all sub menus under the menu bar in a frame
1537 share the same structure, hence the reference count.
1539 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1540 allocated xg_menu_cb_data if CL_DATA is NULL. */
1542 static xg_menu_cb_data
*
1543 make_cl_data (cl_data
, f
, highlight_cb
)
1544 xg_menu_cb_data
*cl_data
;
1546 GCallback highlight_cb
;
1550 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1552 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1553 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1554 cl_data
->highlight_cb
= highlight_cb
;
1555 cl_data
->ref_count
= 0;
1557 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1560 cl_data
->ref_count
++;
1565 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1566 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1568 When the menu bar is updated, menu items may have been added and/or
1569 removed, so menu_bar_vector and menu_bar_items_used change. We must
1570 then update CL_DATA since it is used to determine which menu
1571 item that is invoked in the menu.
1572 HIGHLIGHT_CB could change, there is no check that the same
1573 function is given when modifying a menu bar as was given when
1574 creating the menu bar. */
1577 update_cl_data (cl_data
, f
, highlight_cb
)
1578 xg_menu_cb_data
*cl_data
;
1580 GCallback highlight_cb
;
1585 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1586 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1587 cl_data
->highlight_cb
= highlight_cb
;
1591 /* Decrease reference count for CL_DATA.
1592 If reference count is zero, free CL_DATA. */
1595 unref_cl_data (cl_data
)
1596 xg_menu_cb_data
*cl_data
;
1598 if (cl_data
&& cl_data
->ref_count
> 0)
1600 cl_data
->ref_count
--;
1601 if (cl_data
->ref_count
== 0)
1603 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1609 /* Function that marks all lisp data during GC. */
1616 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1617 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1619 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1621 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1623 if (! NILP (cb_data
->help
))
1624 mark_object (cb_data
->help
);
1629 /* Callback called when a menu item is destroyed. Used to free data.
1630 W is the widget that is being destroyed (not used).
1631 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1634 menuitem_destroy_callback (w
, client_data
)
1636 gpointer client_data
;
1640 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1641 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1646 /* Callback called when the pointer enters/leaves a menu item.
1648 EVENT is either an enter event or leave event.
1649 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W.
1651 Returns FALSE to tell GTK to keep processing this event. */
1654 menuitem_highlight_callback (w
, event
, client_data
)
1656 GdkEventCrossing
*event
;
1657 gpointer client_data
;
1661 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1662 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : client_data
;
1664 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1666 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1667 (*func
) (w
, call_data
);
1674 /* Callback called when a menu is destroyed. Used to free data.
1675 W is the widget that is being destroyed (not used).
1676 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1679 menu_destroy_callback (w
, client_data
)
1681 gpointer client_data
;
1683 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1686 /* Callback called when a menu does a grab or ungrab. That means the
1687 menu has been activated or deactivated.
1688 Used to start a timer so the small timeout the menus in GTK uses before
1689 popping down a menu is seen by Emacs (see xg_process_timeouts above).
1690 W is the widget that does the grab (not used).
1691 UNGRAB_P is TRUE if this is an ungrab, FALSE if it is a grab.
1692 CLIENT_DATA is NULL (not used). */
1695 menu_grab_callback (GtkWidget
*widget
,
1697 gpointer client_data
)
1699 /* Keep track of total number of grabs. */
1702 if (ungrab_p
) cnt
--;
1705 if (cnt
> 0 && ! xg_timer
) xg_start_timer ();
1706 else if (cnt
== 0 && xg_timer
) xg_stop_timer ();
1709 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1710 must be non-NULL) and can be inserted into a menu item.
1712 Returns the GtkHBox. */
1715 make_widget_for_menu_item (utf8_label
, utf8_key
)
1723 wbox
= gtk_hbox_new (FALSE
, 0);
1724 wlbl
= gtk_label_new (utf8_label
);
1725 wkey
= gtk_label_new (utf8_key
);
1727 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1728 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1730 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1731 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1733 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1734 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1735 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1740 /* Make and return a menu item widget with the key to the right.
1741 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1742 UTF8_KEY is the text representing the key binding.
1743 ITEM is the widget_value describing the menu item.
1745 GROUP is an in/out parameter. If the menu item to be created is not
1746 part of any radio menu group, *GROUP contains NULL on entry and exit.
1747 If the menu item to be created is part of a radio menu group, on entry
1748 *GROUP contains the group to use, or NULL if this is the first item
1749 in the group. On exit, *GROUP contains the radio item group.
1751 Unfortunately, keys don't line up as nicely as in Motif,
1752 but the MacOS X version doesn't either, so I guess that is OK. */
1755 make_menu_item (utf8_label
, utf8_key
, item
, group
)
1762 GtkWidget
*wtoadd
= 0;
1764 /* It has been observed that some menu items have a NULL name field.
1765 This will lead to this function being called with a NULL utf8_label.
1766 GTK crashes on that so we set a blank label. Why there is a NULL
1767 name remains to be investigated. */
1768 if (! utf8_label
) utf8_label
= " ";
1771 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1773 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1776 if (utf8_key
) w
= gtk_check_menu_item_new ();
1777 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1778 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1780 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1782 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1783 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1784 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1786 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1791 if (utf8_key
) w
= gtk_menu_item_new ();
1792 else w
= gtk_menu_item_new_with_label (utf8_label
);
1795 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1796 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1801 /* Return non-zero if LABEL specifies a separator (GTK only has one
1805 xg_separator_p (char *label
)
1807 if (! label
) return 0;
1808 else if (strlen (label
) > 3
1809 && strncmp (label
, "--", 2) == 0
1812 static char* separator_names
[] = {
1817 "single-dashed-line",
1818 "double-dashed-line",
1820 "shadow-etched-out",
1821 "shadow-etched-in-dash",
1822 "shadow-etched-out-dash",
1823 "shadow-double-etched-in",
1824 "shadow-double-etched-out",
1825 "shadow-double-etched-in-dash",
1826 "shadow-double-etched-out-dash",
1833 for (i
= 0; separator_names
[i
]; ++i
)
1834 if (strcmp (label
, separator_names
[i
]) == 0)
1839 /* Old-style separator, maybe. It's a separator if it contains
1841 while (*label
== '-')
1843 if (*label
== 0) return 1;
1849 static int xg_detached_menus
;
1851 /* Returns non-zero if there are detached menus. */
1854 xg_have_tear_offs ()
1856 return xg_detached_menus
> 0;
1859 /* Callback invoked when a detached menu window is removed. Here we
1860 decrease the xg_detached_menus count.
1861 WIDGET is the top level window that is removed (the parent of the menu).
1862 CLIENT_DATA is not used. */
1865 tearoff_remove (widget
, client_data
)
1867 gpointer client_data
;
1869 if (xg_detached_menus
> 0) --xg_detached_menus
;
1872 /* Callback invoked when a menu is detached. It increases the
1873 xg_detached_menus count.
1874 WIDGET is the GtkTearoffMenuItem.
1875 CLIENT_DATA is not used. */
1878 tearoff_activate (widget
, client_data
)
1880 gpointer client_data
;
1882 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
1883 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
1885 ++xg_detached_menus
;
1886 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
1888 G_CALLBACK (tearoff_remove
), 0);
1893 /* Create a menu item widget, and connect the callbacks.
1894 ITEM decribes the menu item.
1895 F is the frame the created menu belongs to.
1896 SELECT_CB is the callback to use when a menu item is selected.
1897 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1898 CL_DATA points to the callback data to be used for this menu.
1899 GROUP is an in/out parameter. If the menu item to be created is not
1900 part of any radio menu group, *GROUP contains NULL on entry and exit.
1901 If the menu item to be created is part of a radio menu group, on entry
1902 *GROUP contains the group to use, or NULL if this is the first item
1903 in the group. On exit, *GROUP contains the radio item group.
1905 Returns the created GtkWidget. */
1908 xg_create_one_menuitem (item
, f
, select_cb
, highlight_cb
, cl_data
, group
)
1911 GCallback select_cb
;
1912 GCallback highlight_cb
;
1913 xg_menu_cb_data
*cl_data
;
1919 xg_menu_item_cb_data
*cb_data
;
1921 utf8_label
= get_utf8_string (item
->name
);
1922 utf8_key
= get_utf8_string (item
->key
);
1924 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
1926 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
1927 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
1929 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
1931 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
1933 cb_data
->unhighlight_id
= cb_data
->highlight_id
= cb_data
->select_id
= 0;
1934 cb_data
->help
= item
->help
;
1935 cb_data
->cl_data
= cl_data
;
1936 cb_data
->call_data
= item
->call_data
;
1938 g_signal_connect (G_OBJECT (w
),
1940 G_CALLBACK (menuitem_destroy_callback
),
1943 /* Put cb_data in widget, so we can get at it when modifying menubar */
1944 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
1946 /* final item, not a submenu */
1947 if (item
->call_data
&& ! item
->contents
)
1951 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
1954 if (! NILP (item
->help
) && highlight_cb
)
1956 /* We use enter/leave notify instead of select/deselect because
1957 select/deselect doesn't go well with detached menus. */
1958 cb_data
->highlight_id
1959 = g_signal_connect (G_OBJECT (w
),
1960 "enter-notify-event",
1961 G_CALLBACK (menuitem_highlight_callback
),
1963 cb_data
->unhighlight_id
1964 = g_signal_connect (G_OBJECT (w
),
1965 "leave-notify-event",
1966 G_CALLBACK (menuitem_highlight_callback
),
1973 static GtkWidget
*create_menus
P_ ((widget_value
*, FRAME_PTR
, GCallback
,
1974 GCallback
, GCallback
, int, int, int,
1975 GtkWidget
*, xg_menu_cb_data
*, char *));
1977 /* Create a full menu tree specified by DATA.
1978 F is the frame the created menu belongs to.
1979 SELECT_CB is the callback to use when a menu item is selected.
1980 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
1981 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1982 POP_UP_P is non-zero if we shall create a popup menu.
1983 MENU_BAR_P is non-zero if we shall create a menu bar.
1984 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
1985 if MENU_BAR_P is non-zero.
1986 TOPMENU is the topmost GtkWidget that others shall be placed under.
1987 It may be NULL, in that case we create the appropriate widget
1988 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
1989 CL_DATA is the callback data we shall use for this menu, or NULL
1990 if we haven't set the first callback yet.
1991 NAME is the name to give to the top level menu if this function
1992 creates it. May be NULL to not set any name.
1994 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
1997 This function calls itself to create submenus. */
2000 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2001 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
2004 GCallback select_cb
;
2005 GCallback deactivate_cb
;
2006 GCallback highlight_cb
;
2011 xg_menu_cb_data
*cl_data
;
2015 GtkWidget
*wmenu
= topmenu
;
2016 GSList
*group
= NULL
;
2022 wmenu
= gtk_menu_new ();
2023 xg_set_screen (wmenu
, f
);
2025 else wmenu
= gtk_menu_bar_new ();
2027 /* Put cl_data on the top menu for easier access. */
2028 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2029 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2030 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2031 G_CALLBACK (menu_destroy_callback
), cl_data
);
2034 gtk_widget_set_name (wmenu
, name
);
2037 g_signal_connect (G_OBJECT (wmenu
),
2038 "selection-done", deactivate_cb
, 0);
2040 g_signal_connect (G_OBJECT (wmenu
),
2041 "grab-notify", G_CALLBACK (menu_grab_callback
), 0);
2044 if (! menu_bar_p
&& add_tearoff_p
)
2046 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2047 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2049 g_signal_connect (G_OBJECT (tearoff
), "activate",
2050 G_CALLBACK (tearoff_activate
), 0);
2053 for (item
= data
; item
; item
= item
->next
)
2057 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2058 && !xg_separator_p (item
->name
))
2061 /* A title for a popup. We do the same as GTK does when
2062 creating titles, but it does not look good. */
2064 utf8_label
= get_utf8_string (item
->name
);
2066 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2067 w
= gtk_menu_item_new_with_label (utf8_label
);
2068 gtk_widget_set_sensitive (w
, FALSE
);
2069 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2071 else if (xg_separator_p (item
->name
))
2074 /* GTK only have one separator type. */
2075 w
= gtk_separator_menu_item_new ();
2079 w
= xg_create_one_menuitem (item
,
2081 item
->contents
? 0 : select_cb
,
2088 GtkWidget
*submenu
= create_menus (item
->contents
,
2099 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2103 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2104 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2110 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2111 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2112 with some text and buttons.
2113 F is the frame the created item belongs to.
2114 NAME is the name to use for the top widget.
2115 VAL is a widget_value structure describing items to be created.
2116 SELECT_CB is the callback to use when a menu item is selected or
2117 a dialog button is pressed.
2118 DEACTIVATE_CB is the callback to use when an item is deactivated.
2119 For a menu, when a sub menu is not shown anymore, for a dialog it is
2120 called when the dialog is popped down.
2121 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2123 Returns the widget created. */
2126 xg_create_widget (type
, name
, f
, val
,
2127 select_cb
, deactivate_cb
, highlight_cb
)
2132 GCallback select_cb
;
2133 GCallback deactivate_cb
;
2134 GCallback highlight_cb
;
2137 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2138 int pop_up_p
= strcmp (type
, "popup") == 0;
2140 if (strcmp (type
, "dialog") == 0)
2142 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2143 xg_set_screen (w
, f
);
2144 gtk_window_set_transient_for (GTK_WINDOW (w
),
2145 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2146 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2147 gtk_widget_set_name (w
, "emacs-dialog");
2148 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2150 else if (menu_bar_p
|| pop_up_p
)
2152 w
= create_menus (val
->contents
,
2164 /* Set the cursor to an arrow for popup menus when they are mapped.
2165 This is done by default for menu bar menus. */
2168 /* Must realize so the GdkWindow inside the widget is created. */
2169 gtk_widget_realize (w
);
2170 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2175 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2182 /* Return the label for menu item WITEM. */
2185 xg_get_menu_item_label (witem
)
2188 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2189 return gtk_label_get_label (wlabel
);
2192 /* Return non-zero if the menu item WITEM has the text LABEL. */
2195 xg_item_label_same_p (witem
, label
)
2200 char *utf8_label
= get_utf8_string (label
);
2201 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2203 if (! old_label
&& ! utf8_label
)
2205 else if (old_label
&& utf8_label
)
2206 is_same
= strcmp (utf8_label
, old_label
) == 0;
2208 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2213 /* Destroy widgets in LIST. */
2216 xg_destroy_widgets (list
)
2221 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2223 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2225 /* Destroying the widget will remove it from the container it is in. */
2226 gtk_widget_destroy (w
);
2230 /* Update the top level names in MENUBAR (i.e. not submenus).
2231 F is the frame the menu bar belongs to.
2232 *LIST is a list with the current menu bar names (menu item widgets).
2233 ITER is the item within *LIST that shall be updated.
2234 POS is the numerical position, starting at 0, of ITER in *LIST.
2235 VAL describes what the menu bar shall look like after the update.
2236 SELECT_CB is the callback to use when a menu item is selected.
2237 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2238 CL_DATA points to the callback data to be used for this menu bar.
2240 This function calls itself to walk through the menu bar names. */
2243 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2244 select_cb
, highlight_cb
, cl_data
)
2251 GCallback select_cb
;
2252 GCallback highlight_cb
;
2253 xg_menu_cb_data
*cl_data
;
2255 if (! iter
&& ! val
)
2257 else if (iter
&& ! val
)
2259 /* Item(s) have been removed. Remove all remaining items. */
2260 xg_destroy_widgets (iter
);
2266 else if (! iter
&& val
)
2268 /* Item(s) added. Add all new items in one call. */
2269 create_menus (val
, f
, select_cb
, 0, highlight_cb
,
2270 0, 1, 0, menubar
, cl_data
, 0);
2276 /* Below this neither iter or val is NULL */
2277 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2279 /* This item is still the same, check next item. */
2281 iter
= g_list_next (iter
);
2284 else /* This item is changed. */
2286 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2287 GtkMenuItem
*witem2
= 0;
2288 int val_in_menubar
= 0;
2289 int iter_in_new_menubar
= 0;
2293 /* See if the changed entry (val) is present later in the menu bar */
2295 iter2
&& ! val_in_menubar
;
2296 iter2
= g_list_next (iter2
))
2298 witem2
= GTK_MENU_ITEM (iter2
->data
);
2299 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2302 /* See if the current entry (iter) is present later in the
2303 specification for the new menu bar. */
2304 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2305 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2307 if (val_in_menubar
&& ! iter_in_new_menubar
)
2311 /* This corresponds to:
2316 gtk_widget_ref (GTK_WIDGET (witem
));
2317 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2318 gtk_widget_destroy (GTK_WIDGET (witem
));
2320 /* Must get new list since the old changed. */
2321 g_list_free (*list
);
2322 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2323 while (nr
-- > 0) iter
= g_list_next (iter
);
2325 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2327 /* This corresponds to:
2330 Rename B to X. This might seem to be a strange thing to do,
2331 since if there is a menu under B it will be totally wrong for X.
2332 But consider editing a C file. Then there is a C-mode menu
2333 (corresponds to B above).
2334 If then doing C-x C-f the minibuf menu (X above) replaces the
2335 C-mode menu. When returning from the minibuffer, we get
2336 back the C-mode menu. Thus we do:
2337 Rename B to X (C-mode to minibuf menu)
2338 Rename X to B (minibuf to C-mode menu).
2339 If the X menu hasn't been invoked, the menu under B
2340 is up to date when leaving the minibuffer. */
2341 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2342 char *utf8_label
= get_utf8_string (val
->name
);
2343 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2345 gtk_label_set_text (wlabel
, utf8_label
);
2347 /* If this item has a submenu that has been detached, change
2348 the title in the WM decorations also. */
2349 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2350 /* Set the title of the detached window. */
2351 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2353 iter
= g_list_next (iter
);
2357 else if (! val_in_menubar
&& iter_in_new_menubar
)
2359 /* This corresponds to:
2366 GtkWidget
*w
= xg_create_one_menuitem (val
,
2373 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2374 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2376 g_list_free (*list
);
2377 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2378 while (nr
-- > 0) iter
= g_list_next (iter
);
2379 iter
= g_list_next (iter
);
2383 else /* if (val_in_menubar && iter_in_new_menubar) */
2386 /* This corresponds to:
2391 gtk_widget_ref (GTK_WIDGET (witem2
));
2392 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2393 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2394 GTK_WIDGET (witem2
), pos
);
2395 gtk_widget_unref (GTK_WIDGET (witem2
));
2397 g_list_free (*list
);
2398 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2399 while (nr
-- > 0) iter
= g_list_next (iter
);
2405 /* Update the rest of the menu bar. */
2406 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2407 select_cb
, highlight_cb
, cl_data
);
2410 /* Update the menu item W so it corresponds to VAL.
2411 SELECT_CB is the callback to use when a menu item is selected.
2412 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2413 CL_DATA is the data to set in the widget for menu invokation. */
2416 xg_update_menu_item (val
, w
, select_cb
, highlight_cb
, cl_data
)
2419 GCallback select_cb
;
2420 GCallback highlight_cb
;
2421 xg_menu_cb_data
*cl_data
;
2428 const char *old_label
= 0;
2429 const char *old_key
= 0;
2430 xg_menu_item_cb_data
*cb_data
;
2432 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2433 utf8_label
= get_utf8_string (val
->name
);
2434 utf8_key
= get_utf8_string (val
->key
);
2436 /* See if W is a menu item with a key. See make_menu_item above. */
2437 if (GTK_IS_HBOX (wchild
))
2439 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2441 wlbl
= GTK_LABEL (list
->data
);
2442 wkey
= GTK_LABEL (list
->next
->data
);
2447 /* Remove the key and keep just the label. */
2448 gtk_widget_ref (GTK_WIDGET (wlbl
));
2449 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2450 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2455 else /* Just a label. */
2457 wlbl
= GTK_LABEL (wchild
);
2459 /* Check if there is now a key. */
2462 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2463 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2465 wlbl
= GTK_LABEL (list
->data
);
2466 wkey
= GTK_LABEL (list
->next
->data
);
2469 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2470 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2475 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2476 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2478 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2479 gtk_label_set_text (wkey
, utf8_key
);
2481 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2482 gtk_label_set_text (wlbl
, utf8_label
);
2484 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2485 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2487 if (! val
->enabled
&& GTK_WIDGET_SENSITIVE (w
))
2488 gtk_widget_set_sensitive (w
, FALSE
);
2489 else if (val
->enabled
&& ! GTK_WIDGET_SENSITIVE (w
))
2490 gtk_widget_set_sensitive (w
, TRUE
);
2492 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2496 cb_data
->call_data
= val
->call_data
;
2497 cb_data
->help
= val
->help
;
2498 cb_data
->cl_data
= cl_data
;
2500 /* We assume the callback functions don't change. */
2501 if (val
->call_data
&& ! val
->contents
)
2503 /* This item shall have a select callback. */
2504 if (! cb_data
->select_id
)
2506 = g_signal_connect (G_OBJECT (w
), "activate",
2507 select_cb
, cb_data
);
2509 else if (cb_data
->select_id
)
2511 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2512 cb_data
->select_id
= 0;
2515 if (NILP (cb_data
->help
))
2517 /* Shall not have help. Remove if any existed previously. */
2518 if (cb_data
->highlight_id
)
2520 g_signal_handler_disconnect (G_OBJECT (w
),
2521 cb_data
->highlight_id
);
2522 cb_data
->highlight_id
= 0;
2524 if (cb_data
->unhighlight_id
)
2526 g_signal_handler_disconnect (G_OBJECT (w
),
2527 cb_data
->unhighlight_id
);
2528 cb_data
->unhighlight_id
= 0;
2531 else if (! cb_data
->highlight_id
&& highlight_cb
)
2533 /* Have help now, but didn't previously. Add callback. */
2534 cb_data
->highlight_id
2535 = g_signal_connect (G_OBJECT (w
),
2536 "enter-notify-event",
2537 G_CALLBACK (menuitem_highlight_callback
),
2539 cb_data
->unhighlight_id
2540 = g_signal_connect (G_OBJECT (w
),
2541 "leave-notify-event",
2542 G_CALLBACK (menuitem_highlight_callback
),
2548 /* Update the toggle menu item W so it corresponds to VAL. */
2551 xg_update_toggle_item (val
, w
)
2555 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2558 /* Update the radio menu item W so it corresponds to VAL. */
2561 xg_update_radio_item (val
, w
)
2565 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2568 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2569 SUBMENU may be NULL, in that case a new menu is created.
2570 F is the frame the menu bar belongs to.
2571 VAL describes the contents of the menu bar.
2572 SELECT_CB is the callback to use when a menu item is selected.
2573 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2574 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2575 CL_DATA is the call back data to use for any newly created items.
2577 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2581 xg_update_submenu (submenu
, f
, val
,
2582 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2586 GCallback select_cb
;
2587 GCallback deactivate_cb
;
2588 GCallback highlight_cb
;
2589 xg_menu_cb_data
*cl_data
;
2591 GtkWidget
*newsub
= submenu
;
2595 int has_tearoff_p
= 0;
2596 GList
*first_radio
= 0;
2599 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2601 for (cur
= val
, iter
= list
;
2603 iter
= g_list_next (iter
), cur
= cur
->next
)
2605 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2607 /* Skip tearoff items, they have no counterpart in val. */
2608 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2611 iter
= g_list_next (iter
);
2612 if (iter
) w
= GTK_WIDGET (iter
->data
);
2616 /* Remember first radio button in a group. If we get a mismatch in
2617 a radio group we must rebuild the whole group so that the connections
2618 in GTK becomes correct. */
2619 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2621 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2622 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2625 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2627 if (! xg_separator_p (cur
->name
))
2630 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2632 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2634 xg_update_toggle_item (cur
, w
);
2635 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2637 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2639 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2641 xg_update_radio_item (cur
, w
);
2642 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2644 else if (GTK_IS_MENU_ITEM (w
))
2646 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2649 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2650 xg_separator_p (cur
->name
))
2653 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2655 sub
= gtk_menu_item_get_submenu (witem
);
2656 if (sub
&& ! cur
->contents
)
2658 /* Not a submenu anymore. */
2659 gtk_widget_ref (sub
);
2660 gtk_menu_item_remove_submenu (witem
);
2661 gtk_widget_destroy (sub
);
2663 else if (cur
->contents
)
2667 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2668 select_cb
, deactivate_cb
,
2669 highlight_cb
, cl_data
);
2671 /* If this item just became a submenu, we must set it. */
2673 gtk_menu_item_set_submenu (witem
, nsub
);
2678 /* Structural difference. Remove everything from here and down
2684 /* Remove widgets from first structual change. */
2687 /* If we are adding new menu items below, we must remove from
2688 first radio button so that radio groups become correct. */
2689 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2690 else xg_destroy_widgets (iter
);
2695 /* More items added. Create them. */
2696 newsub
= create_menus (cur
,
2709 if (list
) g_list_free (list
);
2714 /* Update the MENUBAR.
2715 F is the frame the menu bar belongs to.
2716 VAL describes the contents of the menu bar.
2717 If DEEP_P is non-zero, rebuild all but the top level menu names in
2718 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2719 SELECT_CB is the callback to use when a menu item is selected.
2720 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2721 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2724 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2725 select_cb
, deactivate_cb
, highlight_cb
)
2730 GCallback select_cb
;
2731 GCallback deactivate_cb
;
2732 GCallback highlight_cb
;
2734 xg_menu_cb_data
*cl_data
;
2735 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2739 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2742 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2743 select_cb
, highlight_cb
, cl_data
);
2749 /* Update all sub menus.
2750 We must keep the submenus (GTK menu item widgets) since the
2751 X Window in the XEvent that activates the menu are those widgets. */
2753 /* Update cl_data, menu_item things in F may have changed. */
2754 update_cl_data (cl_data
, f
, highlight_cb
);
2756 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2763 /* Find sub menu that corresponds to val and update it. */
2764 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2766 witem
= GTK_MENU_ITEM (iter
->data
);
2767 if (xg_item_label_same_p (witem
, cur
->name
))
2769 sub
= gtk_menu_item_get_submenu (witem
);
2774 newsub
= xg_update_submenu (sub
,
2781 /* sub may still be NULL. If we just updated non deep and added
2782 a new menu bar item, it has no sub menu yet. So we set the
2783 newly created sub menu under witem. */
2786 xg_set_screen (newsub
, f
);
2787 gtk_menu_item_set_submenu (witem
, newsub
);
2793 gtk_widget_show_all (menubar
);
2796 /* Recompute all the widgets of frame F, when the menu bar has been
2797 changed. Value is non-zero if widgets were updated. */
2800 xg_update_frame_menubar (f
)
2803 struct x_output
*x
= f
->output_data
.x
;
2806 if (!x
->menubar_widget
|| GTK_WIDGET_MAPPED (x
->menubar_widget
))
2811 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2813 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2815 gtk_widget_show_all (x
->menubar_widget
);
2816 gtk_widget_size_request (x
->menubar_widget
, &req
);
2818 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2820 /* The height has changed, resize outer widget and set columns
2821 rows to what we had before adding the menu bar. */
2822 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2824 SET_FRAME_GARBAGED (f
);
2830 /* Get rid of the menu bar of frame F, and free its storage.
2831 This is used when deleting a frame, and when turning off the menu bar. */
2834 free_frame_menubar (f
)
2837 struct x_output
*x
= f
->output_data
.x
;
2839 if (x
->menubar_widget
)
2843 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2844 /* The menubar and its children shall be deleted when removed from
2846 x
->menubar_widget
= 0;
2847 FRAME_MENUBAR_HEIGHT (f
) = 0;
2849 /* The height has changed, resize outer widget and set columns
2850 rows to what we had before removing the menu bar. */
2851 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2853 SET_FRAME_GARBAGED (f
);
2860 /***********************************************************************
2861 Scroll bar functions
2862 ***********************************************************************/
2865 /* Setting scroll bar values invokes the callback. Use this variable
2866 to indicate that callback should do nothing. */
2868 int xg_ignore_gtk_scrollbar
;
2870 /* SET_SCROLL_BAR_X_WINDOW assumes the second argument fits in
2871 32 bits. But we want to store pointers, and they may be larger
2872 than 32 bits. Keep a mapping from integer index to widget pointers
2873 to get around the 32 bit limitation. */
2877 GtkWidget
**widgets
;
2882 /* Grow this much every time we need to allocate more */
2884 #define ID_TO_WIDGET_INCR 32
2886 /* Store the widget pointer W in id_to_widget and return the integer index. */
2889 xg_store_widget_in_map (w
)
2894 if (id_to_widget
.max_size
== id_to_widget
.used
)
2896 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
2898 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
2899 sizeof (GtkWidget
*)*new_size
);
2901 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
2902 id_to_widget
.widgets
[i
] = 0;
2903 id_to_widget
.max_size
= new_size
;
2906 /* Just loop over the array and find a free place. After all,
2907 how many scroll bars are we creating? Should be a small number.
2908 The check above guarantees we will find a free place. */
2909 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
2911 if (! id_to_widget
.widgets
[i
])
2913 id_to_widget
.widgets
[i
] = w
;
2914 ++id_to_widget
.used
;
2920 /* Should never end up here */
2924 /* Remove pointer at IDX from id_to_widget.
2925 Called when scroll bar is destroyed. */
2928 xg_remove_widget_from_map (idx
)
2931 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2933 id_to_widget
.widgets
[idx
] = 0;
2934 --id_to_widget
.used
;
2938 /* Get the widget pointer at IDX from id_to_widget. */
2941 xg_get_widget_from_map (idx
)
2944 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2945 return id_to_widget
.widgets
[idx
];
2950 /* Return the scrollbar id for X Window WID on display DPY.
2951 Return -1 if WID not in id_to_widget. */
2954 xg_get_scroll_id_for_window (dpy
, wid
)
2961 w
= xg_win_to_widget (dpy
, wid
);
2965 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
2966 if (id_to_widget
.widgets
[idx
] == w
)
2973 /* Callback invoked when scroll bar WIDGET is destroyed.
2974 DATA is the index into id_to_widget for WIDGET.
2975 We free pointer to last scroll bar values here and remove the index. */
2978 xg_gtk_scroll_destroy (widget
, data
)
2983 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
2985 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
2987 xg_remove_widget_from_map (id
);
2990 /* Callback for button press/release events. Used to start timer so that
2991 the scroll bar repetition timer in GTK gets handeled.
2992 Also, sets bar->dragging to Qnil when dragging (button release) is done.
2993 WIDGET is the scroll bar widget the event is for (not used).
2994 EVENT contains the event.
2995 USER_DATA points to the struct scrollbar structure.
2997 Returns FALSE to tell GTK that it shall continue propagate the event
3001 scroll_bar_button_cb (widget
, event
, user_data
)
3003 GdkEventButton
*event
;
3006 if (event
->type
== GDK_BUTTON_PRESS
&& ! xg_timer
)
3008 else if (event
->type
== GDK_BUTTON_RELEASE
)
3010 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
3011 if (xg_timer
) xg_stop_timer ();
3012 bar
->dragging
= Qnil
;
3018 /* Create a scroll bar widget for frame F. Store the scroll bar
3020 SCROLL_CALLBACK is the callback to invoke when the value of the
3022 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3023 to set resources for the widget. */
3026 xg_create_scroll_bar (f
, bar
, scroll_callback
, scroll_bar_name
)
3028 struct scroll_bar
*bar
;
3029 GCallback scroll_callback
;
3030 char *scroll_bar_name
;
3037 /* Page, step increment values are not so important here, they
3038 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3039 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3042 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3043 webox
= gtk_event_box_new ();
3044 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3045 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3047 scroll_id
= xg_store_widget_in_map (wscroll
);
3049 g_signal_connect (G_OBJECT (wscroll
),
3053 /* The EMACS_INT cast avoids a warning. */
3054 g_signal_connect (G_OBJECT (wscroll
),
3056 G_CALLBACK (xg_gtk_scroll_destroy
),
3057 (gpointer
) (EMACS_INT
) scroll_id
);
3059 /* Connect to button press and button release to detect if any scroll bar
3061 g_signal_connect (G_OBJECT (wscroll
),
3062 "button-press-event",
3063 G_CALLBACK (scroll_bar_button_cb
),
3065 g_signal_connect (G_OBJECT (wscroll
),
3066 "button-release-event",
3067 G_CALLBACK (scroll_bar_button_cb
),
3070 /* The scroll bar widget does not draw on a window of its own. Instead
3071 it draws on the parent window, in this case the edit widget. So
3072 whenever the edit widget is cleared, the scroll bar needs to redraw
3073 also, which causes flicker. Put an event box between the edit widget
3074 and the scroll bar, so the scroll bar instead draws itself on the
3075 event box window. */
3076 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3077 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3080 /* Set the cursor to an arrow. */
3081 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3083 SET_SCROLL_BAR_X_WINDOW (bar
, scroll_id
);
3086 /* Make the scroll bar represented by SCROLLBAR_ID visible. */
3089 xg_show_scroll_bar (scrollbar_id
)
3092 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3094 gtk_widget_show_all (gtk_widget_get_parent (w
));
3097 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3100 xg_remove_scroll_bar (f
, scrollbar_id
)
3104 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3107 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3108 gtk_widget_destroy (w
);
3109 gtk_widget_destroy (wparent
);
3110 SET_FRAME_GARBAGED (f
);
3114 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3116 TOP/LEFT are the new pixel positions where the bar shall appear.
3117 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3120 xg_update_scrollbar_pos (f
, scrollbar_id
, top
, left
, width
, height
)
3129 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3133 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3134 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3136 /* Move and resize to new values. */
3137 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3138 gtk_widget_set_size_request (wscroll
, width
, height
);
3139 gtk_widget_queue_draw (wparent
);
3140 gdk_window_process_all_updates ();
3141 /* GTK does not redraw until the main loop is entered again, but
3142 if there are no X events pending we will not enter it. So we sync
3143 here to get some events. */
3145 SET_FRAME_GARBAGED (f
);
3146 cancel_mouse_face (f
);
3150 /* Set the thumb size and position of scroll bar BAR. We are currently
3151 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3154 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
3155 struct scroll_bar
*bar
;
3156 int portion
, position
, whole
;
3158 GtkWidget
*wscroll
= xg_get_widget_from_map (SCROLL_BAR_X_WINDOW (bar
));
3160 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3162 if (wscroll
&& NILP (bar
->dragging
))
3171 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3173 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3174 rather than the real portion value. This makes the thumb less likely
3175 to resize and that looks better. */
3176 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3177 /* When the thumb is at the bottom, position == whole.
3178 So we need to increase `whole' to make space for the thumb. */
3185 top
= (gdouble
) position
/ whole
;
3186 shown
= (gdouble
) portion
/ whole
;
3189 size
= shown
* XG_SB_RANGE
;
3190 size
= min (size
, XG_SB_RANGE
);
3191 size
= max (size
, 1);
3193 value
= top
* XG_SB_RANGE
;
3194 value
= min (value
, XG_SB_MAX
- size
);
3195 value
= max (value
, XG_SB_MIN
);
3197 /* Assume all lines are of equal size. */
3198 new_step
= size
/ max (1, FRAME_LINES (f
));
3200 if ((int) adj
->page_size
!= size
3201 || (int) adj
->step_increment
!= new_step
)
3203 adj
->page_size
= size
;
3204 adj
->step_increment
= new_step
;
3205 /* Assume a page increment is about 95% of the page size */
3206 adj
->page_increment
= (int) (0.95*adj
->page_size
);
3210 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3212 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3216 /* gtk_range_set_value invokes the callback. Set
3217 ignore_gtk_scrollbar to make the callback do nothing */
3218 xg_ignore_gtk_scrollbar
= 1;
3220 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3221 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3223 gtk_adjustment_changed (adj
);
3225 xg_ignore_gtk_scrollbar
= 0;
3233 /***********************************************************************
3235 ***********************************************************************/
3236 /* The key for the data we put in the GtkImage widgets. The data is
3237 the image used by Emacs. We use this to see if we need to update
3238 the GtkImage with a new image. */
3239 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3241 /* The key for storing the latest modifiers so the activate callback can
3243 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3246 /* Callback function invoked when a tool bar item is pressed.
3247 W is the button widget in the tool bar that got pressed,
3248 CLIENT_DATA is an integer that is the index of the button in the
3249 tool bar. 0 is the first button. */
3252 xg_tool_bar_button_cb (widget
, event
, user_data
)
3254 GdkEventButton
*event
;
3257 g_object_set_data (G_OBJECT (user_data
), XG_TOOL_BAR_LAST_MODIFIER
,
3258 (gpointer
) event
->state
);
3264 xg_tool_bar_callback (w
, client_data
)
3266 gpointer client_data
;
3268 /* The EMACS_INT cast avoids a warning. */
3269 int idx
= (int) (EMACS_INT
) client_data
;
3270 int mod
= (int) g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3272 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3273 Lisp_Object key
, frame
;
3274 struct input_event event
;
3277 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3280 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3282 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3283 XSETFRAME (frame
, f
);
3284 event
.kind
= TOOL_BAR_EVENT
;
3285 event
.frame_or_window
= frame
;
3287 kbd_buffer_store_event (&event
);
3289 event
.kind
= TOOL_BAR_EVENT
;
3290 event
.frame_or_window
= frame
;
3292 /* Convert between the modifier bits GDK uses and the modifier bits
3293 Emacs uses. This assumes GDK an X masks are the same, which they are when
3295 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3296 kbd_buffer_store_event (&event
);
3299 /* This callback is called when a tool bar is detached. We must set
3300 the height of the tool bar to zero when this happens so frame sizes
3301 are correctly calculated.
3302 WBOX is the handle box widget that enables detach/attach of the tool bar.
3303 W is the tool bar widget.
3304 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3307 xg_tool_bar_detach_callback (wbox
, w
, client_data
)
3310 gpointer client_data
;
3312 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3313 extern int x_gtk_whole_detached_tool_bar
;
3315 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3320 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3322 /* When detaching a tool bar, not everything dissapear. There are
3323 a few pixels left that are used to drop the tool bar back into
3325 FRAME_TOOLBAR_HEIGHT (f
) = 2;
3327 /* The height has changed, resize outer widget and set columns
3328 rows to what we had before detaching the tool bar. */
3329 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3333 /* This callback is called when a tool bar is reattached. We must set
3334 the height of the tool bar when this happens so frame sizes
3335 are correctly calculated.
3336 WBOX is the handle box widget that enables detach/attach of the tool bar.
3337 W is the tool bar widget.
3338 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3341 xg_tool_bar_attach_callback (wbox
, w
, client_data
)
3344 gpointer client_data
;
3346 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3347 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3353 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3355 gtk_widget_size_request (w
, &req
);
3356 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3358 /* The height has changed, resize outer widget and set columns
3359 rows to what we had before attaching the tool bar. */
3360 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3364 /* This callback is called when the mouse enters or leaves a tool bar item.
3365 It is used for displaying and hiding the help text.
3366 W is the tool bar item, a button.
3367 EVENT is either an enter event or leave event.
3368 CLIENT_DATA is an integer that is the index of the button in the
3369 tool bar. 0 is the first button.
3371 Returns FALSE to tell GTK to keep processing this event. */
3374 xg_tool_bar_help_callback (w
, event
, client_data
)
3376 GdkEventCrossing
*event
;
3377 gpointer client_data
;
3379 /* The EMACS_INT cast avoids a warning. */
3380 int idx
= (int) (EMACS_INT
) client_data
;
3381 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3382 Lisp_Object help
, frame
;
3384 if (! GTK_IS_BUTTON (w
))
3387 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3390 if (event
->type
== GDK_ENTER_NOTIFY
)
3392 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3393 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3396 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3401 XSETFRAME (frame
, f
);
3402 kbd_buffer_store_help_event (frame
, help
);
3408 /* This callback is called when a tool bar item shall be redrawn.
3409 It modifies the expose event so that the GtkImage widget redraws the
3410 whole image. This to overcome a bug that makes GtkImage draw the image
3411 in the wrong place when it tries to redraw just a part of the image.
3412 W is the GtkImage to be redrawn.
3413 EVENT is the expose event for W.
3414 CLIENT_DATA is unused.
3416 Returns FALSE to tell GTK to keep processing this event. */
3419 xg_tool_bar_item_expose_callback (w
, event
, client_data
)
3421 GdkEventExpose
*event
;
3422 gpointer client_data
;
3426 gdk_drawable_get_size (event
->window
, &width
, &height
);
3428 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3429 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3431 event
->area
.x
= max (0, event
->area
.x
);
3432 event
->area
.y
= max (0, event
->area
.y
);
3434 event
->area
.width
= max (width
, event
->area
.width
);
3435 event
->area
.height
= max (height
, event
->area
.height
);
3440 /* This callback is called when a tool bar shall be redrawn.
3441 We need to update the tool bar from here in case the image cache
3442 has deleted the pixmaps used in the tool bar.
3443 W is the GtkToolbar to be redrawn.
3444 EVENT is the expose event for W.
3445 CLIENT_DATA is pointing to the frame for this tool bar.
3447 Returns FALSE to tell GTK to keep processing this event. */
3450 xg_tool_bar_expose_callback (w
, event
, client_data
)
3452 GdkEventExpose
*event
;
3453 gpointer client_data
;
3455 update_frame_tool_bar ((FRAME_PTR
) client_data
);
3459 /* Create a tool bar for frame F. */
3462 xg_create_tool_bar (f
)
3465 struct x_output
*x
= f
->output_data
.x
;
3467 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3469 x
->toolbar_widget
= gtk_toolbar_new ();
3470 x
->handlebox_widget
= gtk_handle_box_new ();
3471 x
->toolbar_detached
= 0;
3473 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3476 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3479 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3482 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3484 /* We only have icons, so override any user setting. We could
3485 use the caption property of the toolbar item (see update_frame_tool_bar
3486 below), but some of those strings are long, making the toolbar so
3487 long it does not fit on the screen. The GtkToolbar widget makes every
3488 item equal size, so the longest caption determine the size of every
3489 tool bar item. I think the creators of the GtkToolbar widget
3490 counted on 4 or 5 character long strings. */
3491 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3492 gtk_toolbar_set_orientation (GTK_TOOLBAR (x
->toolbar_widget
),
3493 GTK_ORIENTATION_HORIZONTAL
);
3495 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3496 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3497 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3498 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3499 g_signal_connect (G_OBJECT (x
->toolbar_widget
),
3501 G_CALLBACK (xg_tool_bar_expose_callback
),
3504 gtk_widget_show_all (x
->handlebox_widget
);
3506 gtk_widget_size_request (x
->toolbar_widget
, &req
);
3507 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3509 /* The height has changed, resize outer widget and set columns
3510 rows to what we had before adding the tool bar. */
3511 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3513 SET_FRAME_GARBAGED (f
);
3516 /* Update the tool bar for frame F. Add new buttons and remove old. */
3519 update_frame_tool_bar (f
)
3523 GtkRequisition old_req
, new_req
;
3526 struct x_output
*x
= f
->output_data
.x
;
3527 int hmargin
, vmargin
;
3529 if (! FRAME_GTK_WIDGET (f
))
3534 if (INTEGERP (Vtool_bar_button_margin
)
3535 && XINT (Vtool_bar_button_margin
) > 0)
3537 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3538 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3540 else if (CONSP (Vtool_bar_button_margin
))
3542 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3543 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3544 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3546 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3547 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3548 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3551 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3552 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3553 i.e. zero. This means that margins less than
3554 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3555 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3556 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3558 if (! x
->toolbar_widget
)
3559 xg_create_tool_bar (f
);
3561 gtk_widget_size_request (x
->toolbar_widget
, &old_req
);
3563 icon_list
= gtk_container_get_children (GTK_CONTAINER (x
->toolbar_widget
));
3566 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3568 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3570 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3571 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3576 GtkWidget
*wicon
= iter
? GTK_WIDGET (iter
->data
) : 0;
3578 if (iter
) iter
= g_list_next (iter
);
3580 /* If image is a vector, choose the image according to the
3582 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3583 if (VECTORP (image
))
3587 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3588 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3591 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3592 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3594 xassert (ASIZE (image
) >= idx
);
3595 image
= AREF (image
, idx
);
3600 /* Ignore invalid image specifications. */
3601 if (!valid_image_p (image
))
3603 if (wicon
) gtk_widget_hide (wicon
);
3607 img_id
= lookup_image (f
, image
);
3608 img
= IMAGE_FROM_ID (f
, img_id
);
3609 prepare_image_for_display (f
, img
);
3611 if (img
->load_failed_p
|| img
->pixmap
== None
)
3613 if (wicon
) gtk_widget_hide (wicon
);
3619 GtkWidget
*w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
3620 GtkToolItem
*ti
= gtk_tool_button_new (w
, "");
3622 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
3624 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
),
3627 /* The EMACS_INT cast avoids a warning. */
3628 g_signal_connect (GTK_WIDGET (ti
), "clicked",
3629 GTK_SIGNAL_FUNC (xg_tool_bar_callback
),
3630 (gpointer
) (EMACS_INT
) i
);
3632 gtk_widget_show (GTK_WIDGET (ti
));
3633 gtk_widget_show (GTK_WIDGET (w
));
3635 /* Save the image so we can see if an update is needed when
3636 this function is called again. */
3637 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
3638 (gpointer
)img
->pixmap
);
3640 g_object_set_data (G_OBJECT (ti
), XG_FRAME_DATA
, (gpointer
)f
);
3642 /* Catch expose events to overcome an annoying redraw bug, see
3643 comment for xg_tool_bar_item_expose_callback. */
3644 g_signal_connect (G_OBJECT (ti
),
3646 G_CALLBACK (xg_tool_bar_item_expose_callback
),
3649 gtk_widget_set_sensitive (GTK_WIDGET (ti
), enabled_p
);
3650 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (ti
), FALSE
);
3652 while (! GTK_IS_BUTTON (w
))
3653 w
= gtk_widget_get_parent (w
);
3655 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
3656 no distinction based on modifiers in the activate callback,
3657 so we have to do it ourselves. */
3658 g_signal_connect (w
, "button-release-event",
3659 GTK_SIGNAL_FUNC (xg_tool_bar_button_cb
),
3662 g_object_set_data (G_OBJECT (w
), XG_FRAME_DATA
, (gpointer
)f
);
3664 /* Use enter/leave notify to show help. We use the events
3665 rather than the GtkButton specific signals "enter" and
3666 "leave", so we can have only one callback. The event
3667 will tell us what kind of event it is. */
3668 /* The EMACS_INT cast avoids a warning. */
3669 g_signal_connect (G_OBJECT (w
),
3670 "enter-notify-event",
3671 G_CALLBACK (xg_tool_bar_help_callback
),
3672 (gpointer
) (EMACS_INT
) i
);
3673 g_signal_connect (G_OBJECT (w
),
3674 "leave-notify-event",
3675 G_CALLBACK (xg_tool_bar_help_callback
),
3676 (gpointer
) (EMACS_INT
) i
);
3680 /* The child of the tool bar is a button. Inside that button
3681 is a vbox. Inside that vbox is the GtkImage. */
3682 GtkWidget
*wvbox
= gtk_bin_get_child (GTK_BIN (wicon
));
3683 GList
*chlist
= gtk_container_get_children (GTK_CONTAINER (wvbox
));
3684 GtkImage
*wimage
= GTK_IMAGE (chlist
->data
);
3685 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
3686 XG_TOOL_BAR_IMAGE_DATA
);
3687 g_list_free (chlist
);
3689 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
3691 if (old_img
!= img
->pixmap
)
3692 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
3694 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
3695 (gpointer
)img
->pixmap
);
3697 gtk_widget_set_sensitive (wicon
, enabled_p
);
3698 gtk_widget_show (wicon
);
3704 /* Remove buttons not longer needed. We just hide them so they
3705 can be reused later on. */
3708 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3709 gtk_widget_hide (w
);
3710 iter
= g_list_next (iter
);
3713 gtk_widget_size_request (x
->toolbar_widget
, &new_req
);
3714 if (old_req
.height
!= new_req
.height
3715 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
3717 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
3718 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3721 if (icon_list
) g_list_free (icon_list
);
3726 /* Deallocate all resources for the tool bar on frame F.
3727 Remove the tool bar. */
3730 free_frame_tool_bar (f
)
3733 struct x_output
*x
= f
->output_data
.x
;
3735 if (x
->toolbar_widget
)
3738 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
3739 x
->handlebox_widget
);
3740 x
->toolbar_widget
= 0;
3741 x
->handlebox_widget
= 0;
3742 FRAME_TOOLBAR_HEIGHT (f
) = 0;
3744 /* The height has changed, resize outer widget and set columns
3745 rows to what we had before removing the tool bar. */
3746 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3748 SET_FRAME_GARBAGED (f
);
3755 /***********************************************************************
3757 ***********************************************************************/
3761 GtkBindingSet
*binding_set
;
3763 xg_ignore_gtk_scrollbar
= 0;
3764 xg_detached_menus
= 0;
3765 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
3766 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
3768 id_to_widget
.max_size
= id_to_widget
.used
= 0;
3769 id_to_widget
.widgets
= 0;
3771 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
3772 bindings. It doesn't seem to be any way to remove properties,
3773 so we set it to VoidSymbol which in X means "no key". */
3774 gtk_settings_set_string_property (gtk_settings_get_default (),
3775 "gtk-menu-bar-accel",
3779 /* Make GTK text input widgets use Emacs style keybindings. This is
3781 gtk_settings_set_string_property (gtk_settings_get_default (),
3782 "gtk-key-theme-name",
3786 /* Make dialogs close on C-g. Since file dialog inherits from
3787 dialog, this works for them also. */
3788 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_DIALOG
));
3789 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3792 /* Make menus close on C-g. */
3793 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_MENU_SHELL
));
3794 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3798 #endif /* USE_GTK */
3800 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
3801 (do not change this comment) */