1 /* Functions for creating and updating GTK widgets.
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
30 #include "blockinput.h"
31 #include "syssignal.h"
35 #include "termhooks.h"
39 #include <gdk/gdkkeysyms.h>
42 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
43 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
46 /***********************************************************************
47 Display handling functions
48 ***********************************************************************/
50 #ifdef HAVE_GTK_MULTIDISPLAY
52 /* Return the GdkDisplay that corresponds to the X display DPY. */
55 xg_get_gdk_display (dpy
)
58 return gdk_x11_lookup_xdisplay (dpy
);
61 /* When the GTK widget W is to be created on a display for F that
62 is not the default display, set the display for W.
63 W can be a GtkMenu or a GtkWindow widget. */
70 if (FRAME_X_DISPLAY (f
) != GDK_DISPLAY ())
72 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
73 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
76 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
78 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
83 #else /* not HAVE_GTK_MULTIDISPLAY */
85 /* Make some defines so we can use the GTK 2.2 functions when
86 compiling with GTK 2.0. */
88 #define xg_set_screen(w, f)
89 #define gdk_xid_table_lookup_for_display(dpy, w) gdk_xid_table_lookup (w)
90 #define gdk_pixmap_foreign_new_for_display(dpy, p) gdk_pixmap_foreign_new (p)
91 #define gdk_cursor_new_for_display(dpy, c) gdk_cursor_new (c)
92 #define gdk_x11_lookup_xdisplay(dpy) 0
93 #define GdkDisplay void
95 #endif /* not HAVE_GTK_MULTIDISPLAY */
97 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
98 *DPY is set to NULL if the display can't be opened.
100 Returns non-zero if display could be opened, zero if display could not
101 be opened, and less than zero if the GTK version doesn't support
105 xg_display_open (display_name
, dpy
)
109 #ifdef HAVE_GTK_MULTIDISPLAY
112 gdpy
= gdk_display_open (display_name
);
113 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
117 #else /* not HAVE_GTK_MULTIDISPLAY */
120 #endif /* not HAVE_GTK_MULTIDISPLAY */
124 /* Close display DPY. */
127 xg_display_close (Display
*dpy
)
129 #ifdef HAVE_GTK_MULTIDISPLAY
130 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
132 /* GTK 2.2 has a bug that makes gdk_display_close crash (bug
133 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way
134 we can continue running, but there will be memory leaks. */
136 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 4
138 /* If this is the default display, we must change it before calling
139 dispose, otherwise it will crash. */
140 if (gdk_display_get_default () == gdpy
)
142 struct x_display_info
*dpyinfo
;
143 Display
*new_dpy
= 0;
144 GdkDisplay
*gdpy_new
;
146 /* Find another display. */
147 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
148 if (dpyinfo
->display
!= dpy
)
150 new_dpy
= dpyinfo
->display
;
154 if (! new_dpy
) return; /* Emacs will exit anyway. */
156 gdpy_new
= gdk_x11_lookup_xdisplay (new_dpy
);
157 gdk_display_manager_set_default_display (gdk_display_manager_get (),
161 g_object_run_dispose (G_OBJECT (gdpy
));
164 /* I hope this will be fixed in GTK 2.4. It is what bug 85715 says. */
165 gdk_display_close (gdpy
);
167 #endif /* HAVE_GTK_MULTIDISPLAY */
171 /***********************************************************************
173 ***********************************************************************/
174 /* The timer for scroll bar repetition and menu bar timeouts.
175 NULL if no timer is started. */
176 static struct atimer
*xg_timer
;
179 /* The next two variables and functions are taken from lwlib. */
180 static widget_value
*widget_value_free_list
;
181 static int malloc_cpt
;
183 /* Allocate a widget_value structure, either by taking one from the
184 widget_value_free_list or by malloc:ing a new one.
186 Return a pointer to the allocated structure. */
189 malloc_widget_value ()
192 if (widget_value_free_list
)
194 wv
= widget_value_free_list
;
195 widget_value_free_list
= wv
->free_list
;
200 wv
= (widget_value
*) malloc (sizeof (widget_value
));
203 memset (wv
, 0, sizeof (widget_value
));
207 /* This is analogous to free. It frees only what was allocated
208 by malloc_widget_value, and no substructures. */
211 free_widget_value (wv
)
219 /* When the number of already allocated cells is too big,
226 wv
->free_list
= widget_value_free_list
;
227 widget_value_free_list
= wv
;
232 /* Create and return the cursor to be used for popup menus and
233 scroll bars on display DPY. */
236 xg_create_default_cursor (dpy
)
239 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
240 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
243 /* For the image defined in IMG, make and return a GtkImage. For displays with
244 8 planes or less we must make a GdkPixbuf and apply the mask manually.
245 Otherwise the highlightning and dimming the tool bar code in GTK does
246 will look bad. For display with more than 8 planes we just use the
247 pixmap and mask directly. For monochrome displays, GTK doesn't seem
248 able to use external pixmaps, it looks bad whatever we do.
249 The image is defined on the display where frame F is.
250 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
251 If OLD_WIDGET is NULL, a new widget is constructed and returned.
252 If OLD_WIDGET is not NULL, that widget is modified. */
255 xg_get_image_for_pixmap (f
, img
, widget
, old_widget
)
259 GtkImage
*old_widget
;
265 /* If we are on a one bit display, let GTK do all the image handling.
266 This seems to be the only way to make insensitive and activated icons
268 if (x_screen_planes (f
) == 1)
270 Lisp_Object specified_file
= Qnil
;
272 extern Lisp_Object QCfile
;
274 for (tail
= XCDR (img
->spec
);
275 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
276 tail
= XCDR (XCDR (tail
)))
277 if (EQ (XCAR (tail
), QCfile
))
278 specified_file
= XCAR (XCDR (tail
));
280 if (STRINGP (specified_file
))
283 Lisp_Object file
= Qnil
;
287 file
= x_find_image_file (specified_file
);
288 /* We already loaded the image once before calling this
289 function, so this should not fail. */
290 xassert (STRINGP (file
) != 0);
293 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SDATA (file
)));
295 gtk_image_set_from_file (old_widget
, SDATA (file
));
298 return GTK_WIDGET (old_widget
);
302 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
303 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
304 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
306 if (x_screen_planes (f
) > 8 || x_screen_planes (f
) == 1)
309 old_widget
= GTK_IMAGE (gtk_image_new_from_pixmap (gpix
, gmask
));
311 gtk_image_set_from_pixmap (old_widget
, gpix
, gmask
);
315 /* This is a workaround to make icons look good on pseudo color
316 displays. Apparently GTK expects the images to have an alpha
317 channel. If they don't, insensitive and activated icons will
318 look bad. This workaround does not work on monochrome displays,
319 and is not needed on true color/static color displays (i.e.
320 16 bits and higher). */
321 int x
, y
, width
, height
, rowstride
, mask_rowstride
;
322 GdkPixbuf
*icon_buf
, *tmp_buf
;
326 gdk_drawable_get_size (gpix
, &width
, &height
);
327 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
,
329 gtk_widget_get_colormap (widget
),
330 0, 0, 0, 0, width
, height
);
331 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
332 g_object_unref (G_OBJECT (tmp_buf
));
336 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
341 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
342 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
343 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
344 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
347 for (y
= 0; y
< height
; ++y
)
349 guchar
*iconptr
, *maskptr
;
352 iconptr
= pixels
+ y
* rowstride
;
353 maskptr
= mask_pixels
+ y
* mask_rowstride
;
355 for (x
= 0; x
< width
; ++x
)
357 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
358 just R is sufficient. */
360 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
362 iconptr
+= rowstride
/width
;
363 maskptr
+= mask_rowstride
/width
;
367 g_object_unref (G_OBJECT (mask_buf
));
371 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
373 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
375 g_object_unref (G_OBJECT (icon_buf
));
378 g_object_unref (G_OBJECT (gpix
));
379 if (gmask
) g_object_unref (G_OBJECT (gmask
));
381 return GTK_WIDGET (old_widget
);
385 /* Set CURSOR on W and all widgets W contain. We must do like this
386 for scroll bars and menu because they create widgets internally,
387 and it is those widgets that are visible. */
390 xg_set_cursor (w
, cursor
)
394 GList
*children
= gdk_window_peek_children (w
->window
);
396 gdk_window_set_cursor (w
->window
, cursor
);
398 /* The scroll bar widget has more than one GDK window (had to look at
399 the source to figure this out), and there is no way to set cursor
400 on widgets in GTK. So we must set the cursor for all GDK windows.
403 for ( ; children
; children
= g_list_next (children
))
404 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
407 /* Timer function called when a timeout occurs for xg_timer.
408 This function processes all GTK events in a recursive event loop.
409 This is done because GTK timer events are not seen by Emacs event
410 detection, Emacs only looks for X events. When a scroll bar has the
411 pointer (detected by button press/release events below) an Emacs
412 timer is started, and this function can then check if the GTK timer
413 has expired by calling the GTK event loop.
414 Also, when a menu is active, it has a small timeout before it
415 pops down the sub menu under it. */
418 xg_process_timeouts (timer
)
419 struct atimer
*timer
;
422 /* Ideally we would like to just handle timer events, like the Xt version
423 of this does in xterm.c, but there is no such feature in GTK. */
424 while (gtk_events_pending ())
425 gtk_main_iteration ();
429 /* Start the xg_timer with an interval of 0.1 seconds, if not already started.
430 xg_process_timeouts is called when the timer expires. The timer
431 started is continuous, i.e. runs until xg_stop_timer is called. */
439 EMACS_SET_SECS_USECS (interval
, 0, 100000);
440 xg_timer
= start_atimer (ATIMER_CONTINUOUS
,
447 /* Stop the xg_timer if started. */
454 cancel_atimer (xg_timer
);
459 /* Insert NODE into linked LIST. */
462 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
464 xg_list_node
*list_start
= list
->next
;
466 if (list_start
) list_start
->prev
= node
;
467 node
->next
= list_start
;
472 /* Remove NODE from linked LIST. */
475 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
477 xg_list_node
*list_start
= list
->next
;
478 if (node
== list_start
)
480 list
->next
= node
->next
;
481 if (list
->next
) list
->next
->prev
= 0;
485 node
->prev
->next
= node
->next
;
486 if (node
->next
) node
->next
->prev
= node
->prev
;
490 /* Allocate and return a utf8 version of STR. If STR is already
491 utf8 or NULL, just return STR.
492 If not, a new string is allocated and the caller must free the result
496 get_utf8_string (str
)
499 char *utf8_str
= str
;
501 /* If not UTF-8, try current locale. */
502 if (str
&& !g_utf8_validate (str
, -1, NULL
))
503 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
510 /***********************************************************************
511 General functions for creating widgets, resizing, events, e.t.c.
512 ***********************************************************************/
514 /* Make a geometry string and pass that to GTK. It seems this is the
515 only way to get geometry position right if the user explicitly
516 asked for a position when starting Emacs.
517 F is the frame we shall set geometry for. */
523 if (f
->size_hint_flags
& USPosition
)
525 int left
= f
->left_pos
;
526 int xneg
= f
->size_hint_flags
& XNegative
;
527 int top
= f
->top_pos
;
528 int yneg
= f
->size_hint_flags
& YNegative
;
536 sprintf (geom_str
, "=%dx%d%c%d%c%d",
537 FRAME_PIXEL_WIDTH (f
),
538 FRAME_TOTAL_PIXEL_HEIGHT (f
),
539 (xneg
? '-' : '+'), left
,
540 (yneg
? '-' : '+'), top
);
542 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
544 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
549 /* Resize the outer window of frame F after chainging the height.
550 This happend when the menu bar or the tool bar is added or removed.
551 COLUMNS/ROWS is the size the edit area shall have after the resize. */
554 xg_resize_outer_widget (f
, columns
, rows
)
559 /* If we are not mapped yet, set geometry once again, as window
560 height now have changed. */
561 if (! GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f
)))
564 xg_frame_set_char_size (f
, columns
, rows
);
565 gdk_window_process_all_updates ();
568 /* Function to handle resize of our widgets. Since Emacs has some layouts
569 that does not fit well with GTK standard containers, we do most layout
571 F is the frame to resize.
572 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
575 xg_resize_widgets (f
, pixelwidth
, pixelheight
)
577 int pixelwidth
, pixelheight
;
579 int mbheight
= FRAME_MENUBAR_HEIGHT (f
);
580 int tbheight
= FRAME_TOOLBAR_HEIGHT (f
);
581 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, (pixelheight
582 - mbheight
- tbheight
));
583 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
585 if (FRAME_GTK_WIDGET (f
)
586 && (columns
!= FRAME_COLS (f
)
587 || rows
!= FRAME_LINES (f
)
588 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
589 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
)))
591 struct x_output
*x
= f
->output_data
.x
;
594 all
.y
= mbheight
+ tbheight
;
597 all
.width
= pixelwidth
;
598 all
.height
= pixelheight
- mbheight
- tbheight
;
600 gtk_widget_size_allocate (x
->edit_widget
, &all
);
602 change_frame_size (f
, rows
, columns
, 0, 1, 0);
603 SET_FRAME_GARBAGED (f
);
604 cancel_mouse_face (f
);
609 /* Update our widget size to be COLS/ROWS characters for frame F. */
612 xg_frame_set_char_size (f
, cols
, rows
)
617 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
618 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
621 /* Take into account the size of the scroll bar. Always use the
622 number of columns occupied by the scroll bar here otherwise we
623 might end up with a frame width that is not a multiple of the
624 frame's character width which is bad for vertically split
626 f
->scroll_bar_actual_width
627 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
629 compute_fringe_widths (f
, 0);
631 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
632 after calculating that value. */
633 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
635 /* Must resize our top level widget. Font size may have changed,
636 but not rows/cols. */
637 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
638 pixelwidth
, pixelheight
);
639 xg_resize_widgets (f
, pixelwidth
, pixelheight
);
640 x_wm_set_size_hint (f
, 0, 0);
641 SET_FRAME_GARBAGED (f
);
642 cancel_mouse_face (f
);
645 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
646 Must be done like this, because GtkWidget:s can have "hidden"
647 X Window that aren't accessible.
649 Return 0 if no widget match WDESC. */
652 xg_win_to_widget (dpy
, wdesc
)
657 GtkWidget
*gwdesc
= 0;
661 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
666 event
.any
.window
= gdkwin
;
667 gwdesc
= gtk_get_event_widget (&event
);
674 /* Fill in the GdkColor C so that it represents PIXEL.
675 W is the widget that color will be used for. Used to find colormap. */
678 xg_pix_to_gcolor (w
, pixel
, c
)
683 GdkColormap
*map
= gtk_widget_get_colormap (w
);
684 gdk_colormap_query_color (map
, pixel
, c
);
687 /* Create and set up the GTK widgets for frame F.
688 Return 0 if creation failed, non-zero otherwise. */
691 xg_create_frame_widgets (f
)
704 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
705 xg_set_screen (wtop
, f
);
707 wvbox
= gtk_vbox_new (FALSE
, 0);
708 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
710 if (! wtop
|| ! wvbox
|| ! wfixed
)
712 if (wtop
) gtk_widget_destroy (wtop
);
713 if (wvbox
) gtk_widget_destroy (wvbox
);
714 if (wfixed
) gtk_widget_destroy (wfixed
);
720 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
721 gtk_widget_set_name (wtop
, EMACS_CLASS
);
722 gtk_widget_set_name (wvbox
, "pane");
723 gtk_widget_set_name (wfixed
, SDATA (Vx_resource_name
));
725 /* If this frame has a title or name, set it in the title bar. */
726 if (! NILP (f
->title
)) title
= SDATA (ENCODE_UTF_8 (f
->title
));
727 else if (! NILP (f
->name
)) title
= SDATA (ENCODE_UTF_8 (f
->name
));
729 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
731 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
732 FRAME_GTK_WIDGET (f
) = wfixed
;
733 f
->output_data
.x
->vbox_widget
= wvbox
;
735 gtk_fixed_set_has_window (GTK_FIXED (wfixed
), TRUE
);
737 gtk_widget_set_size_request (wfixed
, FRAME_PIXEL_WIDTH (f
),
738 FRAME_PIXEL_HEIGHT (f
));
740 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
741 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
743 if (FRAME_EXTERNAL_TOOL_BAR (f
))
744 update_frame_tool_bar (f
);
746 /* The tool bar is created but first there are no items in it.
747 This causes it to be zero height. Later items are added, but then
748 the frame is already mapped, so there is a "jumping" resize.
749 This makes geometry handling difficult, for example -0-0 will end
750 up in the wrong place as tool bar height has not been taken into account.
751 So we cheat a bit by setting a height that is what it will have
752 later on when tool bar items are added. */
753 if (FRAME_EXTERNAL_TOOL_BAR (f
) && f
->n_tool_bar_items
== 0)
754 FRAME_TOOLBAR_HEIGHT (f
) = 38;
757 /* We don't want this widget double buffered, because we draw on it
758 with regular X drawing primitives, so from a GTK/GDK point of
759 view, the widget is totally blank. When an expose comes, this
760 will make the widget blank, and then Emacs redraws it. This flickers
761 a lot, so we turn off double buffering. */
762 gtk_widget_set_double_buffered (wfixed
, FALSE
);
764 /* GTK documents says use gtk_window_set_resizable. But then a user
765 can't shrink the window from its starting size. */
766 gtk_window_set_policy (GTK_WINDOW (wtop
), TRUE
, TRUE
, TRUE
);
767 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
768 SDATA (Vx_resource_name
),
769 SDATA (Vx_resource_class
));
771 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
772 GTK is to destroy the widget. We want Emacs to do that instead. */
773 g_signal_connect (G_OBJECT (wtop
), "delete-event",
774 G_CALLBACK (gtk_true
), 0);
776 /* Convert our geometry parameters into a geometry string
778 GTK will itself handle calculating the real position this way. */
781 gtk_widget_add_events (wfixed
,
782 GDK_POINTER_MOTION_MASK
784 | GDK_BUTTON_PRESS_MASK
785 | GDK_BUTTON_RELEASE_MASK
787 | GDK_ENTER_NOTIFY_MASK
788 | GDK_LEAVE_NOTIFY_MASK
789 | GDK_FOCUS_CHANGE_MASK
791 | GDK_VISIBILITY_NOTIFY_MASK
);
793 /* Must realize the windows so the X window gets created. It is used
794 by callers of this function. */
795 gtk_widget_realize (wfixed
);
796 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
798 /* Since GTK clears its window by filling with the background color,
799 we must keep X and GTK background in sync. */
800 xg_pix_to_gcolor (wfixed
, f
->output_data
.x
->background_pixel
, &bg
);
801 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
803 /* Also, do not let any background pixmap to be set, this looks very
804 bad as Emacs overwrites the background pixmap with its own idea
805 of background color. */
806 style
= gtk_widget_get_modifier_style (wfixed
);
808 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
809 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
810 gtk_widget_modify_style (wfixed
, style
);
812 /* GTK does not set any border, and they look bad with GTK. */
814 f
->internal_border_width
= 0;
821 /* Set the normal size hints for the window manager, for frame F.
822 FLAGS is the flags word to use--or 0 meaning preserve the flags
823 that the window now has.
824 If USER_POSITION is nonzero, we set the User Position
825 flag (this is useful when FLAGS is 0). */
828 x_wm_set_size_hint (f
, flags
, user_position
)
833 if (FRAME_GTK_OUTER_WIDGET (f
))
835 /* Must use GTK routines here, otherwise GTK resets the size hints
836 to its own defaults. */
837 GdkGeometry size_hints
;
839 int base_width
, base_height
;
840 int min_rows
= 0, min_cols
= 0;
841 int win_gravity
= f
->win_gravity
;
845 memset (&size_hints
, 0, sizeof (size_hints
));
846 f
->output_data
.x
->size_hints
= size_hints
;
847 f
->output_data
.x
->hint_flags
= hint_flags
;
850 flags
= f
->size_hint_flags
;
852 size_hints
= f
->output_data
.x
->size_hints
;
853 hint_flags
= f
->output_data
.x
->hint_flags
;
855 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
856 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
857 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
859 hint_flags
|= GDK_HINT_BASE_SIZE
;
860 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
861 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
862 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
864 check_frame_size (f
, &min_rows
, &min_cols
);
866 size_hints
.base_width
= base_width
;
867 size_hints
.base_height
= base_height
;
868 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
869 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
872 /* These currently have a one to one mapping with the X values, but I
873 don't think we should rely on that. */
874 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
875 size_hints
.win_gravity
= 0;
876 if (win_gravity
== NorthWestGravity
)
877 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
878 else if (win_gravity
== NorthGravity
)
879 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
880 else if (win_gravity
== NorthEastGravity
)
881 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
882 else if (win_gravity
== WestGravity
)
883 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
884 else if (win_gravity
== CenterGravity
)
885 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
886 else if (win_gravity
== EastGravity
)
887 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
888 else if (win_gravity
== SouthWestGravity
)
889 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
890 else if (win_gravity
== SouthGravity
)
891 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
892 else if (win_gravity
== SouthEastGravity
)
893 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
894 else if (win_gravity
== StaticGravity
)
895 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
897 if (flags
& PPosition
) hint_flags
|= GDK_HINT_POS
;
898 if (flags
& USPosition
) hint_flags
|= GDK_HINT_USER_POS
;
899 if (flags
& USSize
) hint_flags
|= GDK_HINT_USER_SIZE
;
903 hint_flags
&= ~GDK_HINT_POS
;
904 hint_flags
|= GDK_HINT_USER_POS
;
909 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
910 FRAME_GTK_OUTER_WIDGET (f
),
914 f
->output_data
.x
->size_hints
= size_hints
;
915 f
->output_data
.x
->hint_flags
= hint_flags
;
920 /* Change background color of a frame.
921 Since GTK uses the background colour to clear the window, we must
922 keep the GTK and X colors in sync.
923 F is the frame to change,
924 BG is the pixel value to change to. */
927 xg_set_background_color (f
, bg
)
931 if (FRAME_GTK_WIDGET (f
))
936 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
937 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
944 /***********************************************************************
946 ***********************************************************************/
947 /* Return the dialog title to use for a dialog of type KEY.
948 This is the encoding used by lwlib. We use the same for GTK. */
951 get_dialog_title (char key
)
961 title
= "Information";
980 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
981 the dialog, but return TRUE so the event does not propagate further
982 in GTK. This prevents GTK from destroying the dialog widget automatically
983 and we can always destrou the widget manually, regardles of how
984 it was popped down (button press or WM_DELETE_WINDOW).
985 W is the dialog widget.
986 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
987 user_data is NULL (not used).
989 Returns TRUE to end propagation of event. */
992 dialog_delete_callback (w
, event
, user_data
)
997 gtk_widget_unmap (w
);
1001 /* Create a popup dialog window. See also xg_create_widget below.
1002 WV is a widget_value describing the dialog.
1003 SELECT_CB is the callback to use when a button has been pressed.
1004 DEACTIVATE_CB is the callback to use when the dialog pops down.
1006 Returns the GTK dialog widget. */
1009 create_dialog (wv
, select_cb
, deactivate_cb
)
1011 GCallback select_cb
;
1012 GCallback deactivate_cb
;
1014 char *title
= get_dialog_title (wv
->name
[0]);
1015 int total_buttons
= wv
->name
[1] - '0';
1016 int right_buttons
= wv
->name
[4] - '0';
1019 int button_spacing
= 10;
1020 GtkWidget
*wdialog
= gtk_dialog_new ();
1024 GtkWidget
*whbox_up
;
1025 GtkWidget
*whbox_down
;
1027 /* If the number of buttons is greater than 4, make two rows of buttons
1028 instead. This looks better. */
1029 int make_two_rows
= total_buttons
> 4;
1031 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1032 left_buttons
= total_buttons
- right_buttons
;
1034 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1035 gtk_widget_set_name (wdialog
, "emacs-dialog");
1037 cur_box
= GTK_BOX (GTK_DIALOG (wdialog
)->action_area
);
1041 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1042 whbox_up
= gtk_hbox_new (FALSE
, 0);
1043 whbox_down
= gtk_hbox_new (FALSE
, 0);
1045 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1046 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1047 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1049 cur_box
= GTK_BOX (whbox_up
);
1052 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1053 G_CALLBACK (dialog_delete_callback
), 0);
1057 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1058 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1061 for (item
= wv
->contents
; item
; item
= item
->next
)
1063 char *utf8_label
= get_utf8_string (item
->value
);
1067 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1069 /* This is the text part of the dialog. */
1070 w
= gtk_label_new (utf8_label
);
1071 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1074 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
), w
,
1076 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1078 /* Try to make dialog look better. Must realize first so
1079 the widget can calculate the size it needs. */
1080 gtk_widget_realize (w
);
1081 gtk_widget_size_request (w
, &req
);
1082 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1084 if (item
->value
&& strlen (item
->value
) > 0)
1085 button_spacing
= 2*req
.width
/strlen (item
->value
);
1089 /* This is one button to add to the dialog. */
1090 w
= gtk_button_new_with_label (utf8_label
);
1091 if (! item
->enabled
)
1092 gtk_widget_set_sensitive (w
, FALSE
);
1094 g_signal_connect (G_OBJECT (w
), "clicked",
1095 select_cb
, item
->call_data
);
1097 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1098 if (++button_nr
== left_buttons
)
1101 cur_box
= GTK_BOX (whbox_down
);
1103 gtk_box_pack_start (cur_box
,
1110 if (utf8_label
&& utf8_label
!= item
->value
)
1111 g_free (utf8_label
);
1119 /***********************************************************************
1120 File dialog functions
1121 ***********************************************************************/
1122 /* Function that is called when the file dialog pops down.
1123 W is the dialog widget, RESPONSE is the response code.
1124 USER_DATA is what we passed in to g_signal_connect (pointer to int). */
1127 xg_file_response_cb (w
,
1134 int *ptr
= (int *) user_data
;
1139 /* Destroy the dialog. This makes it pop down. */
1142 pop_down_file_dialog (arg
)
1145 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1147 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1152 typedef char * (*xg_get_file_func
) P_ ((GtkWidget
*));
1154 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1156 /* Return the selected file for file chooser dialog W.
1157 The returned string must be free:d. */
1160 xg_get_file_name_from_chooser (w
)
1163 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1166 /* Read a file name from the user using a file chooser dialog.
1167 F is the current frame.
1168 PROMPT is a prompt to show to the user. May not be NULL.
1169 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1170 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1171 file. *FUNC is set to a function that can be used to retrieve the
1172 selected file name from the returned widget.
1174 Returns the created widget. */
1177 xg_get_file_with_chooser (f
, prompt
, default_filename
,
1178 mustmatch_p
, only_dir_p
, func
)
1181 char *default_filename
;
1182 int mustmatch_p
, only_dir_p
;
1183 xg_get_file_func
*func
;
1186 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1187 GtkFileChooserAction action
= (mustmatch_p
?
1188 GTK_FILE_CHOOSER_ACTION_OPEN
:
1189 GTK_FILE_CHOOSER_ACTION_SAVE
);
1192 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1194 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1195 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1196 (mustmatch_p
|| only_dir_p
?
1197 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1200 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1202 if (default_filename
)
1205 struct gcpro gcpro1
;
1208 file
= build_string (default_filename
);
1210 /* File chooser does not understand ~/... in the file name. It must be
1211 an absolute name starting with /. */
1212 if (default_filename
[0] != '/')
1213 file
= Fexpand_file_name (file
, Qnil
);
1215 default_filename
= SDATA (file
);
1216 if (Ffile_directory_p (file
))
1217 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1220 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1226 *func
= xg_get_file_name_from_chooser
;
1229 #endif /* HAVE_GTK_FILE_CHOOSER_DIALOG_NEW */
1231 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1233 /* Return the selected file for file selector dialog W.
1234 The returned string must be free:d. */
1237 xg_get_file_name_from_selector (w
)
1240 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1241 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1244 /* Create a file selection dialog.
1245 F is the current frame.
1246 PROMPT is a prompt to show to the user. May not be NULL.
1247 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1248 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1249 file. *FUNC is set to a function that can be used to retrieve the
1250 selected file name from the returned widget.
1252 Returns the created widget. */
1255 xg_get_file_with_selection (f
, prompt
, default_filename
,
1256 mustmatch_p
, only_dir_p
, func
)
1259 char *default_filename
;
1260 int mustmatch_p
, only_dir_p
;
1261 xg_get_file_func
*func
;
1264 GtkFileSelection
*filesel
;
1266 filewin
= gtk_file_selection_new (prompt
);
1267 filesel
= GTK_FILE_SELECTION (filewin
);
1269 if (default_filename
)
1270 gtk_file_selection_set_filename (filesel
, default_filename
);
1274 /* The selection_entry part of filesel is not documented. */
1275 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1276 gtk_file_selection_hide_fileop_buttons (filesel
);
1279 *func
= xg_get_file_name_from_selector
;
1283 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1285 /* Read a file name from the user using a file dialog, either the old
1286 file selection dialog, or the new file chooser dialog. Which to use
1287 depends on what the GTK version used has, and what the value of
1288 gtk-use-old-file-dialog.
1289 F is the current frame.
1290 PROMPT is a prompt to show to the user. May not be NULL.
1291 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1292 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1295 Returns a file name or NULL if no file was selected.
1296 The returned string must be freed by the caller. */
1299 xg_get_file_name (f
, prompt
, default_filename
, mustmatch_p
, only_dir_p
)
1302 char *default_filename
;
1303 int mustmatch_p
, only_dir_p
;
1306 int count
= SPECPDL_INDEX ();
1308 int filesel_done
= 0;
1309 xg_get_file_func func
;
1310 extern int x_use_old_gtk_file_dialog
;
1312 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1313 /* I really don't know why this is needed, but without this the GLIBC add on
1314 library linuxthreads hangs when the Gnome file chooser backend creates
1316 sigblock (sigmask (__SIGRTMIN
));
1317 #endif /* HAVE_GTK_AND_PTHREAD */
1319 #ifdef HAVE_GTK_FILE_BOTH
1321 if (x_use_old_gtk_file_dialog
)
1322 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1323 mustmatch_p
, only_dir_p
, &func
);
1325 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1326 mustmatch_p
, only_dir_p
, &func
);
1328 #else /* not HAVE_GTK_FILE_BOTH */
1330 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1331 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1332 mustmatch_p
, only_dir_p
, &func
);
1334 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1335 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1336 mustmatch_p
, only_dir_p
, &func
);
1339 #endif /* HAVE_GTK_FILE_BOTH */
1341 xg_set_screen (w
, f
);
1342 gtk_widget_set_name (w
, "emacs-filedialog");
1343 gtk_window_set_transient_for (GTK_WINDOW (w
),
1344 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1345 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1346 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1348 g_signal_connect (G_OBJECT (w
),
1350 G_CALLBACK (xg_file_response_cb
),
1353 /* Don't destroy the widget if closed by the window manager close button. */
1354 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1356 gtk_widget_show (w
);
1358 record_unwind_protect (pop_down_file_dialog
, make_save_value (w
, 0));
1359 while (! filesel_done
)
1361 x_menu_wait_for_event (0);
1362 gtk_main_iteration ();
1365 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1366 sigunblock (sigmask (__SIGRTMIN
));
1369 if (filesel_done
== GTK_RESPONSE_OK
)
1372 unbind_to (count
, Qnil
);
1378 /***********************************************************************
1380 ***********************************************************************/
1382 /* The name of menu items that can be used for citomization. Since GTK
1383 RC files are very crude and primitive, we have to set this on all
1384 menu item names so a user can easily cutomize menu items. */
1386 #define MENU_ITEM_NAME "emacs-menuitem"
1389 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1390 during GC. The next member points to the items. */
1391 static xg_list_node xg_menu_cb_list
;
1393 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1394 during GC. The next member points to the items. */
1395 static xg_list_node xg_menu_item_cb_list
;
1397 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1398 F is the frame CL_DATA will be initialized for.
1399 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1401 The menu bar and all sub menus under the menu bar in a frame
1402 share the same structure, hence the reference count.
1404 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1405 allocated xg_menu_cb_data if CL_DATA is NULL. */
1407 static xg_menu_cb_data
*
1408 make_cl_data (cl_data
, f
, highlight_cb
)
1409 xg_menu_cb_data
*cl_data
;
1411 GCallback highlight_cb
;
1415 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1417 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1418 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1419 cl_data
->highlight_cb
= highlight_cb
;
1420 cl_data
->ref_count
= 0;
1422 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1425 cl_data
->ref_count
++;
1430 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1431 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1433 When the menu bar is updated, menu items may have been added and/or
1434 removed, so menu_bar_vector and menu_bar_items_used change. We must
1435 then update CL_DATA since it is used to determine which menu
1436 item that is invoked in the menu.
1437 HIGHLIGHT_CB could change, there is no check that the same
1438 function is given when modifying a menu bar as was given when
1439 creating the menu bar. */
1442 update_cl_data (cl_data
, f
, highlight_cb
)
1443 xg_menu_cb_data
*cl_data
;
1445 GCallback highlight_cb
;
1450 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1451 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1452 cl_data
->highlight_cb
= highlight_cb
;
1456 /* Decrease reference count for CL_DATA.
1457 If reference count is zero, free CL_DATA. */
1460 unref_cl_data (cl_data
)
1461 xg_menu_cb_data
*cl_data
;
1463 if (cl_data
&& cl_data
->ref_count
> 0)
1465 cl_data
->ref_count
--;
1466 if (cl_data
->ref_count
== 0)
1468 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1474 /* Function that marks all lisp data during GC. */
1481 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1482 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1484 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1486 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1488 if (! NILP (cb_data
->help
))
1489 mark_object (cb_data
->help
);
1494 /* Callback called when a menu item is destroyed. Used to free data.
1495 W is the widget that is being destroyed (not used).
1496 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1499 menuitem_destroy_callback (w
, client_data
)
1501 gpointer client_data
;
1505 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1506 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1511 /* Callback called when the pointer enters/leaves a menu item.
1513 EVENT is either an enter event or leave event.
1514 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W.
1516 Returns FALSE to tell GTK to keep processing this event. */
1519 menuitem_highlight_callback (w
, event
, client_data
)
1521 GdkEventCrossing
*event
;
1522 gpointer client_data
;
1526 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1527 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : client_data
;
1529 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1531 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1532 (*func
) (w
, call_data
);
1539 /* Callback called when a menu is destroyed. Used to free data.
1540 W is the widget that is being destroyed (not used).
1541 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1544 menu_destroy_callback (w
, client_data
)
1546 gpointer client_data
;
1548 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1551 /* Callback called when a menu does a grab or ungrab. That means the
1552 menu has been activated or deactivated.
1553 Used to start a timer so the small timeout the menus in GTK uses before
1554 popping down a menu is seen by Emacs (see xg_process_timeouts above).
1555 W is the widget that does the grab (not used).
1556 UNGRAB_P is TRUE if this is an ungrab, FALSE if it is a grab.
1557 CLIENT_DATA is NULL (not used). */
1560 menu_grab_callback (GtkWidget
*widget
,
1562 gpointer client_data
)
1564 /* Keep track of total number of grabs. */
1567 if (ungrab_p
) cnt
--;
1570 if (cnt
> 0 && ! xg_timer
) xg_start_timer ();
1571 else if (cnt
== 0 && xg_timer
) xg_stop_timer ();
1574 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1575 must be non-NULL) and can be inserted into a menu item.
1577 Returns the GtkHBox. */
1580 make_widget_for_menu_item (utf8_label
, utf8_key
)
1588 wbox
= gtk_hbox_new (FALSE
, 0);
1589 wlbl
= gtk_label_new (utf8_label
);
1590 wkey
= gtk_label_new (utf8_key
);
1592 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1593 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1595 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1596 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1598 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1599 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1600 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1605 /* Make and return a menu item widget with the key to the right.
1606 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1607 UTF8_KEY is the text representing the key binding.
1608 ITEM is the widget_value describing the menu item.
1610 GROUP is an in/out parameter. If the menu item to be created is not
1611 part of any radio menu group, *GROUP contains NULL on entry and exit.
1612 If the menu item to be created is part of a radio menu group, on entry
1613 *GROUP contains the group to use, or NULL if this is the first item
1614 in the group. On exit, *GROUP contains the radio item group.
1616 Unfortunately, keys don't line up as nicely as in Motif,
1617 but the MacOS X version doesn't either, so I guess that is OK. */
1620 make_menu_item (utf8_label
, utf8_key
, item
, group
)
1627 GtkWidget
*wtoadd
= 0;
1629 /* It has been observed that some menu items have a NULL name field.
1630 This will lead to this function being called with a NULL utf8_label.
1631 GTK crashes on that so we set a blank label. Why there is a NULL
1632 name remains to be investigated. */
1633 if (! utf8_label
) utf8_label
= " ";
1636 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1638 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1641 if (utf8_key
) w
= gtk_check_menu_item_new ();
1642 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1643 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1645 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1647 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1648 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1649 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1651 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1656 if (utf8_key
) w
= gtk_menu_item_new ();
1657 else w
= gtk_menu_item_new_with_label (utf8_label
);
1660 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1661 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1666 /* Return non-zero if LABEL specifies a separator (GTK only has one
1670 xg_separator_p (char *label
)
1672 if (! label
) return 0;
1673 else if (strlen (label
) > 3
1674 && strncmp (label
, "--", 2) == 0
1677 static char* separator_names
[] = {
1682 "single-dashed-line",
1683 "double-dashed-line",
1685 "shadow-etched-out",
1686 "shadow-etched-in-dash",
1687 "shadow-etched-out-dash",
1688 "shadow-double-etched-in",
1689 "shadow-double-etched-out",
1690 "shadow-double-etched-in-dash",
1691 "shadow-double-etched-out-dash",
1698 for (i
= 0; separator_names
[i
]; ++i
)
1699 if (strcmp (label
, separator_names
[i
]) == 0)
1704 /* Old-style separator, maybe. It's a separator if it contains
1706 while (*label
== '-')
1708 if (*label
== 0) return 1;
1714 static int xg_detached_menus
;
1716 /* Returns non-zero if there are detached menus. */
1719 xg_have_tear_offs ()
1721 return xg_detached_menus
> 0;
1724 /* Callback invoked when a detached menu window is removed. Here we
1725 decrease the xg_detached_menus count.
1726 WIDGET is the top level window that is removed (the parent of the menu).
1727 CLIENT_DATA is not used. */
1730 tearoff_remove (widget
, client_data
)
1732 gpointer client_data
;
1734 if (xg_detached_menus
> 0) --xg_detached_menus
;
1737 /* Callback invoked when a menu is detached. It increases the
1738 xg_detached_menus count.
1739 WIDGET is the GtkTearoffMenuItem.
1740 CLIENT_DATA is not used. */
1743 tearoff_activate (widget
, client_data
)
1745 gpointer client_data
;
1747 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
1748 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
1750 ++xg_detached_menus
;
1751 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
1753 G_CALLBACK (tearoff_remove
), 0);
1758 /* Create a menu item widget, and connect the callbacks.
1759 ITEM decribes the menu item.
1760 F is the frame the created menu belongs to.
1761 SELECT_CB is the callback to use when a menu item is selected.
1762 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1763 CL_DATA points to the callback data to be used for this menu.
1764 GROUP is an in/out parameter. If the menu item to be created is not
1765 part of any radio menu group, *GROUP contains NULL on entry and exit.
1766 If the menu item to be created is part of a radio menu group, on entry
1767 *GROUP contains the group to use, or NULL if this is the first item
1768 in the group. On exit, *GROUP contains the radio item group.
1770 Returns the created GtkWidget. */
1773 xg_create_one_menuitem (item
, f
, select_cb
, highlight_cb
, cl_data
, group
)
1776 GCallback select_cb
;
1777 GCallback highlight_cb
;
1778 xg_menu_cb_data
*cl_data
;
1784 xg_menu_item_cb_data
*cb_data
;
1786 utf8_label
= get_utf8_string (item
->name
);
1787 utf8_key
= get_utf8_string (item
->key
);
1789 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
1791 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
1792 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
1794 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
1796 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
1798 cb_data
->unhighlight_id
= cb_data
->highlight_id
= cb_data
->select_id
= 0;
1799 cb_data
->help
= item
->help
;
1800 cb_data
->cl_data
= cl_data
;
1801 cb_data
->call_data
= item
->call_data
;
1803 g_signal_connect (G_OBJECT (w
),
1805 G_CALLBACK (menuitem_destroy_callback
),
1808 /* Put cb_data in widget, so we can get at it when modifying menubar */
1809 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
1811 /* final item, not a submenu */
1812 if (item
->call_data
&& ! item
->contents
)
1816 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
1819 if (! NILP (item
->help
) && highlight_cb
)
1821 /* We use enter/leave notify instead of select/deselect because
1822 select/deselect doesn't go well with detached menus. */
1823 cb_data
->highlight_id
1824 = g_signal_connect (G_OBJECT (w
),
1825 "enter-notify-event",
1826 G_CALLBACK (menuitem_highlight_callback
),
1828 cb_data
->unhighlight_id
1829 = g_signal_connect (G_OBJECT (w
),
1830 "leave-notify-event",
1831 G_CALLBACK (menuitem_highlight_callback
),
1838 static GtkWidget
*create_menus
P_ ((widget_value
*, FRAME_PTR
, GCallback
,
1839 GCallback
, GCallback
, int, int, int,
1840 GtkWidget
*, xg_menu_cb_data
*, char *));
1842 /* Create a full menu tree specified by DATA.
1843 F is the frame the created menu belongs to.
1844 SELECT_CB is the callback to use when a menu item is selected.
1845 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
1846 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1847 POP_UP_P is non-zero if we shall create a popup menu.
1848 MENU_BAR_P is non-zero if we shall create a menu bar.
1849 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
1850 if MENU_BAR_P is non-zero.
1851 TOPMENU is the topmost GtkWidget that others shall be placed under.
1852 It may be NULL, in that case we create the appropriate widget
1853 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
1854 CL_DATA is the callback data we shall use for this menu, or NULL
1855 if we haven't set the first callback yet.
1856 NAME is the name to give to the top level menu if this function
1857 creates it. May be NULL to not set any name.
1859 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
1862 This function calls itself to create submenus. */
1865 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
1866 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
1869 GCallback select_cb
;
1870 GCallback deactivate_cb
;
1871 GCallback highlight_cb
;
1876 xg_menu_cb_data
*cl_data
;
1880 GtkWidget
*wmenu
= topmenu
;
1881 GSList
*group
= NULL
;
1887 wmenu
= gtk_menu_new ();
1888 xg_set_screen (wmenu
, f
);
1890 else wmenu
= gtk_menu_bar_new ();
1892 /* Put cl_data on the top menu for easier access. */
1893 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
1894 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
1895 g_signal_connect (G_OBJECT (wmenu
), "destroy",
1896 G_CALLBACK (menu_destroy_callback
), cl_data
);
1899 gtk_widget_set_name (wmenu
, name
);
1902 g_signal_connect (G_OBJECT (wmenu
),
1903 "selection-done", deactivate_cb
, 0);
1905 g_signal_connect (G_OBJECT (wmenu
),
1906 "grab-notify", G_CALLBACK (menu_grab_callback
), 0);
1909 if (! menu_bar_p
&& add_tearoff_p
)
1911 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
1912 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
1914 g_signal_connect (G_OBJECT (tearoff
), "activate",
1915 G_CALLBACK (tearoff_activate
), 0);
1918 for (item
= data
; item
; item
= item
->next
)
1922 if (pop_up_p
&& !item
->contents
&& !item
->call_data
1923 && !xg_separator_p (item
->name
))
1926 /* A title for a popup. We do the same as GTK does when
1927 creating titles, but it does not look good. */
1929 utf8_label
= get_utf8_string (item
->name
);
1931 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
1932 w
= gtk_menu_item_new_with_label (utf8_label
);
1933 gtk_widget_set_sensitive (w
, FALSE
);
1934 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
1936 else if (xg_separator_p (item
->name
))
1939 /* GTK only have one separator type. */
1940 w
= gtk_separator_menu_item_new ();
1944 w
= xg_create_one_menuitem (item
,
1946 item
->contents
? 0 : select_cb
,
1953 GtkWidget
*submenu
= create_menus (item
->contents
,
1964 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
1968 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
1969 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
1975 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
1976 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
1977 with some text and buttons.
1978 F is the frame the created item belongs to.
1979 NAME is the name to use for the top widget.
1980 VAL is a widget_value structure describing items to be created.
1981 SELECT_CB is the callback to use when a menu item is selected or
1982 a dialog button is pressed.
1983 DEACTIVATE_CB is the callback to use when an item is deactivated.
1984 For a menu, when a sub menu is not shown anymore, for a dialog it is
1985 called when the dialog is popped down.
1986 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1988 Returns the widget created. */
1991 xg_create_widget (type
, name
, f
, val
,
1992 select_cb
, deactivate_cb
, highlight_cb
)
1997 GCallback select_cb
;
1998 GCallback deactivate_cb
;
1999 GCallback highlight_cb
;
2002 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2003 int pop_up_p
= strcmp (type
, "popup") == 0;
2005 if (strcmp (type
, "dialog") == 0)
2007 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2008 xg_set_screen (w
, f
);
2009 gtk_window_set_transient_for (GTK_WINDOW (w
),
2010 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2011 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2012 gtk_widget_set_name (w
, "emacs-dialog");
2013 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2015 else if (menu_bar_p
|| pop_up_p
)
2017 w
= create_menus (val
->contents
,
2029 /* Set the cursor to an arrow for popup menus when they are mapped.
2030 This is done by default for menu bar menus. */
2033 /* Must realize so the GdkWindow inside the widget is created. */
2034 gtk_widget_realize (w
);
2035 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2040 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2047 /* Return the label for menu item WITEM. */
2050 xg_get_menu_item_label (witem
)
2053 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2054 return gtk_label_get_label (wlabel
);
2057 /* Return non-zero if the menu item WITEM has the text LABEL. */
2060 xg_item_label_same_p (witem
, label
)
2065 char *utf8_label
= get_utf8_string (label
);
2066 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2068 if (! old_label
&& ! utf8_label
)
2070 else if (old_label
&& utf8_label
)
2071 is_same
= strcmp (utf8_label
, old_label
) == 0;
2073 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2078 /* Destroy widgets in LIST. */
2081 xg_destroy_widgets (list
)
2086 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2088 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2090 /* Destroying the widget will remove it from the container it is in. */
2091 gtk_widget_destroy (w
);
2095 /* Update the top level names in MENUBAR (i.e. not submenus).
2096 F is the frame the menu bar belongs to.
2097 *LIST is a list with the current menu bar names (menu item widgets).
2098 ITER is the item within *LIST that shall be updated.
2099 POS is the numerical position, starting at 0, of ITER in *LIST.
2100 VAL describes what the menu bar shall look like after the update.
2101 SELECT_CB is the callback to use when a menu item is selected.
2102 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2103 CL_DATA points to the callback data to be used for this menu bar.
2105 This function calls itself to walk through the menu bar names. */
2108 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2109 select_cb
, highlight_cb
, cl_data
)
2116 GCallback select_cb
;
2117 GCallback highlight_cb
;
2118 xg_menu_cb_data
*cl_data
;
2120 if (! iter
&& ! val
)
2122 else if (iter
&& ! val
)
2124 /* Item(s) have been removed. Remove all remaining items. */
2125 xg_destroy_widgets (iter
);
2131 else if (! iter
&& val
)
2133 /* Item(s) added. Add all new items in one call. */
2134 create_menus (val
, f
, select_cb
, 0, highlight_cb
,
2135 0, 1, 0, menubar
, cl_data
, 0);
2141 /* Below this neither iter or val is NULL */
2142 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2144 /* This item is still the same, check next item. */
2146 iter
= g_list_next (iter
);
2149 else /* This item is changed. */
2151 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2152 GtkMenuItem
*witem2
= 0;
2153 int val_in_menubar
= 0;
2154 int iter_in_new_menubar
= 0;
2158 /* See if the changed entry (val) is present later in the menu bar */
2160 iter2
&& ! val_in_menubar
;
2161 iter2
= g_list_next (iter2
))
2163 witem2
= GTK_MENU_ITEM (iter2
->data
);
2164 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2167 /* See if the current entry (iter) is present later in the
2168 specification for the new menu bar. */
2169 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2170 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2172 if (val_in_menubar
&& ! iter_in_new_menubar
)
2176 /* This corresponds to:
2181 gtk_widget_ref (GTK_WIDGET (witem
));
2182 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2183 gtk_widget_destroy (GTK_WIDGET (witem
));
2185 /* Must get new list since the old changed. */
2186 g_list_free (*list
);
2187 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2188 while (nr
-- > 0) iter
= g_list_next (iter
);
2190 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2192 /* This corresponds to:
2195 Rename B to X. This might seem to be a strange thing to do,
2196 since if there is a menu under B it will be totally wrong for X.
2197 But consider editing a C file. Then there is a C-mode menu
2198 (corresponds to B above).
2199 If then doing C-x C-f the minibuf menu (X above) replaces the
2200 C-mode menu. When returning from the minibuffer, we get
2201 back the C-mode menu. Thus we do:
2202 Rename B to X (C-mode to minibuf menu)
2203 Rename X to B (minibuf to C-mode menu).
2204 If the X menu hasn't been invoked, the menu under B
2205 is up to date when leaving the minibuffer. */
2206 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2207 char *utf8_label
= get_utf8_string (val
->name
);
2208 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2210 gtk_label_set_text (wlabel
, utf8_label
);
2212 /* If this item has a submenu that has been detached, change
2213 the title in the WM decorations also. */
2214 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2215 /* Set the title of the detached window. */
2216 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2218 iter
= g_list_next (iter
);
2222 else if (! val_in_menubar
&& iter_in_new_menubar
)
2224 /* This corresponds to:
2231 GtkWidget
*w
= xg_create_one_menuitem (val
,
2238 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2239 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2241 g_list_free (*list
);
2242 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2243 while (nr
-- > 0) iter
= g_list_next (iter
);
2244 iter
= g_list_next (iter
);
2248 else /* if (val_in_menubar && iter_in_new_menubar) */
2251 /* This corresponds to:
2256 gtk_widget_ref (GTK_WIDGET (witem2
));
2257 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2258 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2259 GTK_WIDGET (witem2
), pos
);
2260 gtk_widget_unref (GTK_WIDGET (witem2
));
2262 g_list_free (*list
);
2263 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2264 while (nr
-- > 0) iter
= g_list_next (iter
);
2270 /* Update the rest of the menu bar. */
2271 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2272 select_cb
, highlight_cb
, cl_data
);
2275 /* Update the menu item W so it corresponds to VAL.
2276 SELECT_CB is the callback to use when a menu item is selected.
2277 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2278 CL_DATA is the data to set in the widget for menu invokation. */
2281 xg_update_menu_item (val
, w
, select_cb
, highlight_cb
, cl_data
)
2284 GCallback select_cb
;
2285 GCallback highlight_cb
;
2286 xg_menu_cb_data
*cl_data
;
2293 const char *old_label
= 0;
2294 const char *old_key
= 0;
2295 xg_menu_item_cb_data
*cb_data
;
2297 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2298 utf8_label
= get_utf8_string (val
->name
);
2299 utf8_key
= get_utf8_string (val
->key
);
2301 /* See if W is a menu item with a key. See make_menu_item above. */
2302 if (GTK_IS_HBOX (wchild
))
2304 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2306 wlbl
= GTK_LABEL (list
->data
);
2307 wkey
= GTK_LABEL (list
->next
->data
);
2312 /* Remove the key and keep just the label. */
2313 gtk_widget_ref (GTK_WIDGET (wlbl
));
2314 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2315 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2320 else /* Just a label. */
2322 wlbl
= GTK_LABEL (wchild
);
2324 /* Check if there is now a key. */
2327 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2328 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2330 wlbl
= GTK_LABEL (list
->data
);
2331 wkey
= GTK_LABEL (list
->next
->data
);
2334 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2335 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2340 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2341 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2343 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2344 gtk_label_set_text (wkey
, utf8_key
);
2346 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2347 gtk_label_set_text (wlbl
, utf8_label
);
2349 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2350 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2352 if (! val
->enabled
&& GTK_WIDGET_SENSITIVE (w
))
2353 gtk_widget_set_sensitive (w
, FALSE
);
2354 else if (val
->enabled
&& ! GTK_WIDGET_SENSITIVE (w
))
2355 gtk_widget_set_sensitive (w
, TRUE
);
2357 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2361 cb_data
->call_data
= val
->call_data
;
2362 cb_data
->help
= val
->help
;
2363 cb_data
->cl_data
= cl_data
;
2365 /* We assume the callback functions don't change. */
2366 if (val
->call_data
&& ! val
->contents
)
2368 /* This item shall have a select callback. */
2369 if (! cb_data
->select_id
)
2371 = g_signal_connect (G_OBJECT (w
), "activate",
2372 select_cb
, cb_data
);
2374 else if (cb_data
->select_id
)
2376 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2377 cb_data
->select_id
= 0;
2380 if (NILP (cb_data
->help
))
2382 /* Shall not have help. Remove if any existed previously. */
2383 if (cb_data
->highlight_id
)
2385 g_signal_handler_disconnect (G_OBJECT (w
),
2386 cb_data
->highlight_id
);
2387 cb_data
->highlight_id
= 0;
2389 if (cb_data
->unhighlight_id
)
2391 g_signal_handler_disconnect (G_OBJECT (w
),
2392 cb_data
->unhighlight_id
);
2393 cb_data
->unhighlight_id
= 0;
2396 else if (! cb_data
->highlight_id
&& highlight_cb
)
2398 /* Have help now, but didn't previously. Add callback. */
2399 cb_data
->highlight_id
2400 = g_signal_connect (G_OBJECT (w
),
2401 "enter-notify-event",
2402 G_CALLBACK (menuitem_highlight_callback
),
2404 cb_data
->unhighlight_id
2405 = g_signal_connect (G_OBJECT (w
),
2406 "leave-notify-event",
2407 G_CALLBACK (menuitem_highlight_callback
),
2413 /* Update the toggle menu item W so it corresponds to VAL. */
2416 xg_update_toggle_item (val
, w
)
2420 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2423 /* Update the radio menu item W so it corresponds to VAL. */
2426 xg_update_radio_item (val
, w
)
2430 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2433 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2434 SUBMENU may be NULL, in that case a new menu is created.
2435 F is the frame the menu bar belongs to.
2436 VAL describes the contents of the menu bar.
2437 SELECT_CB is the callback to use when a menu item is selected.
2438 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2439 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2440 CL_DATA is the call back data to use for any newly created items.
2442 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2446 xg_update_submenu (submenu
, f
, val
,
2447 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2451 GCallback select_cb
;
2452 GCallback deactivate_cb
;
2453 GCallback highlight_cb
;
2454 xg_menu_cb_data
*cl_data
;
2456 GtkWidget
*newsub
= submenu
;
2460 int has_tearoff_p
= 0;
2461 GList
*first_radio
= 0;
2464 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2466 for (cur
= val
, iter
= list
;
2468 iter
= g_list_next (iter
), cur
= cur
->next
)
2470 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2472 /* Skip tearoff items, they have no counterpart in val. */
2473 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2476 iter
= g_list_next (iter
);
2477 if (iter
) w
= GTK_WIDGET (iter
->data
);
2481 /* Remember first radio button in a group. If we get a mismatch in
2482 a radio group we must rebuild the whole group so that the connections
2483 in GTK becomes correct. */
2484 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2486 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2487 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2490 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2492 if (! xg_separator_p (cur
->name
))
2495 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2497 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2499 xg_update_toggle_item (cur
, w
);
2500 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2502 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2504 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2506 xg_update_radio_item (cur
, w
);
2507 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2509 else if (GTK_IS_MENU_ITEM (w
))
2511 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2514 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2515 xg_separator_p (cur
->name
))
2518 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2520 sub
= gtk_menu_item_get_submenu (witem
);
2521 if (sub
&& ! cur
->contents
)
2523 /* Not a submenu anymore. */
2524 gtk_widget_ref (sub
);
2525 gtk_menu_item_remove_submenu (witem
);
2526 gtk_widget_destroy (sub
);
2528 else if (cur
->contents
)
2532 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2533 select_cb
, deactivate_cb
,
2534 highlight_cb
, cl_data
);
2536 /* If this item just became a submenu, we must set it. */
2538 gtk_menu_item_set_submenu (witem
, nsub
);
2543 /* Structural difference. Remove everything from here and down
2549 /* Remove widgets from first structual change. */
2552 /* If we are adding new menu items below, we must remove from
2553 first radio button so that radio groups become correct. */
2554 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2555 else xg_destroy_widgets (iter
);
2560 /* More items added. Create them. */
2561 newsub
= create_menus (cur
,
2574 if (list
) g_list_free (list
);
2579 /* Update the MENUBAR.
2580 F is the frame the menu bar belongs to.
2581 VAL describes the contents of the menu bar.
2582 If DEEP_P is non-zero, rebuild all but the top level menu names in
2583 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2584 SELECT_CB is the callback to use when a menu item is selected.
2585 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2586 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2589 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2590 select_cb
, deactivate_cb
, highlight_cb
)
2595 GCallback select_cb
;
2596 GCallback deactivate_cb
;
2597 GCallback highlight_cb
;
2599 xg_menu_cb_data
*cl_data
;
2600 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2604 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2607 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2608 select_cb
, highlight_cb
, cl_data
);
2614 /* Update all sub menus.
2615 We must keep the submenus (GTK menu item widgets) since the
2616 X Window in the XEvent that activates the menu are those widgets. */
2618 /* Update cl_data, menu_item things in F may have changed. */
2619 update_cl_data (cl_data
, f
, highlight_cb
);
2621 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2628 /* Find sub menu that corresponds to val and update it. */
2629 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2631 witem
= GTK_MENU_ITEM (iter
->data
);
2632 if (xg_item_label_same_p (witem
, cur
->name
))
2634 sub
= gtk_menu_item_get_submenu (witem
);
2639 newsub
= xg_update_submenu (sub
,
2646 /* sub may still be NULL. If we just updated non deep and added
2647 a new menu bar item, it has no sub menu yet. So we set the
2648 newly created sub menu under witem. */
2651 xg_set_screen (newsub
, f
);
2652 gtk_menu_item_set_submenu (witem
, newsub
);
2658 gtk_widget_show_all (menubar
);
2661 /* Recompute all the widgets of frame F, when the menu bar has been
2662 changed. Value is non-zero if widgets were updated. */
2665 xg_update_frame_menubar (f
)
2668 struct x_output
*x
= f
->output_data
.x
;
2671 if (!x
->menubar_widget
|| GTK_WIDGET_MAPPED (x
->menubar_widget
))
2676 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2678 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2680 gtk_widget_show_all (x
->menubar_widget
);
2681 gtk_widget_size_request (x
->menubar_widget
, &req
);
2683 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2685 /* The height has changed, resize outer widget and set columns
2686 rows to what we had before adding the menu bar. */
2687 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2689 SET_FRAME_GARBAGED (f
);
2695 /* Get rid of the menu bar of frame F, and free its storage.
2696 This is used when deleting a frame, and when turning off the menu bar. */
2699 free_frame_menubar (f
)
2702 struct x_output
*x
= f
->output_data
.x
;
2704 if (x
->menubar_widget
)
2708 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2709 /* The menubar and its children shall be deleted when removed from
2711 x
->menubar_widget
= 0;
2712 FRAME_MENUBAR_HEIGHT (f
) = 0;
2714 /* The height has changed, resize outer widget and set columns
2715 rows to what we had before removing the menu bar. */
2716 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
2718 SET_FRAME_GARBAGED (f
);
2725 /***********************************************************************
2726 Scroll bar functions
2727 ***********************************************************************/
2730 /* Setting scroll bar values invokes the callback. Use this variable
2731 to indicate that callback should do nothing. */
2733 int xg_ignore_gtk_scrollbar
;
2735 /* SET_SCROLL_BAR_X_WINDOW assumes the second argument fits in
2736 32 bits. But we want to store pointers, and they may be larger
2737 than 32 bits. Keep a mapping from integer index to widget pointers
2738 to get around the 32 bit limitation. */
2742 GtkWidget
**widgets
;
2747 /* Grow this much every time we need to allocate more */
2749 #define ID_TO_WIDGET_INCR 32
2751 /* Store the widget pointer W in id_to_widget and return the integer index. */
2754 xg_store_widget_in_map (w
)
2759 if (id_to_widget
.max_size
== id_to_widget
.used
)
2761 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
2763 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
2764 sizeof (GtkWidget
*)*new_size
);
2766 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
2767 id_to_widget
.widgets
[i
] = 0;
2768 id_to_widget
.max_size
= new_size
;
2771 /* Just loop over the array and find a free place. After all,
2772 how many scroll bars are we creating? Should be a small number.
2773 The check above guarantees we will find a free place. */
2774 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
2776 if (! id_to_widget
.widgets
[i
])
2778 id_to_widget
.widgets
[i
] = w
;
2779 ++id_to_widget
.used
;
2785 /* Should never end up here */
2789 /* Remove pointer at IDX from id_to_widget.
2790 Called when scroll bar is destroyed. */
2793 xg_remove_widget_from_map (idx
)
2796 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2798 id_to_widget
.widgets
[idx
] = 0;
2799 --id_to_widget
.used
;
2803 /* Get the widget pointer at IDX from id_to_widget. */
2806 xg_get_widget_from_map (idx
)
2809 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2810 return id_to_widget
.widgets
[idx
];
2815 /* Return the scrollbar id for X Window WID on display DPY.
2816 Return -1 if WID not in id_to_widget. */
2819 xg_get_scroll_id_for_window (dpy
, wid
)
2826 w
= xg_win_to_widget (dpy
, wid
);
2830 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
2831 if (id_to_widget
.widgets
[idx
] == w
)
2838 /* Callback invoked when scroll bar WIDGET is destroyed.
2839 DATA is the index into id_to_widget for WIDGET.
2840 We free pointer to last scroll bar values here and remove the index. */
2843 xg_gtk_scroll_destroy (widget
, data
)
2848 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
2850 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
2852 xg_remove_widget_from_map (id
);
2855 /* Callback for button press/release events. Used to start timer so that
2856 the scroll bar repetition timer in GTK gets handeled.
2857 Also, sets bar->dragging to Qnil when dragging (button release) is done.
2858 WIDGET is the scroll bar widget the event is for (not used).
2859 EVENT contains the event.
2860 USER_DATA points to the struct scrollbar structure.
2862 Returns FALSE to tell GTK that it shall continue propagate the event
2866 scroll_bar_button_cb (widget
, event
, user_data
)
2868 GdkEventButton
*event
;
2871 if (event
->type
== GDK_BUTTON_PRESS
&& ! xg_timer
)
2873 else if (event
->type
== GDK_BUTTON_RELEASE
)
2875 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
2876 if (xg_timer
) xg_stop_timer ();
2877 bar
->dragging
= Qnil
;
2883 /* Create a scroll bar widget for frame F. Store the scroll bar
2885 SCROLL_CALLBACK is the callback to invoke when the value of the
2887 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
2888 to set resources for the widget. */
2891 xg_create_scroll_bar (f
, bar
, scroll_callback
, scroll_bar_name
)
2893 struct scroll_bar
*bar
;
2894 GCallback scroll_callback
;
2895 char *scroll_bar_name
;
2902 /* Page, step increment values are not so important here, they
2903 will be corrected in x_set_toolkit_scroll_bar_thumb. */
2904 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
2907 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
2908 webox
= gtk_event_box_new ();
2909 gtk_widget_set_name (wscroll
, scroll_bar_name
);
2910 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
2912 scroll_id
= xg_store_widget_in_map (wscroll
);
2914 g_signal_connect (G_OBJECT (wscroll
),
2918 /* The EMACS_INT cast avoids a warning. */
2919 g_signal_connect (G_OBJECT (wscroll
),
2921 G_CALLBACK (xg_gtk_scroll_destroy
),
2922 (gpointer
) (EMACS_INT
) scroll_id
);
2924 /* Connect to button press and button release to detect if any scroll bar
2926 g_signal_connect (G_OBJECT (wscroll
),
2927 "button-press-event",
2928 G_CALLBACK (scroll_bar_button_cb
),
2930 g_signal_connect (G_OBJECT (wscroll
),
2931 "button-release-event",
2932 G_CALLBACK (scroll_bar_button_cb
),
2935 /* The scroll bar widget does not draw on a window of its own. Instead
2936 it draws on the parent window, in this case the edit widget. So
2937 whenever the edit widget is cleared, the scroll bar needs to redraw
2938 also, which causes flicker. Put an event box between the edit widget
2939 and the scroll bar, so the scroll bar instead draws itself on the
2940 event box window. */
2941 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
2942 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
2945 /* Set the cursor to an arrow. */
2946 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2948 SET_SCROLL_BAR_X_WINDOW (bar
, scroll_id
);
2951 /* Make the scroll bar represented by SCROLLBAR_ID visible. */
2954 xg_show_scroll_bar (scrollbar_id
)
2957 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
2959 gtk_widget_show_all (gtk_widget_get_parent (w
));
2962 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
2965 xg_remove_scroll_bar (f
, scrollbar_id
)
2969 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
2972 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
2973 gtk_widget_destroy (w
);
2974 gtk_widget_destroy (wparent
);
2975 SET_FRAME_GARBAGED (f
);
2979 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
2981 TOP/LEFT are the new pixel positions where the bar shall appear.
2982 WIDTH, HEIGHT is the size in pixels the bar shall have. */
2985 xg_update_scrollbar_pos (f
, scrollbar_id
, top
, left
, width
, height
)
2994 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
2998 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
2999 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3001 /* Move and resize to new values. */
3002 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3003 gtk_widget_set_size_request (wscroll
, width
, height
);
3004 gtk_widget_queue_draw (wparent
);
3005 gdk_window_process_all_updates ();
3006 /* GTK does not redraw until the main loop is entered again, but
3007 if there are no X events pending we will not enter it. So we sync
3008 here to get some events. */
3010 SET_FRAME_GARBAGED (f
);
3011 cancel_mouse_face (f
);
3015 /* Set the thumb size and position of scroll bar BAR. We are currently
3016 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3019 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
3020 struct scroll_bar
*bar
;
3021 int portion
, position
, whole
;
3023 GtkWidget
*wscroll
= xg_get_widget_from_map (SCROLL_BAR_X_WINDOW (bar
));
3025 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3027 if (wscroll
&& NILP (bar
->dragging
))
3036 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3038 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3039 rather than the real portion value. This makes the thumb less likely
3040 to resize and that looks better. */
3041 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3042 /* When the thumb is at the bottom, position == whole.
3043 So we need to increase `whole' to make space for the thumb. */
3050 top
= (gdouble
) position
/ whole
;
3051 shown
= (gdouble
) portion
/ whole
;
3054 size
= shown
* XG_SB_RANGE
;
3055 size
= min (size
, XG_SB_RANGE
);
3056 size
= max (size
, 1);
3058 value
= top
* XG_SB_RANGE
;
3059 value
= min (value
, XG_SB_MAX
- size
);
3060 value
= max (value
, XG_SB_MIN
);
3062 /* Assume all lines are of equal size. */
3063 new_step
= size
/ max (1, FRAME_LINES (f
));
3065 if ((int) adj
->page_size
!= size
3066 || (int) adj
->step_increment
!= new_step
)
3068 adj
->page_size
= size
;
3069 adj
->step_increment
= new_step
;
3070 /* Assume a page increment is about 95% of the page size */
3071 adj
->page_increment
= (int) (0.95*adj
->page_size
);
3075 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3077 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3081 /* gtk_range_set_value invokes the callback. Set
3082 ignore_gtk_scrollbar to make the callback do nothing */
3083 xg_ignore_gtk_scrollbar
= 1;
3085 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3086 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3088 gtk_adjustment_changed (adj
);
3090 xg_ignore_gtk_scrollbar
= 0;
3098 /***********************************************************************
3100 ***********************************************************************/
3101 /* The key for the data we put in the GtkImage widgets. The data is
3102 the image used by Emacs. We use this to see if we need to update
3103 the GtkImage with a new image. */
3104 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3106 /* Callback function invoked when a tool bar item is pressed.
3107 W is the button widget in the tool bar that got pressed,
3108 CLIENT_DATA is an integer that is the index of the button in the
3109 tool bar. 0 is the first button. */
3112 xg_tool_bar_callback (w
, client_data
)
3114 gpointer client_data
;
3116 /* The EMACS_INT cast avoids a warning. */
3117 int idx
= (int) (EMACS_INT
) client_data
;
3118 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3119 Lisp_Object key
, frame
;
3120 struct input_event event
;
3123 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3126 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3128 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3129 XSETFRAME (frame
, f
);
3130 event
.kind
= TOOL_BAR_EVENT
;
3131 event
.frame_or_window
= frame
;
3133 kbd_buffer_store_event (&event
);
3135 event
.kind
= TOOL_BAR_EVENT
;
3136 event
.frame_or_window
= frame
;
3138 event
.modifiers
= 0; /* These are not available. */
3139 kbd_buffer_store_event (&event
);
3142 /* This callback is called when a tool bar is detached. We must set
3143 the height of the tool bar to zero when this happens so frame sizes
3144 are correctly calculated.
3145 WBOX is the handle box widget that enables detach/attach of the tool bar.
3146 W is the tool bar widget.
3147 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3150 xg_tool_bar_detach_callback (wbox
, w
, client_data
)
3153 gpointer client_data
;
3155 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3159 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3161 /* When detaching a tool bar, not everything dissapear. There are
3162 a few pixels left that are used to drop the tool bar back into
3164 FRAME_TOOLBAR_HEIGHT (f
) = 2;
3166 /* The height has changed, resize outer widget and set columns
3167 rows to what we had before detaching the tool bar. */
3168 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3172 /* This callback is called when a tool bar is reattached. We must set
3173 the height of the tool bar when this happens so frame sizes
3174 are correctly calculated.
3175 WBOX is the handle box widget that enables detach/attach of the tool bar.
3176 W is the tool bar widget.
3177 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3180 xg_tool_bar_attach_callback (wbox
, w
, client_data
)
3183 gpointer client_data
;
3185 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3191 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3193 gtk_widget_size_request (w
, &req
);
3194 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3196 /* The height has changed, resize outer widget and set columns
3197 rows to what we had before attaching the tool bar. */
3198 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3202 /* This callback is called when the mouse enters or leaves a tool bar item.
3203 It is used for displaying and hiding the help text.
3204 W is the tool bar item, a button.
3205 EVENT is either an enter event or leave event.
3206 CLIENT_DATA is an integer that is the index of the button in the
3207 tool bar. 0 is the first button.
3209 Returns FALSE to tell GTK to keep processing this event. */
3212 xg_tool_bar_help_callback (w
, event
, client_data
)
3214 GdkEventCrossing
*event
;
3215 gpointer client_data
;
3217 /* The EMACS_INT cast avoids a warning. */
3218 int idx
= (int) (EMACS_INT
) client_data
;
3219 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3220 Lisp_Object help
, frame
;
3222 if (! GTK_IS_BUTTON (w
))
3227 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3230 if (event
->type
== GDK_ENTER_NOTIFY
)
3232 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3233 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3236 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3241 XSETFRAME (frame
, f
);
3242 kbd_buffer_store_help_event (frame
, help
);
3248 /* This callback is called when a tool bar item shall be redrawn.
3249 It modifies the expose event so that the GtkImage widget redraws the
3250 whole image. This to overcome a bug that makes GtkImage draw the image
3251 in the wrong place when it tries to redraw just a part of the image.
3252 W is the GtkImage to be redrawn.
3253 EVENT is the expose event for W.
3254 CLIENT_DATA is unused.
3256 Returns FALSE to tell GTK to keep processing this event. */
3259 xg_tool_bar_item_expose_callback (w
, event
, client_data
)
3261 GdkEventExpose
*event
;
3262 gpointer client_data
;
3266 gdk_drawable_get_size (event
->window
, &width
, &height
);
3268 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3269 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3271 event
->area
.x
= max (0, event
->area
.x
);
3272 event
->area
.y
= max (0, event
->area
.y
);
3274 event
->area
.width
= max (width
, event
->area
.width
);
3275 event
->area
.height
= max (height
, event
->area
.height
);
3280 /* This callback is called when a tool bar shall be redrawn.
3281 We need to update the tool bar from here in case the image cache
3282 has deleted the pixmaps used in the tool bar.
3283 W is the GtkToolbar to be redrawn.
3284 EVENT is the expose event for W.
3285 CLIENT_DATA is pointing to the frame for this tool bar.
3287 Returns FALSE to tell GTK to keep processing this event. */
3290 xg_tool_bar_expose_callback (w
, event
, client_data
)
3292 GdkEventExpose
*event
;
3293 gpointer client_data
;
3295 update_frame_tool_bar ((FRAME_PTR
) client_data
);
3299 /* Create a tool bar for frame F. */
3302 xg_create_tool_bar (f
)
3305 struct x_output
*x
= f
->output_data
.x
;
3307 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3309 x
->toolbar_widget
= gtk_toolbar_new ();
3310 x
->handlebox_widget
= gtk_handle_box_new ();
3311 x
->toolbar_detached
= 0;
3313 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3316 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3319 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3322 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3324 /* We only have icons, so override any user setting. We could
3325 use the caption property of the toolbar item (see update_frame_tool_bar
3326 below), but some of those strings are long, making the toolbar so
3327 long it does not fit on the screen. The GtkToolbar widget makes every
3328 item equal size, so the longest caption determine the size of every
3329 tool bar item. I think the creators of the GtkToolbar widget
3330 counted on 4 or 5 character long strings. */
3331 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3332 gtk_toolbar_set_orientation (GTK_TOOLBAR (x
->toolbar_widget
),
3333 GTK_ORIENTATION_HORIZONTAL
);
3335 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3336 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3337 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3338 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3339 g_signal_connect (G_OBJECT (x
->toolbar_widget
),
3341 G_CALLBACK (xg_tool_bar_expose_callback
),
3344 gtk_widget_show_all (x
->handlebox_widget
);
3346 gtk_widget_size_request (x
->toolbar_widget
, &req
);
3347 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3349 /* The height has changed, resize outer widget and set columns
3350 rows to what we had before adding the tool bar. */
3351 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3353 SET_FRAME_GARBAGED (f
);
3356 /* Update the tool bar for frame F. Add new buttons and remove old. */
3359 update_frame_tool_bar (f
)
3363 GtkRequisition old_req
, new_req
;
3366 struct x_output
*x
= f
->output_data
.x
;
3367 int hmargin
, vmargin
;
3369 if (! FRAME_GTK_WIDGET (f
))
3374 if (INTEGERP (Vtool_bar_button_margin
)
3375 && XINT (Vtool_bar_button_margin
) > 0)
3377 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3378 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3380 else if (CONSP (Vtool_bar_button_margin
))
3382 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3383 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3384 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3386 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3387 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3388 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3391 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3392 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3393 i.e. zero. This means that margins less than
3394 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3395 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3396 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3398 if (! x
->toolbar_widget
)
3399 xg_create_tool_bar (f
);
3401 gtk_widget_size_request (x
->toolbar_widget
, &old_req
);
3403 icon_list
= gtk_container_get_children (GTK_CONTAINER (x
->toolbar_widget
));
3406 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3408 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3410 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3411 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3416 GtkWidget
*wicon
= iter
? GTK_WIDGET (iter
->data
) : 0;
3418 if (iter
) iter
= g_list_next (iter
);
3420 /* If image is a vector, choose the image according to the
3422 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3423 if (VECTORP (image
))
3427 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3428 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3431 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
3432 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
3434 xassert (ASIZE (image
) >= idx
);
3435 image
= AREF (image
, idx
);
3440 /* Ignore invalid image specifications. */
3441 if (!valid_image_p (image
))
3443 if (wicon
) gtk_widget_hide (wicon
);
3447 img_id
= lookup_image (f
, image
);
3448 img
= IMAGE_FROM_ID (f
, img_id
);
3449 prepare_image_for_display (f
, img
);
3451 if (img
->load_failed_p
|| img
->pixmap
== None
)
3453 if (wicon
) gtk_widget_hide (wicon
);
3459 GtkWidget
*w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
3461 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
3463 /* The EMACS_INT cast avoids a warning. */
3464 gtk_toolbar_append_item (GTK_TOOLBAR (x
->toolbar_widget
),
3467 GTK_SIGNAL_FUNC (xg_tool_bar_callback
),
3468 (gpointer
) (EMACS_INT
) i
);
3470 /* Save the image so we can see if an update is needed when
3471 this function is called again. */
3472 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
3473 (gpointer
)img
->pixmap
);
3475 /* Catch expose events to overcome an annoying redraw bug, see
3476 comment for xg_tool_bar_item_expose_callback. */
3477 g_signal_connect (G_OBJECT (w
),
3479 G_CALLBACK (xg_tool_bar_item_expose_callback
),
3482 /* We must set sensitive on the button that is the parent
3483 of the GtkImage parent. Go upwards until we find the button. */
3484 while (! GTK_IS_BUTTON (w
))
3485 w
= gtk_widget_get_parent (w
);
3489 /* Save the frame in the button so the xg_tool_bar_callback
3491 g_object_set_data (G_OBJECT (w
), XG_FRAME_DATA
, (gpointer
)f
);
3492 gtk_widget_set_sensitive (w
, enabled_p
);
3494 /* Use enter/leave notify to show help. We use the events
3495 rather than the GtkButton specific signals "enter" and
3496 "leave", so we can have only one callback. The event
3497 will tell us what kind of event it is. */
3498 /* The EMACS_INT cast avoids a warning. */
3499 g_signal_connect (G_OBJECT (w
),
3500 "enter-notify-event",
3501 G_CALLBACK (xg_tool_bar_help_callback
),
3502 (gpointer
) (EMACS_INT
) i
);
3503 g_signal_connect (G_OBJECT (w
),
3504 "leave-notify-event",
3505 G_CALLBACK (xg_tool_bar_help_callback
),
3506 (gpointer
) (EMACS_INT
) i
);
3511 /* The child of the tool bar is a button. Inside that button
3512 is a vbox. Inside that vbox is the GtkImage. */
3513 GtkWidget
*wvbox
= gtk_bin_get_child (GTK_BIN (wicon
));
3514 GList
*chlist
= gtk_container_get_children (GTK_CONTAINER (wvbox
));
3515 GtkImage
*wimage
= GTK_IMAGE (chlist
->data
);
3516 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
3517 XG_TOOL_BAR_IMAGE_DATA
);
3518 g_list_free (chlist
);
3520 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
3522 if (old_img
!= img
->pixmap
)
3523 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
3525 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
3526 (gpointer
)img
->pixmap
);
3528 gtk_widget_set_sensitive (wicon
, enabled_p
);
3529 gtk_widget_show (wicon
);
3535 /* Remove buttons not longer needed. We just hide them so they
3536 can be reused later on. */
3539 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3540 gtk_widget_hide (w
);
3541 iter
= g_list_next (iter
);
3544 gtk_widget_size_request (x
->toolbar_widget
, &new_req
);
3545 if (old_req
.height
!= new_req
.height
3546 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
3548 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
3549 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3552 if (icon_list
) g_list_free (icon_list
);
3557 /* Deallocate all resources for the tool bar on frame F.
3558 Remove the tool bar. */
3561 free_frame_tool_bar (f
)
3564 struct x_output
*x
= f
->output_data
.x
;
3566 if (x
->toolbar_widget
)
3569 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
3570 x
->handlebox_widget
);
3571 x
->toolbar_widget
= 0;
3572 x
->handlebox_widget
= 0;
3573 FRAME_TOOLBAR_HEIGHT (f
) = 0;
3575 /* The height has changed, resize outer widget and set columns
3576 rows to what we had before removing the tool bar. */
3577 xg_resize_outer_widget (f
, FRAME_COLS (f
), FRAME_LINES (f
));
3579 SET_FRAME_GARBAGED (f
);
3586 /***********************************************************************
3588 ***********************************************************************/
3592 GtkBindingSet
*binding_set
;
3594 xg_ignore_gtk_scrollbar
= 0;
3595 xg_detached_menus
= 0;
3596 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
3597 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
3599 id_to_widget
.max_size
= id_to_widget
.used
= 0;
3600 id_to_widget
.widgets
= 0;
3602 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
3603 bindings. It doesn't seem to be any way to remove properties,
3604 so we set it to VoidSymbol which in X means "no key". */
3605 gtk_settings_set_string_property (gtk_settings_get_default (),
3606 "gtk-menu-bar-accel",
3610 /* Make GTK text input widgets use Emacs style keybindings. This is
3612 gtk_settings_set_string_property (gtk_settings_get_default (),
3613 "gtk-key-theme-name",
3617 /* Make dialogs close on C-g. Since file dialog inherits from
3618 dialog, this works for them also. */
3619 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_DIALOG
));
3620 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3623 /* Make menus close on C-g. */
3624 binding_set
= gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_MENU_SHELL
));
3625 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
3629 #endif /* USE_GTK */
3631 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
3632 (do not change this comment) */