1 /* Functions for creating and updating GTK widgets.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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 3 of the License, or
10 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
29 #include "blockinput.h"
30 #include "syssignal.h"
33 #include "termhooks.h"
37 #include <gdk/gdkkeysyms.h>
40 #include <X11/Xft/Xft.h>
43 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
44 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
46 /* Avoid "differ in sign" warnings */
47 #define SSDATA(x) ((char *) SDATA (x))
50 /***********************************************************************
51 Display handling functions
52 ***********************************************************************/
54 #ifdef HAVE_GTK_MULTIDISPLAY
56 /* Keep track of the default display, or NULL if there is none. Emacs
57 may close all its displays. */
59 static GdkDisplay
*gdpy_def
;
61 /* Return the GdkDisplay that corresponds to the X display DPY. */
64 xg_get_gdk_display (dpy
)
67 return gdk_x11_lookup_xdisplay (dpy
);
70 /* When the GTK widget W is to be created on a display for F that
71 is not the default display, set the display for W.
72 W can be a GtkMenu or a GtkWindow widget. */
79 if (FRAME_X_DISPLAY (f
) != GDK_DISPLAY ())
81 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
82 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
85 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
87 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
92 #else /* not HAVE_GTK_MULTIDISPLAY */
94 /* Make some defines so we can use the GTK 2.2 functions when
95 compiling with GTK 2.0. */
97 #define xg_set_screen(w, f)
98 #define gdk_xid_table_lookup_for_display(dpy, w) gdk_xid_table_lookup (w)
99 #define gdk_pixmap_foreign_new_for_display(dpy, p) gdk_pixmap_foreign_new (p)
100 #define gdk_cursor_new_for_display(dpy, c) gdk_cursor_new (c)
101 #define gdk_x11_lookup_xdisplay(dpy) 0
102 #define GdkDisplay void
104 #endif /* not HAVE_GTK_MULTIDISPLAY */
106 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
107 *DPY is set to NULL if the display can't be opened.
109 Returns non-zero if display could be opened, zero if display could not
110 be opened, and less than zero if the GTK version doesn't support
114 xg_display_open (display_name
, dpy
)
118 #ifdef HAVE_GTK_MULTIDISPLAY
121 gdpy
= gdk_display_open (display_name
);
122 if (!gdpy_def
&& gdpy
)
125 gdk_display_manager_set_default_display (gdk_display_manager_get (),
129 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
132 #else /* not HAVE_GTK_MULTIDISPLAY */
135 #endif /* not HAVE_GTK_MULTIDISPLAY */
139 /* Close display DPY. */
142 xg_display_close (Display
*dpy
)
144 #ifdef HAVE_GTK_MULTIDISPLAY
145 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
147 /* If this is the default display, try to change it before closing.
148 If there is no other display to use, gdpy_def is set to NULL, and
149 the next call to xg_display_open resets the default display. */
150 if (gdk_display_get_default () == gdpy
)
152 struct x_display_info
*dpyinfo
;
153 GdkDisplay
*gdpy_new
= NULL
;
155 /* Find another display. */
156 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
157 if (dpyinfo
->display
!= dpy
)
159 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
160 gdk_display_manager_set_default_display (gdk_display_manager_get (),
167 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
168 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
169 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
170 can continue running, but there will be memory leaks. */
171 g_object_run_dispose (G_OBJECT (gdpy
));
173 /* This seems to be fixed in GTK 2.10. */
174 gdk_display_close (gdpy
);
176 #endif /* HAVE_GTK_MULTIDISPLAY */
180 /***********************************************************************
182 ***********************************************************************/
183 /* The next two variables and functions are taken from lwlib. */
184 static widget_value
*widget_value_free_list
;
185 static int malloc_cpt
;
187 /* Allocate a widget_value structure, either by taking one from the
188 widget_value_free_list or by malloc:ing a new one.
190 Return a pointer to the allocated structure. */
193 malloc_widget_value ()
196 if (widget_value_free_list
)
198 wv
= widget_value_free_list
;
199 widget_value_free_list
= wv
->free_list
;
204 wv
= (widget_value
*) xmalloc (sizeof (widget_value
));
207 memset (wv
, 0, sizeof (widget_value
));
211 /* This is analogous to free. It frees only what was allocated
212 by malloc_widget_value, and no substructures. */
215 free_widget_value (wv
)
223 /* When the number of already allocated cells is too big,
230 wv
->free_list
= widget_value_free_list
;
231 widget_value_free_list
= wv
;
236 /* Create and return the cursor to be used for popup menus and
237 scroll bars on display DPY. */
240 xg_create_default_cursor (dpy
)
243 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
244 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
247 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
250 xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
)
255 int x
, y
, width
, height
, rowstride
, mask_rowstride
;
256 GdkPixbuf
*icon_buf
, *tmp_buf
;
260 gdk_drawable_get_size (gpix
, &width
, &height
);
261 tmp_buf
= gdk_pixbuf_get_from_drawable (NULL
, gpix
, cmap
,
262 0, 0, 0, 0, width
, height
);
263 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
264 g_object_unref (G_OBJECT (tmp_buf
));
268 GdkPixbuf
*mask_buf
= gdk_pixbuf_get_from_drawable (NULL
,
273 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
274 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
275 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
276 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
279 for (y
= 0; y
< height
; ++y
)
281 guchar
*iconptr
, *maskptr
;
284 iconptr
= pixels
+ y
* rowstride
;
285 maskptr
= mask_pixels
+ y
* mask_rowstride
;
287 for (x
= 0; x
< width
; ++x
)
289 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
290 just R is sufficient. */
292 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
294 iconptr
+= rowstride
/width
;
295 maskptr
+= mask_rowstride
/width
;
299 g_object_unref (G_OBJECT (mask_buf
));
306 file_for_image (image
)
309 Lisp_Object specified_file
= Qnil
;
311 extern Lisp_Object QCfile
;
313 for (tail
= XCDR (image
);
314 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
315 tail
= XCDR (XCDR (tail
)))
316 if (EQ (XCAR (tail
), QCfile
))
317 specified_file
= XCAR (XCDR (tail
));
319 return specified_file
;
322 /* For the image defined in IMG, make and return a GtkImage. For displays with
323 8 planes or less we must make a GdkPixbuf and apply the mask manually.
324 Otherwise the highlightning and dimming the tool bar code in GTK does
325 will look bad. For display with more than 8 planes we just use the
326 pixmap and mask directly. For monochrome displays, GTK doesn't seem
327 able to use external pixmaps, it looks bad whatever we do.
328 The image is defined on the display where frame F is.
329 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
330 If OLD_WIDGET is NULL, a new widget is constructed and returned.
331 If OLD_WIDGET is not NULL, that widget is modified. */
334 xg_get_image_for_pixmap (f
, img
, widget
, old_widget
)
338 GtkImage
*old_widget
;
346 /* If we have a file, let GTK do all the image handling.
347 This seems to be the only way to make insensitive and activated icons
348 look good in all cases. */
349 Lisp_Object specified_file
= file_for_image (img
->spec
);
352 /* We already loaded the image once before calling this
353 function, so this only fails if the image file has been removed.
354 In that case, use the pixmap already loaded. */
356 if (STRINGP (specified_file
)
357 && STRINGP (file
= x_find_image_file (specified_file
)))
360 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
362 gtk_image_set_from_file (old_widget
, SSDATA (file
));
364 return GTK_WIDGET (old_widget
);
367 /* No file, do the image handling ourselves. This will look very bad
368 on a monochrome display, and sometimes bad on all displays with
371 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
372 gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, img
->pixmap
);
373 gmask
= img
->mask
? gdk_pixmap_foreign_new_for_display (gdpy
, img
->mask
) : 0;
375 /* This is a workaround to make icons look good on pseudo color
376 displays. Apparently GTK expects the images to have an alpha
377 channel. If they don't, insensitive and activated icons will
378 look bad. This workaround does not work on monochrome displays,
379 and is strictly not needed on true color/static color displays (i.e.
380 16 bits and higher). But we do it anyway so we get a pixbuf that is
381 not associated with the img->pixmap. The img->pixmap may be removed
382 by clearing the image cache and then the tool bar redraw fails, since
383 Gtk+ assumes the pixmap is always there. */
384 cmap
= gtk_widget_get_colormap (widget
);
385 icon_buf
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, cmap
);
388 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
390 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
392 g_object_unref (G_OBJECT (icon_buf
));
394 g_object_unref (G_OBJECT (gpix
));
395 if (gmask
) g_object_unref (G_OBJECT (gmask
));
397 return GTK_WIDGET (old_widget
);
401 /* Set CURSOR on W and all widgets W contain. We must do like this
402 for scroll bars and menu because they create widgets internally,
403 and it is those widgets that are visible. */
406 xg_set_cursor (w
, cursor
)
410 GList
*children
= gdk_window_peek_children (w
->window
);
412 gdk_window_set_cursor (w
->window
, cursor
);
414 /* The scroll bar widget has more than one GDK window (had to look at
415 the source to figure this out), and there is no way to set cursor
416 on widgets in GTK. So we must set the cursor for all GDK windows.
419 for ( ; children
; children
= g_list_next (children
))
420 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
423 /* Insert NODE into linked LIST. */
426 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
428 xg_list_node
*list_start
= list
->next
;
430 if (list_start
) list_start
->prev
= node
;
431 node
->next
= list_start
;
436 /* Remove NODE from linked LIST. */
439 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
441 xg_list_node
*list_start
= list
->next
;
442 if (node
== list_start
)
444 list
->next
= node
->next
;
445 if (list
->next
) list
->next
->prev
= 0;
449 node
->prev
->next
= node
->next
;
450 if (node
->next
) node
->next
->prev
= node
->prev
;
454 /* Allocate and return a utf8 version of STR. If STR is already
455 utf8 or NULL, just return STR.
456 If not, a new string is allocated and the caller must free the result
460 get_utf8_string (str
)
463 char *utf8_str
= str
;
465 if (!str
) return NULL
;
467 /* If not UTF-8, try current locale. */
468 if (!g_utf8_validate (str
, -1, NULL
))
469 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
473 /* Probably some control characters in str. Escape them. */
477 unsigned char *p
= (unsigned char *)str
;
479 GError
*error
= NULL
;
481 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
482 &bytes_written
, &error
))
483 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
486 p
+= bytes_written
+1;
487 g_error_free (error
);
493 g_error_free (error
);
498 up
= utf8_str
= xmalloc (strlen (str
) + nr_bad
* 4 + 1);
499 p
= (unsigned char *)str
;
501 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
502 &bytes_written
, &error
))
503 && error
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
505 strncpy (up
, (char *)p
, bytes_written
);
506 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
507 up
[bytes_written
+4] = '\0';
508 up
+= bytes_written
+4;
509 p
+= bytes_written
+1;
510 g_error_free (error
);
516 strcat (utf8_str
, cp
);
521 g_error_free (error
);
530 /***********************************************************************
531 General functions for creating widgets, resizing, events, e.t.c.
532 ***********************************************************************/
534 /* Make a geometry string and pass that to GTK. It seems this is the
535 only way to get geometry position right if the user explicitly
536 asked for a position when starting Emacs.
537 F is the frame we shall set geometry for. */
543 if (f
->size_hint_flags
& USPosition
)
545 int left
= f
->left_pos
;
546 int xneg
= f
->size_hint_flags
& XNegative
;
547 int top
= f
->top_pos
;
548 int yneg
= f
->size_hint_flags
& YNegative
;
556 sprintf (geom_str
, "=%dx%d%c%d%c%d",
557 FRAME_PIXEL_WIDTH (f
),
558 FRAME_TOTAL_PIXEL_HEIGHT (f
),
559 (xneg
? '-' : '+'), left
,
560 (yneg
? '-' : '+'), top
);
562 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
564 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
566 else if (f
->size_hint_flags
& PPosition
)
567 gtk_window_move (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
568 f
->left_pos
, f
->top_pos
);
571 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
572 and use a GtkFixed widget, this doesn't happen automatically. */
575 xg_clear_under_internal_border (f
)
578 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
580 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
581 gtk_widget_queue_draw (wfixed
);
582 gdk_window_process_all_updates ();
583 x_clear_area (FRAME_X_DISPLAY (f
),
586 FRAME_PIXEL_WIDTH (f
),
587 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
588 x_clear_area (FRAME_X_DISPLAY (f
),
591 FRAME_INTERNAL_BORDER_WIDTH (f
),
592 FRAME_PIXEL_HEIGHT (f
), 0);
593 x_clear_area (FRAME_X_DISPLAY (f
),
595 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
596 FRAME_PIXEL_WIDTH (f
),
597 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
598 x_clear_area (FRAME_X_DISPLAY (f
),
600 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
602 FRAME_INTERNAL_BORDER_WIDTH (f
),
603 FRAME_PIXEL_HEIGHT (f
), 0);
607 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
608 and a Gtk+ menu bar, we get resize events for the edit part of the
609 frame only. We let Gtk+ deal with the Gtk+ parts.
610 F is the frame to resize.
611 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
614 xg_frame_resized (f
, pixelwidth
, pixelheight
)
616 int pixelwidth
, pixelheight
;
620 if (pixelwidth
== -1 && pixelheight
== -1)
622 if (FRAME_GTK_WIDGET (f
) && GTK_WIDGET_MAPPED (FRAME_GTK_WIDGET (f
)))
623 gdk_window_get_geometry (FRAME_GTK_WIDGET (f
)->window
, 0, 0,
624 &pixelwidth
, &pixelheight
, 0);
629 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
630 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
632 if (columns
!= FRAME_COLS (f
)
633 || rows
!= FRAME_LINES (f
)
634 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
635 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
637 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
638 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
640 xg_clear_under_internal_border (f
);
641 change_frame_size (f
, rows
, columns
, 0, 1, 0);
642 SET_FRAME_GARBAGED (f
);
643 cancel_mouse_face (f
);
647 /* Resize the outer window of frame F after chainging the height.
648 COLUMNS/ROWS is the size the edit area shall have after the resize. */
651 xg_frame_set_char_size (f
, cols
, rows
)
656 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
657 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
660 if (FRAME_PIXEL_HEIGHT (f
) == 0)
663 /* Take into account the size of the scroll bar. Always use the
664 number of columns occupied by the scroll bar here otherwise we
665 might end up with a frame width that is not a multiple of the
666 frame's character width which is bad for vertically split
668 f
->scroll_bar_actual_width
669 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
671 compute_fringe_widths (f
, 0);
673 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
674 after calculating that value. */
675 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
678 /* Do this before resize, as we don't know yet if we will be resized. */
679 xg_clear_under_internal_border (f
);
681 /* Must resize our top level widget. Font size may have changed,
682 but not rows/cols. */
683 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
684 pixelwidth
, pixelheight
);
685 x_wm_set_size_hint (f
, 0, 0);
687 SET_FRAME_GARBAGED (f
);
688 cancel_mouse_face (f
);
690 /* We can not call change_frame_size for a mapped frame,
691 we can not set pixel width/height either. The window manager may
692 override our resize request, XMonad does this all the time.
693 The best we can do is try to sync, so lisp code sees the updated
694 size as fast as possible.
695 For unmapped windows, we can set rows/cols. When
696 the frame is mapped again we will (hopefully) get the correct size. */
697 if (f
->async_visible
)
699 /* Must call this to flush out events */
700 (void)gtk_events_pending ();
702 x_wait_for_event (f
, ConfigureNotify
);
706 change_frame_size (f
, rows
, cols
, 0, 1, 0);
707 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
708 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
712 /* Handle height changes (i.e. add/remove menu/toolbar).
713 The policy is to keep the number of editable lines. */
716 xg_height_changed (f
)
719 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
720 FRAME_PIXEL_WIDTH (f
), FRAME_TOTAL_PIXEL_HEIGHT (f
));
721 f
->output_data
.x
->hint_flags
= 0;
722 x_wm_set_size_hint (f
, 0, 0);
725 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
726 Must be done like this, because GtkWidget:s can have "hidden"
727 X Window that aren't accessible.
729 Return 0 if no widget match WDESC. */
732 xg_win_to_widget (dpy
, wdesc
)
737 GtkWidget
*gwdesc
= 0;
741 gdkwin
= gdk_xid_table_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
746 event
.any
.window
= gdkwin
;
747 gwdesc
= gtk_get_event_widget (&event
);
754 /* Fill in the GdkColor C so that it represents PIXEL.
755 W is the widget that color will be used for. Used to find colormap. */
758 xg_pix_to_gcolor (w
, pixel
, c
)
763 GdkColormap
*map
= gtk_widget_get_colormap (w
);
764 gdk_colormap_query_color (map
, pixel
, c
);
767 /* Create and set up the GTK widgets for frame F.
768 Return 0 if creation failed, non-zero otherwise. */
771 xg_create_frame_widgets (f
)
784 if (FRAME_X_EMBEDDED_P (f
))
785 wtop
= gtk_plug_new (f
->output_data
.x
->parent_desc
);
787 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
789 xg_set_screen (wtop
, f
);
791 wvbox
= gtk_vbox_new (FALSE
, 0);
792 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
794 if (! wtop
|| ! wvbox
|| ! wfixed
)
796 if (wtop
) gtk_widget_destroy (wtop
);
797 if (wvbox
) gtk_widget_destroy (wvbox
);
798 if (wfixed
) gtk_widget_destroy (wfixed
);
804 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
805 gtk_widget_set_name (wtop
, EMACS_CLASS
);
806 gtk_widget_set_name (wvbox
, "pane");
807 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
809 /* If this frame has a title or name, set it in the title bar. */
810 if (! NILP (f
->title
)) title
= SSDATA (ENCODE_UTF_8 (f
->title
));
811 else if (! NILP (f
->name
)) title
= SSDATA (ENCODE_UTF_8 (f
->name
));
813 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
815 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
816 FRAME_GTK_WIDGET (f
) = wfixed
;
817 f
->output_data
.x
->vbox_widget
= wvbox
;
819 gtk_fixed_set_has_window (GTK_FIXED (wfixed
), TRUE
);
821 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
822 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
824 if (FRAME_EXTERNAL_TOOL_BAR (f
))
825 update_frame_tool_bar (f
);
827 /* We don't want this widget double buffered, because we draw on it
828 with regular X drawing primitives, so from a GTK/GDK point of
829 view, the widget is totally blank. When an expose comes, this
830 will make the widget blank, and then Emacs redraws it. This flickers
831 a lot, so we turn off double buffering. */
832 gtk_widget_set_double_buffered (wfixed
, FALSE
);
834 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
835 SSDATA (Vx_resource_name
),
836 SSDATA (Vx_resource_class
));
838 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
839 GTK is to destroy the widget. We want Emacs to do that instead. */
840 g_signal_connect (G_OBJECT (wtop
), "delete-event",
841 G_CALLBACK (gtk_true
), 0);
843 /* Convert our geometry parameters into a geometry string
845 GTK will itself handle calculating the real position this way. */
847 int grav
= gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
848 f
->win_gravity
= grav
;
850 gtk_widget_add_events (wfixed
,
851 GDK_POINTER_MOTION_MASK
853 | GDK_BUTTON_PRESS_MASK
854 | GDK_BUTTON_RELEASE_MASK
856 | GDK_ENTER_NOTIFY_MASK
857 | GDK_LEAVE_NOTIFY_MASK
858 | GDK_FOCUS_CHANGE_MASK
860 | GDK_VISIBILITY_NOTIFY_MASK
);
862 /* Must realize the windows so the X window gets created. It is used
863 by callers of this function. */
864 gtk_widget_realize (wfixed
);
865 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
867 /* Since GTK clears its window by filling with the background color,
868 we must keep X and GTK background in sync. */
869 xg_pix_to_gcolor (wfixed
, FRAME_BACKGROUND_PIXEL (f
), &bg
);
870 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
872 /* Also, do not let any background pixmap to be set, this looks very
873 bad as Emacs overwrites the background pixmap with its own idea
874 of background color. */
875 style
= gtk_widget_get_modifier_style (wfixed
);
877 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
878 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
879 gtk_widget_modify_style (wfixed
, style
);
881 /* GTK does not set any border, and they look bad with GTK. */
882 /* That they look bad is no excuse for imposing this here. --Stef
883 It should be done by providing the proper default in Fx_create_Frame.
885 f->internal_border_width = 0; */
892 /* Set the normal size hints for the window manager, for frame F.
893 FLAGS is the flags word to use--or 0 meaning preserve the flags
894 that the window now has.
895 If USER_POSITION is nonzero, we set the User Position
896 flag (this is useful when FLAGS is 0). */
899 x_wm_set_size_hint (f
, flags
, user_position
)
904 /* Don't set size hints during initialization; that apparently leads
905 to a race condition. See the thread at
906 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
907 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
910 /* Must use GTK routines here, otherwise GTK resets the size hints
911 to its own defaults. */
912 GdkGeometry size_hints
;
914 int base_width
, base_height
;
915 int min_rows
= 0, min_cols
= 0;
916 int win_gravity
= f
->win_gravity
;
920 memset (&size_hints
, 0, sizeof (size_hints
));
921 f
->output_data
.x
->size_hints
= size_hints
;
922 f
->output_data
.x
->hint_flags
= hint_flags
;
925 flags
= f
->size_hint_flags
;
927 size_hints
= f
->output_data
.x
->size_hints
;
928 hint_flags
= f
->output_data
.x
->hint_flags
;
930 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
931 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
932 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
934 hint_flags
|= GDK_HINT_BASE_SIZE
;
935 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
936 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0)
937 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
939 check_frame_size (f
, &min_rows
, &min_cols
);
941 size_hints
.base_width
= base_width
;
942 size_hints
.base_height
= base_height
;
943 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
944 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
946 /* These currently have a one to one mapping with the X values, but I
947 don't think we should rely on that. */
948 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
949 size_hints
.win_gravity
= 0;
950 if (win_gravity
== NorthWestGravity
)
951 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
952 else if (win_gravity
== NorthGravity
)
953 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
954 else if (win_gravity
== NorthEastGravity
)
955 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
956 else if (win_gravity
== WestGravity
)
957 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
958 else if (win_gravity
== CenterGravity
)
959 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
960 else if (win_gravity
== EastGravity
)
961 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
962 else if (win_gravity
== SouthWestGravity
)
963 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
964 else if (win_gravity
== SouthGravity
)
965 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
966 else if (win_gravity
== SouthEastGravity
)
967 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
968 else if (win_gravity
== StaticGravity
)
969 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
971 if (flags
& PPosition
) hint_flags
|= GDK_HINT_POS
;
972 if (flags
& USPosition
) hint_flags
|= GDK_HINT_USER_POS
;
973 if (flags
& USSize
) hint_flags
|= GDK_HINT_USER_SIZE
;
977 hint_flags
&= ~GDK_HINT_POS
;
978 hint_flags
|= GDK_HINT_USER_POS
;
981 if (hint_flags
!= f
->output_data
.x
->hint_flags
982 || memcmp (&size_hints
,
983 &f
->output_data
.x
->size_hints
,
984 sizeof (size_hints
)) != 0)
987 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
988 NULL
, &size_hints
, hint_flags
);
989 f
->output_data
.x
->size_hints
= size_hints
;
990 f
->output_data
.x
->hint_flags
= hint_flags
;
995 /* Change background color of a frame.
996 Since GTK uses the background color to clear the window, we must
997 keep the GTK and X colors in sync.
998 F is the frame to change,
999 BG is the pixel value to change to. */
1002 xg_set_background_color (f
, bg
)
1006 if (FRAME_GTK_WIDGET (f
))
1011 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
1012 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
1018 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1019 functions so GTK does not overwrite the icon. */
1022 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
)
1027 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1028 GdkPixmap
*gpix
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_pixmap
);
1029 GdkPixmap
*gmask
= gdk_pixmap_foreign_new_for_display (gdpy
, icon_mask
);
1030 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (gpix
, gmask
, NULL
);
1032 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1037 /***********************************************************************
1039 ***********************************************************************/
1040 /* Return the dialog title to use for a dialog of type KEY.
1041 This is the encoding used by lwlib. We use the same for GTK. */
1044 get_dialog_title (char key
)
1054 title
= "Information";
1073 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1074 the dialog, but return TRUE so the event does not propagate further
1075 in GTK. This prevents GTK from destroying the dialog widget automatically
1076 and we can always destrou the widget manually, regardles of how
1077 it was popped down (button press or WM_DELETE_WINDOW).
1078 W is the dialog widget.
1079 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1080 user_data is NULL (not used).
1082 Returns TRUE to end propagation of event. */
1085 dialog_delete_callback (w
, event
, user_data
)
1090 gtk_widget_unmap (w
);
1094 /* Create a popup dialog window. See also xg_create_widget below.
1095 WV is a widget_value describing the dialog.
1096 SELECT_CB is the callback to use when a button has been pressed.
1097 DEACTIVATE_CB is the callback to use when the dialog pops down.
1099 Returns the GTK dialog widget. */
1102 create_dialog (wv
, select_cb
, deactivate_cb
)
1104 GCallback select_cb
;
1105 GCallback deactivate_cb
;
1107 char *title
= get_dialog_title (wv
->name
[0]);
1108 int total_buttons
= wv
->name
[1] - '0';
1109 int right_buttons
= wv
->name
[4] - '0';
1112 int button_spacing
= 10;
1113 GtkWidget
*wdialog
= gtk_dialog_new ();
1117 GtkWidget
*whbox_up
;
1118 GtkWidget
*whbox_down
;
1120 /* If the number of buttons is greater than 4, make two rows of buttons
1121 instead. This looks better. */
1122 int make_two_rows
= total_buttons
> 4;
1124 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1125 left_buttons
= total_buttons
- right_buttons
;
1127 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1128 gtk_widget_set_name (wdialog
, "emacs-dialog");
1130 cur_box
= GTK_BOX (GTK_DIALOG (wdialog
)->action_area
);
1134 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
1135 whbox_up
= gtk_hbox_new (FALSE
, 0);
1136 whbox_down
= gtk_hbox_new (FALSE
, 0);
1138 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1139 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1140 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1142 cur_box
= GTK_BOX (whbox_up
);
1145 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1146 G_CALLBACK (dialog_delete_callback
), 0);
1150 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1151 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1154 for (item
= wv
->contents
; item
; item
= item
->next
)
1156 char *utf8_label
= get_utf8_string (item
->value
);
1160 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1162 /* This is the text part of the dialog. */
1163 w
= gtk_label_new (utf8_label
);
1164 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1167 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
), w
,
1169 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1171 /* Try to make dialog look better. Must realize first so
1172 the widget can calculate the size it needs. */
1173 gtk_widget_realize (w
);
1174 gtk_widget_size_request (w
, &req
);
1175 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
1177 if (item
->value
&& strlen (item
->value
) > 0)
1178 button_spacing
= 2*req
.width
/strlen (item
->value
);
1182 /* This is one button to add to the dialog. */
1183 w
= gtk_button_new_with_label (utf8_label
);
1184 if (! item
->enabled
)
1185 gtk_widget_set_sensitive (w
, FALSE
);
1187 g_signal_connect (G_OBJECT (w
), "clicked",
1188 select_cb
, item
->call_data
);
1190 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1191 if (++button_nr
== left_buttons
)
1194 cur_box
= GTK_BOX (whbox_down
);
1196 gtk_box_pack_start (cur_box
,
1203 if (utf8_label
&& utf8_label
!= item
->value
)
1204 g_free (utf8_label
);
1210 struct xg_dialog_data
1218 /* Function that is called when the file or font dialogs pop down.
1219 W is the dialog widget, RESPONSE is the response code.
1220 USER_DATA is what we passed in to g_signal_connect. */
1223 xg_dialog_response_cb (w
,
1230 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1231 dd
->response
= response
;
1232 g_main_loop_quit (dd
->loop
);
1236 /* Destroy the dialog. This makes it pop down. */
1239 pop_down_dialog (arg
)
1242 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1243 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1246 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1247 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1249 g_main_loop_quit (dd
->loop
);
1250 g_main_loop_unref (dd
->loop
);
1257 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1258 We pass in DATA as gpointer* so we can use this as a callback. */
1261 xg_maybe_add_timer (data
)
1264 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1265 EMACS_TIME next_time
= timer_check (1);
1266 long secs
= EMACS_SECS (next_time
);
1267 long usecs
= EMACS_USECS (next_time
);
1271 if (secs
>= 0 && usecs
>= 0 && secs
< ((guint
)-1)/1000)
1273 dd
->timerid
= g_timeout_add (secs
* 1000 + usecs
/1000,
1281 /* Pops up a modal dialog W and waits for response.
1282 We don't use gtk_dialog_run because we want to process emacs timers.
1283 The dialog W is not destroyed when this function returns. */
1286 xg_dialog_run (f
, w
)
1291 int count
= SPECPDL_INDEX ();
1292 struct xg_dialog_data dd
;
1294 xg_set_screen (w
, f
);
1295 gtk_window_set_transient_for (GTK_WINDOW (w
),
1296 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1297 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1298 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1300 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1301 dd
.response
= GTK_RESPONSE_CANCEL
;
1305 g_signal_connect (G_OBJECT (w
),
1307 G_CALLBACK (xg_dialog_response_cb
),
1309 /* Don't destroy the widget if closed by the window manager close button. */
1310 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1311 gtk_widget_show (w
);
1313 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1315 (void) xg_maybe_add_timer (&dd
);
1316 g_main_loop_run (dd
.loop
);
1319 unbind_to (count
, Qnil
);
1325 /***********************************************************************
1326 File dialog functions
1327 ***********************************************************************/
1328 /* Return non-zero if the old file selection dialog is being used.
1329 Return zero if not. */
1332 xg_uses_old_file_dialog ()
1334 #ifdef HAVE_GTK_FILE_BOTH
1335 extern int x_gtk_use_old_file_dialog
;
1336 return x_gtk_use_old_file_dialog
;
1337 #else /* ! HAVE_GTK_FILE_BOTH */
1339 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1345 #endif /* ! HAVE_GTK_FILE_BOTH */
1349 typedef char * (*xg_get_file_func
) P_ ((GtkWidget
*));
1351 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1353 /* Return the selected file for file chooser dialog W.
1354 The returned string must be free:d. */
1357 xg_get_file_name_from_chooser (w
)
1360 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1363 /* Callback called when the "Show hidden files" toggle is pressed.
1364 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1367 xg_toggle_visibility_cb (widget
, data
)
1371 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1373 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1374 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1378 /* Callback called when a property changes in a file chooser.
1379 GOBJECT is the file chooser dialog, ARG1 describes the property.
1380 USER_DATA is the toggle widget in the file chooser dialog.
1381 We use this to update the "Show hidden files" toggle when the user
1382 changes that property by right clicking in the file list. */
1385 xg_toggle_notify_cb (gobject
, arg1
, user_data
)
1390 extern int x_gtk_show_hidden_files
;
1392 if (strcmp (arg1
->name
, "show-hidden") == 0)
1394 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (gobject
);
1395 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1396 gboolean visible
, toggle_on
;
1398 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1399 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1401 if (!!visible
!= !!toggle_on
)
1403 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1404 G_CALLBACK (xg_toggle_visibility_cb
),
1406 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1407 g_signal_handlers_unblock_by_func
1408 (G_OBJECT (wtoggle
),
1409 G_CALLBACK (xg_toggle_visibility_cb
),
1412 x_gtk_show_hidden_files
= visible
;
1416 /* Read a file name from the user using a file chooser dialog.
1417 F is the current frame.
1418 PROMPT is a prompt to show to the user. May not be NULL.
1419 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1420 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1421 file. *FUNC is set to a function that can be used to retrieve the
1422 selected file name from the returned widget.
1424 Returns the created widget. */
1427 xg_get_file_with_chooser (f
, prompt
, default_filename
,
1428 mustmatch_p
, only_dir_p
, func
)
1431 char *default_filename
;
1432 int mustmatch_p
, only_dir_p
;
1433 xg_get_file_func
*func
;
1437 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
;
1438 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1439 GtkFileChooserAction action
= (mustmatch_p
?
1440 GTK_FILE_CHOOSER_ACTION_OPEN
:
1441 GTK_FILE_CHOOSER_ACTION_SAVE
);
1442 extern int x_gtk_show_hidden_files
;
1443 extern int x_gtk_file_dialog_help_text
;
1447 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1449 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1450 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1451 (mustmatch_p
|| only_dir_p
?
1452 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1455 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1457 wbox
= gtk_vbox_new (FALSE
, 0);
1458 gtk_widget_show (wbox
);
1459 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1461 if (x_gtk_show_hidden_files
)
1463 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1464 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1466 gtk_widget_show (wtoggle
);
1467 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1468 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1469 g_signal_connect (G_OBJECT (filewin
), "notify",
1470 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1472 if (x_gtk_file_dialog_help_text
)
1475 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1476 Show the C-l help text only for versions < 2.10. */
1477 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1478 strcat (message
, "\nType C-l to display a file name text entry box.\n");
1479 strcat (message
, "\nIf you don't like this file selector, use the "
1480 "corresponding\nkey binding or customize "
1481 "use-file-dialog to turn it off.");
1483 wmessage
= gtk_label_new (message
);
1484 gtk_widget_show (wmessage
);
1487 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1488 if (x_gtk_file_dialog_help_text
)
1489 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1490 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1492 if (default_filename
)
1495 struct gcpro gcpro1
;
1496 char *utf8_filename
;
1499 file
= build_string (default_filename
);
1501 /* File chooser does not understand ~/... in the file name. It must be
1502 an absolute name starting with /. */
1503 if (default_filename
[0] != '/')
1504 file
= Fexpand_file_name (file
, Qnil
);
1506 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1507 if (! NILP (Ffile_directory_p (file
)))
1508 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1512 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1514 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1516 char *cp
= strrchr (utf8_filename
, '/');
1518 else cp
= utf8_filename
;
1519 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1526 *func
= xg_get_file_name_from_chooser
;
1529 #endif /* HAVE_GTK_FILE_CHOOSER_DIALOG_NEW */
1531 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1533 /* Return the selected file for file selector dialog W.
1534 The returned string must be free:d. */
1537 xg_get_file_name_from_selector (w
)
1540 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1541 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1544 /* Create a file selection dialog.
1545 F is the current frame.
1546 PROMPT is a prompt to show to the user. May not be NULL.
1547 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1548 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1549 file. *FUNC is set to a function that can be used to retrieve the
1550 selected file name from the returned widget.
1552 Returns the created widget. */
1555 xg_get_file_with_selection (f
, prompt
, default_filename
,
1556 mustmatch_p
, only_dir_p
, func
)
1559 char *default_filename
;
1560 int mustmatch_p
, only_dir_p
;
1561 xg_get_file_func
*func
;
1564 GtkFileSelection
*filesel
;
1566 filewin
= gtk_file_selection_new (prompt
);
1567 filesel
= GTK_FILE_SELECTION (filewin
);
1569 if (default_filename
)
1570 gtk_file_selection_set_filename (filesel
, default_filename
);
1574 /* The selection_entry part of filesel is not documented. */
1575 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1576 gtk_file_selection_hide_fileop_buttons (filesel
);
1579 *func
= xg_get_file_name_from_selector
;
1583 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1585 /* Read a file name from the user using a file dialog, either the old
1586 file selection dialog, or the new file chooser dialog. Which to use
1587 depends on what the GTK version used has, and what the value of
1588 gtk-use-old-file-dialog.
1589 F is the current frame.
1590 PROMPT is a prompt to show to the user. May not be NULL.
1591 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1592 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1595 Returns a file name or NULL if no file was selected.
1596 The returned string must be freed by the caller. */
1599 xg_get_file_name (f
, prompt
, default_filename
, mustmatch_p
, only_dir_p
)
1602 char *default_filename
;
1603 int mustmatch_p
, only_dir_p
;
1607 int filesel_done
= 0;
1608 xg_get_file_func func
;
1610 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1611 /* I really don't know why this is needed, but without this the GLIBC add on
1612 library linuxthreads hangs when the Gnome file chooser backend creates
1614 sigblock (sigmask (__SIGRTMIN
));
1615 #endif /* HAVE_GTK_AND_PTHREAD */
1617 #ifdef HAVE_GTK_FILE_BOTH
1619 if (xg_uses_old_file_dialog ())
1620 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1621 mustmatch_p
, only_dir_p
, &func
);
1623 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1624 mustmatch_p
, only_dir_p
, &func
);
1626 #else /* not HAVE_GTK_FILE_BOTH */
1628 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1629 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1630 mustmatch_p
, only_dir_p
, &func
);
1632 #ifdef HAVE_GTK_FILE_CHOOSER_DIALOG_NEW
1633 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1634 mustmatch_p
, only_dir_p
, &func
);
1637 #endif /* HAVE_GTK_FILE_BOTH */
1639 gtk_widget_set_name (w
, "emacs-filedialog");
1641 filesel_done
= xg_dialog_run (f
, w
);
1643 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1644 sigunblock (sigmask (__SIGRTMIN
));
1647 if (filesel_done
== GTK_RESPONSE_OK
)
1650 gtk_widget_destroy (w
);
1654 #ifdef HAVE_FREETYPE
1655 /* Pop up a GTK font selector and return the name of the font the user
1656 selects, as a C string. The returned font name follows GTK's own
1659 `FAMILY [VALUE1 VALUE2] SIZE'
1661 This can be parsed using font_parse_fcname in font.c.
1662 DEFAULT_NAME, if non-zero, is the default font name. */
1665 xg_get_font_name (f
, default_name
)
1670 char *fontname
= NULL
;
1673 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1674 sigblock (sigmask (__SIGRTMIN
));
1675 #endif /* HAVE_GTK_AND_PTHREAD */
1677 w
= gtk_font_selection_dialog_new ("Pick a font");
1679 default_name
= "Monospace 10";
1680 gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w
),
1683 gtk_widget_set_name (w
, "emacs-fontdialog");
1685 done
= xg_dialog_run (f
, w
);
1687 #if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
1688 sigunblock (sigmask (__SIGRTMIN
));
1691 if (done
== GTK_RESPONSE_OK
)
1692 fontname
= gtk_font_selection_dialog_get_font_name
1693 (GTK_FONT_SELECTION_DIALOG (w
));
1695 gtk_widget_destroy (w
);
1698 #endif /* HAVE_FREETYPE */
1702 /***********************************************************************
1704 ***********************************************************************/
1706 /* The name of menu items that can be used for customization. Since GTK
1707 RC files are very crude and primitive, we have to set this on all
1708 menu item names so a user can easily customize menu items. */
1710 #define MENU_ITEM_NAME "emacs-menuitem"
1713 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
1714 during GC. The next member points to the items. */
1715 static xg_list_node xg_menu_cb_list
;
1717 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
1718 during GC. The next member points to the items. */
1719 static xg_list_node xg_menu_item_cb_list
;
1721 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
1722 F is the frame CL_DATA will be initialized for.
1723 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1725 The menu bar and all sub menus under the menu bar in a frame
1726 share the same structure, hence the reference count.
1728 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
1729 allocated xg_menu_cb_data if CL_DATA is NULL. */
1731 static xg_menu_cb_data
*
1732 make_cl_data (cl_data
, f
, highlight_cb
)
1733 xg_menu_cb_data
*cl_data
;
1735 GCallback highlight_cb
;
1739 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
1741 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1742 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1743 cl_data
->highlight_cb
= highlight_cb
;
1744 cl_data
->ref_count
= 0;
1746 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
1749 cl_data
->ref_count
++;
1754 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
1755 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1757 When the menu bar is updated, menu items may have been added and/or
1758 removed, so menu_bar_vector and menu_bar_items_used change. We must
1759 then update CL_DATA since it is used to determine which menu
1760 item that is invoked in the menu.
1761 HIGHLIGHT_CB could change, there is no check that the same
1762 function is given when modifying a menu bar as was given when
1763 creating the menu bar. */
1766 update_cl_data (cl_data
, f
, highlight_cb
)
1767 xg_menu_cb_data
*cl_data
;
1769 GCallback highlight_cb
;
1774 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
1775 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1776 cl_data
->highlight_cb
= highlight_cb
;
1780 /* Decrease reference count for CL_DATA.
1781 If reference count is zero, free CL_DATA. */
1784 unref_cl_data (cl_data
)
1785 xg_menu_cb_data
*cl_data
;
1787 if (cl_data
&& cl_data
->ref_count
> 0)
1789 cl_data
->ref_count
--;
1790 if (cl_data
->ref_count
== 0)
1792 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1798 /* Function that marks all lisp data during GC. */
1805 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1806 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1808 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1810 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1812 if (! NILP (cb_data
->help
))
1813 mark_object (cb_data
->help
);
1818 /* Callback called when a menu item is destroyed. Used to free data.
1819 W is the widget that is being destroyed (not used).
1820 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1823 menuitem_destroy_callback (w
, client_data
)
1825 gpointer client_data
;
1829 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1830 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1835 /* Callback called when the pointer enters/leaves a menu item.
1836 W is the parent of the menu item.
1837 EVENT is either an enter event or leave event.
1838 CLIENT_DATA is not used.
1840 Returns FALSE to tell GTK to keep processing this event. */
1843 menuitem_highlight_callback (w
, event
, client_data
)
1845 GdkEventCrossing
*event
;
1846 gpointer client_data
;
1849 GtkWidget
*subwidget
;
1850 xg_menu_item_cb_data
*data
;
1852 ev
.crossing
= *event
;
1853 subwidget
= gtk_get_event_widget (&ev
);
1854 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
1858 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1860 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
1861 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1862 (*func
) (subwidget
, call_data
);
1869 /* Callback called when a menu is destroyed. Used to free data.
1870 W is the widget that is being destroyed (not used).
1871 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1874 menu_destroy_callback (w
, client_data
)
1876 gpointer client_data
;
1878 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1881 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1882 must be non-NULL) and can be inserted into a menu item.
1884 Returns the GtkHBox. */
1887 make_widget_for_menu_item (utf8_label
, utf8_key
)
1895 wbox
= gtk_hbox_new (FALSE
, 0);
1896 wlbl
= gtk_label_new (utf8_label
);
1897 wkey
= gtk_label_new (utf8_key
);
1899 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1900 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1902 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1903 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1905 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1906 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1907 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
1912 /* Make and return a menu item widget with the key to the right.
1913 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1914 UTF8_KEY is the text representing the key binding.
1915 ITEM is the widget_value describing the menu item.
1917 GROUP is an in/out parameter. If the menu item to be created is not
1918 part of any radio menu group, *GROUP contains NULL on entry and exit.
1919 If the menu item to be created is part of a radio menu group, on entry
1920 *GROUP contains the group to use, or NULL if this is the first item
1921 in the group. On exit, *GROUP contains the radio item group.
1923 Unfortunately, keys don't line up as nicely as in Motif,
1924 but the MacOS X version doesn't either, so I guess that is OK. */
1927 make_menu_item (utf8_label
, utf8_key
, item
, group
)
1934 GtkWidget
*wtoadd
= 0;
1936 /* It has been observed that some menu items have a NULL name field.
1937 This will lead to this function being called with a NULL utf8_label.
1938 GTK crashes on that so we set a blank label. Why there is a NULL
1939 name remains to be investigated. */
1940 if (! utf8_label
) utf8_label
= " ";
1943 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1945 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1948 if (utf8_key
) w
= gtk_check_menu_item_new ();
1949 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
1950 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1952 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1954 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1955 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
1956 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1958 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1963 if (utf8_key
) w
= gtk_menu_item_new ();
1964 else w
= gtk_menu_item_new_with_label (utf8_label
);
1967 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1968 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1973 /* Return non-zero if LABEL specifies a separator (GTK only has one
1976 static const char* separator_names
[] = {
1981 "single-dashed-line",
1982 "double-dashed-line",
1984 "shadow-etched-out",
1985 "shadow-etched-in-dash",
1986 "shadow-etched-out-dash",
1987 "shadow-double-etched-in",
1988 "shadow-double-etched-out",
1989 "shadow-double-etched-in-dash",
1990 "shadow-double-etched-out-dash",
1995 xg_separator_p (char *label
)
1997 if (! label
) return 0;
1998 else if (strlen (label
) > 3
1999 && strncmp (label
, "--", 2) == 0
2005 for (i
= 0; separator_names
[i
]; ++i
)
2006 if (strcmp (label
, separator_names
[i
]) == 0)
2011 /* Old-style separator, maybe. It's a separator if it contains
2013 while (*label
== '-')
2015 if (*label
== 0) return 1;
2021 static int xg_detached_menus
;
2023 /* Returns non-zero if there are detached menus. */
2026 xg_have_tear_offs ()
2028 return xg_detached_menus
> 0;
2031 /* Callback invoked when a detached menu window is removed. Here we
2032 decrease the xg_detached_menus count.
2033 WIDGET is the top level window that is removed (the parent of the menu).
2034 CLIENT_DATA is not used. */
2037 tearoff_remove (widget
, client_data
)
2039 gpointer client_data
;
2041 if (xg_detached_menus
> 0) --xg_detached_menus
;
2044 /* Callback invoked when a menu is detached. It increases the
2045 xg_detached_menus count.
2046 WIDGET is the GtkTearoffMenuItem.
2047 CLIENT_DATA is not used. */
2050 tearoff_activate (widget
, client_data
)
2052 gpointer client_data
;
2054 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2055 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2057 ++xg_detached_menus
;
2058 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2060 G_CALLBACK (tearoff_remove
), 0);
2065 /* Create a menu item widget, and connect the callbacks.
2066 ITEM decribes the menu item.
2067 F is the frame the created menu belongs to.
2068 SELECT_CB is the callback to use when a menu item is selected.
2069 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2070 CL_DATA points to the callback data to be used for this menu.
2071 GROUP is an in/out parameter. If the menu item to be created is not
2072 part of any radio menu group, *GROUP contains NULL on entry and exit.
2073 If the menu item to be created is part of a radio menu group, on entry
2074 *GROUP contains the group to use, or NULL if this is the first item
2075 in the group. On exit, *GROUP contains the radio item group.
2077 Returns the created GtkWidget. */
2080 xg_create_one_menuitem (item
, f
, select_cb
, highlight_cb
, cl_data
, group
)
2083 GCallback select_cb
;
2084 GCallback highlight_cb
;
2085 xg_menu_cb_data
*cl_data
;
2091 xg_menu_item_cb_data
*cb_data
;
2093 utf8_label
= get_utf8_string (item
->name
);
2094 utf8_key
= get_utf8_string (item
->key
);
2096 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2098 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2099 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
2101 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
2103 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2105 cb_data
->select_id
= 0;
2106 cb_data
->help
= item
->help
;
2107 cb_data
->cl_data
= cl_data
;
2108 cb_data
->call_data
= item
->call_data
;
2110 g_signal_connect (G_OBJECT (w
),
2112 G_CALLBACK (menuitem_destroy_callback
),
2115 /* Put cb_data in widget, so we can get at it when modifying menubar */
2116 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2118 /* final item, not a submenu */
2119 if (item
->call_data
&& ! item
->contents
)
2123 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2129 static GtkWidget
*create_menus
P_ ((widget_value
*, FRAME_PTR
, GCallback
,
2130 GCallback
, GCallback
, int, int, int,
2131 GtkWidget
*, xg_menu_cb_data
*, char *));
2133 /* Create a full menu tree specified by DATA.
2134 F is the frame the created menu belongs to.
2135 SELECT_CB is the callback to use when a menu item is selected.
2136 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2137 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2138 POP_UP_P is non-zero if we shall create a popup menu.
2139 MENU_BAR_P is non-zero if we shall create a menu bar.
2140 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
2141 if MENU_BAR_P is non-zero.
2142 TOPMENU is the topmost GtkWidget that others shall be placed under.
2143 It may be NULL, in that case we create the appropriate widget
2144 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2145 CL_DATA is the callback data we shall use for this menu, or NULL
2146 if we haven't set the first callback yet.
2147 NAME is the name to give to the top level menu if this function
2148 creates it. May be NULL to not set any name.
2150 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2153 This function calls itself to create submenus. */
2156 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2157 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
2160 GCallback select_cb
;
2161 GCallback deactivate_cb
;
2162 GCallback highlight_cb
;
2167 xg_menu_cb_data
*cl_data
;
2171 GtkWidget
*wmenu
= topmenu
;
2172 GSList
*group
= NULL
;
2178 wmenu
= gtk_menu_new ();
2179 xg_set_screen (wmenu
, f
);
2180 /* Connect this to the menu instead of items so we get enter/leave for
2181 disabled items also. TODO: Still does not get enter/leave for
2182 disabled items in detached menus. */
2183 g_signal_connect (G_OBJECT (wmenu
),
2184 "enter-notify-event",
2185 G_CALLBACK (menuitem_highlight_callback
),
2187 g_signal_connect (G_OBJECT (wmenu
),
2188 "leave-notify-event",
2189 G_CALLBACK (menuitem_highlight_callback
),
2194 wmenu
= gtk_menu_bar_new ();
2195 /* Set width of menu bar to a small value so it doesn't enlarge
2196 a small initial frame size. The width will be set to the
2197 width of the frame later on when it is added to a container.
2198 height -1: Natural height. */
2199 gtk_widget_set_size_request (wmenu
, 1, -1);
2202 /* Put cl_data on the top menu for easier access. */
2203 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2204 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2205 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2206 G_CALLBACK (menu_destroy_callback
), cl_data
);
2209 gtk_widget_set_name (wmenu
, name
);
2212 g_signal_connect (G_OBJECT (wmenu
),
2213 "selection-done", deactivate_cb
, 0);
2216 if (! menu_bar_p
&& add_tearoff_p
)
2218 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2219 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2221 g_signal_connect (G_OBJECT (tearoff
), "activate",
2222 G_CALLBACK (tearoff_activate
), 0);
2225 for (item
= data
; item
; item
= item
->next
)
2229 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2230 && !xg_separator_p (item
->name
))
2233 /* A title for a popup. We do the same as GTK does when
2234 creating titles, but it does not look good. */
2236 utf8_label
= get_utf8_string (item
->name
);
2238 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2239 w
= gtk_menu_item_new_with_label (utf8_label
);
2240 gtk_widget_set_sensitive (w
, FALSE
);
2241 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
2243 else if (xg_separator_p (item
->name
))
2246 /* GTK only have one separator type. */
2247 w
= gtk_separator_menu_item_new ();
2251 w
= xg_create_one_menuitem (item
,
2253 item
->contents
? 0 : select_cb
,
2258 /* Create a possibly empty submenu for menu bar items, since some
2259 themes don't highlight items correctly without it. */
2260 if (item
->contents
|| menu_bar_p
)
2262 GtkWidget
*submenu
= create_menus (item
->contents
,
2273 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2277 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2278 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2284 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2285 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2286 with some text and buttons.
2287 F is the frame the created item belongs to.
2288 NAME is the name to use for the top widget.
2289 VAL is a widget_value structure describing items to be created.
2290 SELECT_CB is the callback to use when a menu item is selected or
2291 a dialog button is pressed.
2292 DEACTIVATE_CB is the callback to use when an item is deactivated.
2293 For a menu, when a sub menu is not shown anymore, for a dialog it is
2294 called when the dialog is popped down.
2295 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2297 Returns the widget created. */
2300 xg_create_widget (type
, name
, f
, val
,
2301 select_cb
, deactivate_cb
, highlight_cb
)
2306 GCallback select_cb
;
2307 GCallback deactivate_cb
;
2308 GCallback highlight_cb
;
2311 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2312 int pop_up_p
= strcmp (type
, "popup") == 0;
2314 if (strcmp (type
, "dialog") == 0)
2316 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2317 xg_set_screen (w
, f
);
2318 gtk_window_set_transient_for (GTK_WINDOW (w
),
2319 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2320 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2321 gtk_widget_set_name (w
, "emacs-dialog");
2322 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2324 else if (menu_bar_p
|| pop_up_p
)
2326 w
= create_menus (val
->contents
,
2338 /* Set the cursor to an arrow for popup menus when they are mapped.
2339 This is done by default for menu bar menus. */
2342 /* Must realize so the GdkWindow inside the widget is created. */
2343 gtk_widget_realize (w
);
2344 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2349 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2356 /* Return the label for menu item WITEM. */
2359 xg_get_menu_item_label (witem
)
2362 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2363 return gtk_label_get_label (wlabel
);
2366 /* Return non-zero if the menu item WITEM has the text LABEL. */
2369 xg_item_label_same_p (witem
, label
)
2374 char *utf8_label
= get_utf8_string (label
);
2375 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2377 if (! old_label
&& ! utf8_label
)
2379 else if (old_label
&& utf8_label
)
2380 is_same
= strcmp (utf8_label
, old_label
) == 0;
2382 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
2387 /* Destroy widgets in LIST. */
2390 xg_destroy_widgets (list
)
2395 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2397 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2399 /* Destroying the widget will remove it from the container it is in. */
2400 gtk_widget_destroy (w
);
2404 /* Update the top level names in MENUBAR (i.e. not submenus).
2405 F is the frame the menu bar belongs to.
2406 *LIST is a list with the current menu bar names (menu item widgets).
2407 ITER is the item within *LIST that shall be updated.
2408 POS is the numerical position, starting at 0, of ITER in *LIST.
2409 VAL describes what the menu bar shall look like after the update.
2410 SELECT_CB is the callback to use when a menu item is selected.
2411 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2412 CL_DATA points to the callback data to be used for this menu bar.
2414 This function calls itself to walk through the menu bar names. */
2417 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2418 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2425 GCallback select_cb
;
2426 GCallback deactivate_cb
;
2427 GCallback highlight_cb
;
2428 xg_menu_cb_data
*cl_data
;
2430 if (! iter
&& ! val
)
2432 else if (iter
&& ! val
)
2434 /* Item(s) have been removed. Remove all remaining items. */
2435 xg_destroy_widgets (iter
);
2437 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2438 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2439 gtk_menu_item_new_with_label (""),
2445 else if (! iter
&& val
)
2447 /* Item(s) added. Add all new items in one call. */
2448 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2449 0, 1, 0, menubar
, cl_data
, 0);
2455 /* Below this neither iter or val is NULL */
2456 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2458 /* This item is still the same, check next item. */
2460 iter
= g_list_next (iter
);
2463 else /* This item is changed. */
2465 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2466 GtkMenuItem
*witem2
= 0;
2467 int val_in_menubar
= 0;
2468 int iter_in_new_menubar
= 0;
2472 /* See if the changed entry (val) is present later in the menu bar */
2474 iter2
&& ! val_in_menubar
;
2475 iter2
= g_list_next (iter2
))
2477 witem2
= GTK_MENU_ITEM (iter2
->data
);
2478 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2481 /* See if the current entry (iter) is present later in the
2482 specification for the new menu bar. */
2483 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2484 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2486 if (val_in_menubar
&& ! iter_in_new_menubar
)
2490 /* This corresponds to:
2495 gtk_widget_ref (GTK_WIDGET (witem
));
2496 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2497 gtk_widget_destroy (GTK_WIDGET (witem
));
2499 /* Must get new list since the old changed. */
2500 g_list_free (*list
);
2501 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2502 while (nr
-- > 0) iter
= g_list_next (iter
);
2504 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2506 /* This corresponds to:
2509 Rename B to X. This might seem to be a strange thing to do,
2510 since if there is a menu under B it will be totally wrong for X.
2511 But consider editing a C file. Then there is a C-mode menu
2512 (corresponds to B above).
2513 If then doing C-x C-f the minibuf menu (X above) replaces the
2514 C-mode menu. When returning from the minibuffer, we get
2515 back the C-mode menu. Thus we do:
2516 Rename B to X (C-mode to minibuf menu)
2517 Rename X to B (minibuf to C-mode menu).
2518 If the X menu hasn't been invoked, the menu under B
2519 is up to date when leaving the minibuffer. */
2520 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
2521 char *utf8_label
= get_utf8_string (val
->name
);
2522 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2524 gtk_label_set_text (wlabel
, utf8_label
);
2526 /* If this item has a submenu that has been detached, change
2527 the title in the WM decorations also. */
2528 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2529 /* Set the title of the detached window. */
2530 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2532 iter
= g_list_next (iter
);
2536 else if (! val_in_menubar
&& iter_in_new_menubar
)
2538 /* This corresponds to:
2545 GtkWidget
*w
= xg_create_one_menuitem (val
,
2552 /* Create a possibly empty submenu for menu bar items, since some
2553 themes don't highlight items correctly without it. */
2554 GtkWidget
*submenu
= create_menus (NULL
, f
,
2555 select_cb
, deactivate_cb
,
2557 0, 0, 0, 0, cl_data
, 0);
2558 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2559 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2560 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2562 g_list_free (*list
);
2563 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2564 while (nr
-- > 0) iter
= g_list_next (iter
);
2565 iter
= g_list_next (iter
);
2569 else /* if (val_in_menubar && iter_in_new_menubar) */
2572 /* This corresponds to:
2577 gtk_widget_ref (GTK_WIDGET (witem2
));
2578 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2579 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2580 GTK_WIDGET (witem2
), pos
);
2581 gtk_widget_unref (GTK_WIDGET (witem2
));
2583 g_list_free (*list
);
2584 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2585 while (nr
-- > 0) iter
= g_list_next (iter
);
2586 if (iter
) iter
= g_list_next (iter
);
2592 /* Update the rest of the menu bar. */
2593 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2594 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2597 /* Update the menu item W so it corresponds to VAL.
2598 SELECT_CB is the callback to use when a menu item is selected.
2599 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2600 CL_DATA is the data to set in the widget for menu invocation. */
2603 xg_update_menu_item (val
, w
, select_cb
, highlight_cb
, cl_data
)
2606 GCallback select_cb
;
2607 GCallback highlight_cb
;
2608 xg_menu_cb_data
*cl_data
;
2615 const char *old_label
= 0;
2616 const char *old_key
= 0;
2617 xg_menu_item_cb_data
*cb_data
;
2619 wchild
= gtk_bin_get_child (GTK_BIN (w
));
2620 utf8_label
= get_utf8_string (val
->name
);
2621 utf8_key
= get_utf8_string (val
->key
);
2623 /* See if W is a menu item with a key. See make_menu_item above. */
2624 if (GTK_IS_HBOX (wchild
))
2626 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2628 wlbl
= GTK_LABEL (list
->data
);
2629 wkey
= GTK_LABEL (list
->next
->data
);
2634 /* Remove the key and keep just the label. */
2635 gtk_widget_ref (GTK_WIDGET (wlbl
));
2636 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2637 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2642 else /* Just a label. */
2644 wlbl
= GTK_LABEL (wchild
);
2646 /* Check if there is now a key. */
2649 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2650 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2652 wlbl
= GTK_LABEL (list
->data
);
2653 wkey
= GTK_LABEL (list
->next
->data
);
2656 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2657 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2662 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2663 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2665 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2666 gtk_label_set_text (wkey
, utf8_key
);
2668 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2669 gtk_label_set_text (wlbl
, utf8_label
);
2671 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
2672 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
2674 if (! val
->enabled
&& GTK_WIDGET_SENSITIVE (w
))
2675 gtk_widget_set_sensitive (w
, FALSE
);
2676 else if (val
->enabled
&& ! GTK_WIDGET_SENSITIVE (w
))
2677 gtk_widget_set_sensitive (w
, TRUE
);
2679 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
2683 cb_data
->call_data
= val
->call_data
;
2684 cb_data
->help
= val
->help
;
2685 cb_data
->cl_data
= cl_data
;
2687 /* We assume the callback functions don't change. */
2688 if (val
->call_data
&& ! val
->contents
)
2690 /* This item shall have a select callback. */
2691 if (! cb_data
->select_id
)
2693 = g_signal_connect (G_OBJECT (w
), "activate",
2694 select_cb
, cb_data
);
2696 else if (cb_data
->select_id
)
2698 g_signal_handler_disconnect (w
, cb_data
->select_id
);
2699 cb_data
->select_id
= 0;
2704 /* Update the toggle menu item W so it corresponds to VAL. */
2707 xg_update_toggle_item (val
, w
)
2711 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2714 /* Update the radio menu item W so it corresponds to VAL. */
2717 xg_update_radio_item (val
, w
)
2721 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
2724 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
2725 SUBMENU may be NULL, in that case a new menu is created.
2726 F is the frame the menu bar belongs to.
2727 VAL describes the contents of the menu bar.
2728 SELECT_CB is the callback to use when a menu item is selected.
2729 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2730 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2731 CL_DATA is the call back data to use for any newly created items.
2733 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
2737 xg_update_submenu (submenu
, f
, val
,
2738 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
2742 GCallback select_cb
;
2743 GCallback deactivate_cb
;
2744 GCallback highlight_cb
;
2745 xg_menu_cb_data
*cl_data
;
2747 GtkWidget
*newsub
= submenu
;
2751 int has_tearoff_p
= 0;
2752 GList
*first_radio
= 0;
2755 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
2757 for (cur
= val
, iter
= list
;
2759 iter
= g_list_next (iter
), cur
= cur
->next
)
2761 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2763 /* Skip tearoff items, they have no counterpart in val. */
2764 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
2767 iter
= g_list_next (iter
);
2768 if (iter
) w
= GTK_WIDGET (iter
->data
);
2772 /* Remember first radio button in a group. If we get a mismatch in
2773 a radio group we must rebuild the whole group so that the connections
2774 in GTK becomes correct. */
2775 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
2777 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
2778 && ! GTK_IS_RADIO_MENU_ITEM (w
))
2781 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
2783 if (! xg_separator_p (cur
->name
))
2786 else if (GTK_IS_CHECK_MENU_ITEM (w
))
2788 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
2790 xg_update_toggle_item (cur
, w
);
2791 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2793 else if (GTK_IS_RADIO_MENU_ITEM (w
))
2795 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
2797 xg_update_radio_item (cur
, w
);
2798 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2800 else if (GTK_IS_MENU_ITEM (w
))
2802 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2805 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2806 xg_separator_p (cur
->name
))
2809 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2811 sub
= gtk_menu_item_get_submenu (witem
);
2812 if (sub
&& ! cur
->contents
)
2814 /* Not a submenu anymore. */
2815 gtk_widget_ref (sub
);
2816 gtk_menu_item_remove_submenu (witem
);
2817 gtk_widget_destroy (sub
);
2819 else if (cur
->contents
)
2823 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2824 select_cb
, deactivate_cb
,
2825 highlight_cb
, cl_data
);
2827 /* If this item just became a submenu, we must set it. */
2829 gtk_menu_item_set_submenu (witem
, nsub
);
2834 /* Structural difference. Remove everything from here and down
2840 /* Remove widgets from first structual change. */
2843 /* If we are adding new menu items below, we must remove from
2844 first radio button so that radio groups become correct. */
2845 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
2846 else xg_destroy_widgets (iter
);
2851 /* More items added. Create them. */
2852 newsub
= create_menus (cur
,
2865 if (list
) g_list_free (list
);
2870 /* Update the MENUBAR.
2871 F is the frame the menu bar belongs to.
2872 VAL describes the contents of the menu bar.
2873 If DEEP_P is non-zero, rebuild all but the top level menu names in
2874 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2875 SELECT_CB is the callback to use when a menu item is selected.
2876 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2877 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2880 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2881 select_cb
, deactivate_cb
, highlight_cb
)
2886 GCallback select_cb
;
2887 GCallback deactivate_cb
;
2888 GCallback highlight_cb
;
2890 xg_menu_cb_data
*cl_data
;
2891 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2895 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2898 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
2899 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2905 /* Update all sub menus.
2906 We must keep the submenus (GTK menu item widgets) since the
2907 X Window in the XEvent that activates the menu are those widgets. */
2909 /* Update cl_data, menu_item things in F may have changed. */
2910 update_cl_data (cl_data
, f
, highlight_cb
);
2912 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2919 /* Find sub menu that corresponds to val and update it. */
2920 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2922 witem
= GTK_MENU_ITEM (iter
->data
);
2923 if (xg_item_label_same_p (witem
, cur
->name
))
2925 sub
= gtk_menu_item_get_submenu (witem
);
2930 newsub
= xg_update_submenu (sub
,
2937 /* sub may still be NULL. If we just updated non deep and added
2938 a new menu bar item, it has no sub menu yet. So we set the
2939 newly created sub menu under witem. */
2942 xg_set_screen (newsub
, f
);
2943 gtk_menu_item_set_submenu (witem
, newsub
);
2949 gtk_widget_show_all (menubar
);
2952 /* Recompute all the widgets of frame F, when the menu bar has been
2953 changed. Value is non-zero if widgets were updated. */
2956 xg_update_frame_menubar (f
)
2959 struct x_output
*x
= f
->output_data
.x
;
2962 if (!x
->menubar_widget
|| GTK_WIDGET_MAPPED (x
->menubar_widget
))
2965 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
2966 return 0; /* Already done this, happens for frames created invisible. */
2970 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2972 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2974 gtk_widget_show_all (x
->menubar_widget
);
2975 gtk_widget_size_request (x
->menubar_widget
, &req
);
2976 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2977 xg_height_changed (f
);
2983 /* Get rid of the menu bar of frame F, and free its storage.
2984 This is used when deleting a frame, and when turning off the menu bar. */
2987 free_frame_menubar (f
)
2990 struct x_output
*x
= f
->output_data
.x
;
2992 if (x
->menubar_widget
)
2996 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2997 /* The menubar and its children shall be deleted when removed from
2999 x
->menubar_widget
= 0;
3000 FRAME_MENUBAR_HEIGHT (f
) = 0;
3001 xg_height_changed (f
);
3008 /***********************************************************************
3009 Scroll bar functions
3010 ***********************************************************************/
3013 /* Setting scroll bar values invokes the callback. Use this variable
3014 to indicate that callback should do nothing. */
3016 int xg_ignore_gtk_scrollbar
;
3018 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3019 may be larger than 32 bits. Keep a mapping from integer index to widget
3020 pointers to get around the 32 bit limitation. */
3024 GtkWidget
**widgets
;
3029 /* Grow this much every time we need to allocate more */
3031 #define ID_TO_WIDGET_INCR 32
3033 /* Store the widget pointer W in id_to_widget and return the integer index. */
3036 xg_store_widget_in_map (w
)
3041 if (id_to_widget
.max_size
== id_to_widget
.used
)
3043 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3045 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
3046 sizeof (GtkWidget
*)*new_size
);
3048 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3049 id_to_widget
.widgets
[i
] = 0;
3050 id_to_widget
.max_size
= new_size
;
3053 /* Just loop over the array and find a free place. After all,
3054 how many scroll bars are we creating? Should be a small number.
3055 The check above guarantees we will find a free place. */
3056 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3058 if (! id_to_widget
.widgets
[i
])
3060 id_to_widget
.widgets
[i
] = w
;
3061 ++id_to_widget
.used
;
3067 /* Should never end up here */
3071 /* Remove pointer at IDX from id_to_widget.
3072 Called when scroll bar is destroyed. */
3075 xg_remove_widget_from_map (idx
)
3078 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3080 id_to_widget
.widgets
[idx
] = 0;
3081 --id_to_widget
.used
;
3085 /* Get the widget pointer at IDX from id_to_widget. */
3088 xg_get_widget_from_map (idx
)
3091 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3092 return id_to_widget
.widgets
[idx
];
3097 /* Return the scrollbar id for X Window WID on display DPY.
3098 Return -1 if WID not in id_to_widget. */
3101 xg_get_scroll_id_for_window (dpy
, wid
)
3108 w
= xg_win_to_widget (dpy
, wid
);
3112 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3113 if (id_to_widget
.widgets
[idx
] == w
)
3120 /* Callback invoked when scroll bar WIDGET is destroyed.
3121 DATA is the index into id_to_widget for WIDGET.
3122 We free pointer to last scroll bar values here and remove the index. */
3125 xg_gtk_scroll_destroy (widget
, data
)
3129 int id
= (int) (EMACS_INT
) data
; /* The EMACS_INT cast avoids a warning. */
3130 xg_remove_widget_from_map (id
);
3133 /* Create a scroll bar widget for frame F. Store the scroll bar
3135 SCROLL_CALLBACK is the callback to invoke when the value of the
3137 END_CALLBACK is the callback to invoke when scrolling ends.
3138 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3139 to set resources for the widget. */
3142 xg_create_scroll_bar (f
, bar
, scroll_callback
, end_callback
, scroll_bar_name
)
3144 struct scroll_bar
*bar
;
3145 GCallback scroll_callback
, end_callback
;
3146 char *scroll_bar_name
;
3153 /* Page, step increment values are not so important here, they
3154 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3155 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3158 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
3159 webox
= gtk_event_box_new ();
3160 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3161 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3162 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3164 scroll_id
= xg_store_widget_in_map (wscroll
);
3166 /* The EMACS_INT cast avoids a warning. */
3167 g_signal_connect (G_OBJECT (wscroll
),
3169 G_CALLBACK (xg_gtk_scroll_destroy
),
3170 (gpointer
) (EMACS_INT
) scroll_id
);
3171 g_signal_connect (G_OBJECT (wscroll
),
3175 g_signal_connect (G_OBJECT (wscroll
),
3176 "button-release-event",
3180 /* The scroll bar widget does not draw on a window of its own. Instead
3181 it draws on the parent window, in this case the edit widget. So
3182 whenever the edit widget is cleared, the scroll bar needs to redraw
3183 also, which causes flicker. Put an event box between the edit widget
3184 and the scroll bar, so the scroll bar instead draws itself on the
3185 event box window. */
3186 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3187 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3190 /* Set the cursor to an arrow. */
3191 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3193 bar
->x_window
= scroll_id
;
3196 /* Make the scroll bar represented by SCROLLBAR_ID visible. */
3199 xg_show_scroll_bar (scrollbar_id
)
3202 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3204 gtk_widget_show_all (gtk_widget_get_parent (w
));
3207 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3210 xg_remove_scroll_bar (f
, scrollbar_id
)
3214 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3217 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3218 gtk_widget_destroy (w
);
3219 gtk_widget_destroy (wparent
);
3220 SET_FRAME_GARBAGED (f
);
3224 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3226 TOP/LEFT are the new pixel positions where the bar shall appear.
3227 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3230 xg_update_scrollbar_pos (f
, scrollbar_id
, top
, left
, width
, height
)
3239 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3243 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3244 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3245 GtkFixed
*wf
= GTK_FIXED (wfixed
);
3247 /* Clear out old position. */
3249 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3250 for (iter
= wf
->children
; iter
; iter
= iter
->next
)
3251 if (((GtkFixedChild
*)iter
->data
)->widget
== wparent
)
3253 GtkFixedChild
*ch
= (GtkFixedChild
*)iter
->data
;
3254 if (ch
->x
!= left
|| ch
->y
!= top
)
3258 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3263 /* Move and resize to new values. */
3264 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3265 gtk_widget_set_size_request (wscroll
, width
, height
);
3266 gtk_widget_queue_draw (wfixed
);
3267 gdk_window_process_all_updates ();
3270 /* Clear under old scroll bar position. This must be done after
3271 the gtk_widget_queue_draw and gdk_window_process_all_updates
3273 x_clear_area (FRAME_X_DISPLAY (f
),
3275 oldx
, oldy
, oldw
, oldh
, 0);
3278 /* GTK does not redraw until the main loop is entered again, but
3279 if there are no X events pending we will not enter it. So we sync
3280 here to get some events. */
3283 SET_FRAME_GARBAGED (f
);
3284 cancel_mouse_face (f
);
3288 /* Set the thumb size and position of scroll bar BAR. We are currently
3289 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3292 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
3293 struct scroll_bar
*bar
;
3294 int portion
, position
, whole
;
3296 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3298 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3300 if (wscroll
&& NILP (bar
->dragging
))
3309 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3311 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3312 rather than the real portion value. This makes the thumb less likely
3313 to resize and that looks better. */
3314 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3315 /* When the thumb is at the bottom, position == whole.
3316 So we need to increase `whole' to make space for the thumb. */
3323 top
= (gdouble
) position
/ whole
;
3324 shown
= (gdouble
) portion
/ whole
;
3327 size
= shown
* XG_SB_RANGE
;
3328 size
= min (size
, XG_SB_RANGE
);
3329 size
= max (size
, 1);
3331 value
= top
* XG_SB_RANGE
;
3332 value
= min (value
, XG_SB_MAX
- size
);
3333 value
= max (value
, XG_SB_MIN
);
3335 /* Assume all lines are of equal size. */
3336 new_step
= size
/ max (1, FRAME_LINES (f
));
3338 if ((int) adj
->page_size
!= size
3339 || (int) adj
->step_increment
!= new_step
)
3341 adj
->page_size
= size
;
3342 adj
->step_increment
= new_step
;
3343 /* Assume a page increment is about 95% of the page size */
3344 adj
->page_increment
= (int) (0.95*adj
->page_size
);
3348 if (changed
|| (int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3350 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3354 /* gtk_range_set_value invokes the callback. Set
3355 ignore_gtk_scrollbar to make the callback do nothing */
3356 xg_ignore_gtk_scrollbar
= 1;
3358 if ((int) gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3359 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3361 gtk_adjustment_changed (adj
);
3363 xg_ignore_gtk_scrollbar
= 0;
3370 /* Return non-zero if EVENT is for a scroll bar in frame F.
3371 When the same X window is used for several Gtk+ widgets, we cannot
3372 say for sure based on the X window alone if an event is for the
3373 frame. This function does additional checks.
3375 Return non-zero if the event is for a scroll bar, zero otherwise. */
3378 xg_event_is_for_scrollbar (f
, event
)
3384 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3386 /* Check if press occurred outside the edit widget. */
3387 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3388 retval
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
)
3389 != f
->output_data
.x
->edit_widget
->window
;
3392 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3393 || event
->type
== MotionNotify
))
3395 /* If we are releasing or moving the scroll bar, it has the grab. */
3396 retval
= gtk_grab_get_current () != 0
3397 && gtk_grab_get_current () != f
->output_data
.x
->edit_widget
;
3405 /***********************************************************************
3407 ***********************************************************************/
3408 /* The key for the data we put in the GtkImage widgets. The data is
3409 the image used by Emacs. We use this to see if we need to update
3410 the GtkImage with a new image. */
3411 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3413 /* The key for storing the latest modifiers so the activate callback can
3415 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3417 /* The key for storing the button widget in its proxy menu item. */
3418 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3420 /* The key for the data we put in the GtkImage widgets. The data is
3421 the stock name used by Emacs. We use this to see if we need to update
3422 the GtkImage with a new image. */
3423 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3425 /* As above, but this is used for named theme widgets, as opposed to
3427 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3429 /* Callback function invoked when a tool bar item is pressed.
3430 W is the button widget in the tool bar that got pressed,
3431 CLIENT_DATA is an integer that is the index of the button in the
3432 tool bar. 0 is the first button. */
3435 xg_tool_bar_button_cb (widget
, event
, user_data
)
3437 GdkEventButton
*event
;
3440 /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
3441 gpointer ptr
= (gpointer
) (EMACS_INT
) event
->state
;
3442 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3447 /* Callback function invoked when a tool bar item is pressed.
3448 W is the button widget in the tool bar that got pressed,
3449 CLIENT_DATA is an integer that is the index of the button in the
3450 tool bar. 0 is the first button. */
3453 xg_tool_bar_callback (w
, client_data
)
3455 gpointer client_data
;
3457 /* The EMACS_INT cast avoids a warning. */
3458 int idx
= (int) (EMACS_INT
) client_data
;
3459 int mod
= (int) (EMACS_INT
) g_object_get_data (G_OBJECT (w
),
3460 XG_TOOL_BAR_LAST_MODIFIER
);
3462 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3463 Lisp_Object key
, frame
;
3464 struct input_event event
;
3467 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3470 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3472 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3473 XSETFRAME (frame
, f
);
3475 /* We generate two events here. The first one is to set the prefix
3476 to `(tool_bar)', see keyboard.c. */
3477 event
.kind
= TOOL_BAR_EVENT
;
3478 event
.frame_or_window
= frame
;
3480 kbd_buffer_store_event (&event
);
3482 event
.kind
= TOOL_BAR_EVENT
;
3483 event
.frame_or_window
= frame
;
3485 /* Convert between the modifier bits GDK uses and the modifier bits
3486 Emacs uses. This assumes GDK and X masks are the same, which they are when
3488 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3489 kbd_buffer_store_event (&event
);
3491 /* Return focus to the frame after we have clicked on a detached
3493 Fx_focus_frame (frame
);
3496 /* Callback function invoked when a tool bar item is pressed in a detached
3497 tool bar or the overflow drop down menu.
3498 We just call xg_tool_bar_callback.
3499 W is the menu item widget that got pressed,
3500 CLIENT_DATA is an integer that is the index of the button in the
3501 tool bar. 0 is the first button. */
3504 xg_tool_bar_proxy_callback (w
, client_data
)
3506 gpointer client_data
;
3508 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3509 XG_TOOL_BAR_PROXY_BUTTON
));
3510 xg_tool_bar_callback (wbutton
, client_data
);
3515 xg_tool_bar_help_callback
P_ ((GtkWidget
*w
,
3516 GdkEventCrossing
*event
,
3517 gpointer client_data
));
3519 /* This callback is called when a help is to be shown for an item in
3520 the detached tool bar when the detached tool bar it is not expanded. */
3523 xg_tool_bar_proxy_help_callback (w
, event
, client_data
)
3525 GdkEventCrossing
*event
;
3526 gpointer client_data
;
3528 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3529 XG_TOOL_BAR_PROXY_BUTTON
));
3531 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3535 /* This callback is called when a tool item should create a proxy item,
3536 such as for the overflow menu. Also called when the tool bar is detached.
3537 If we don't create a proxy menu item, the detached tool bar will be
3541 xg_tool_bar_menu_proxy (toolitem
, user_data
)
3542 GtkToolItem
*toolitem
;
3545 GtkWidget
*weventbox
= gtk_bin_get_child (GTK_BIN (toolitem
));
3546 GtkButton
*wbutton
= GTK_BUTTON (gtk_bin_get_child (GTK_BIN (weventbox
)));
3547 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label ("");
3548 GtkWidget
*wmenuimage
;
3550 if (gtk_button_get_use_stock (wbutton
))
3551 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3552 GTK_ICON_SIZE_MENU
);
3555 GtkImage
*wimage
= GTK_IMAGE (gtk_bin_get_child (GTK_BIN (wbutton
)));
3556 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3557 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3559 if (store_type
== GTK_IMAGE_STOCK
)
3562 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3563 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3565 else if (store_type
== GTK_IMAGE_ICON_SET
)
3567 GtkIconSet
*icon_set
;
3568 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3569 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3570 GTK_ICON_SIZE_MENU
);
3572 else if (store_type
== GTK_IMAGE_PIXBUF
)
3577 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3580 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3582 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3583 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3584 GDK_INTERP_BILINEAR
);
3586 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
3590 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
3594 else if (store_type
== GTK_IMAGE_ICON_NAME
)
3596 const gchar
*icon_name
;
3597 GtkIconSize icon_size
;
3599 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
3600 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
3601 GTK_ICON_SIZE_MENU
);
3605 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
3610 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
3612 g_signal_connect (G_OBJECT (wmenuitem
),
3614 G_CALLBACK (xg_tool_bar_proxy_callback
),
3618 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
3619 (gpointer
) wbutton
);
3620 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
3621 gtk_widget_set_sensitive (wmenuitem
, GTK_WIDGET_SENSITIVE (wbutton
));
3623 /* Use enter/leave notify to show help. We use the events
3624 rather than the GtkButton specific signals "enter" and
3625 "leave", so we can have only one callback. The event
3626 will tell us what kind of event it is. */
3627 g_signal_connect (G_OBJECT (wmenuitem
),
3628 "enter-notify-event",
3629 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3631 g_signal_connect (G_OBJECT (wmenuitem
),
3632 "leave-notify-event",
3633 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
3639 /* This callback is called when a tool bar is detached. We must set
3640 the height of the tool bar to zero when this happens so frame sizes
3641 are correctly calculated.
3642 WBOX is the handle box widget that enables detach/attach of the tool bar.
3643 W is the tool bar widget.
3644 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3647 xg_tool_bar_detach_callback (wbox
, w
, client_data
)
3650 gpointer client_data
;
3652 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3653 extern int x_gtk_whole_detached_tool_bar
;
3655 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
3660 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
3662 /* When detaching a tool bar, not everything dissapear. There are
3663 a few pixels left that are used to drop the tool bar back into
3665 FRAME_TOOLBAR_HEIGHT (f
) = 4;
3666 xg_height_changed (f
);
3670 /* This callback is called when a tool bar is reattached. We must set
3671 the height of the tool bar when this happens so frame sizes
3672 are correctly calculated.
3673 WBOX is the handle box widget that enables detach/attach of the tool bar.
3674 W is the tool bar widget.
3675 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
3678 xg_tool_bar_attach_callback (wbox
, w
, client_data
)
3681 gpointer client_data
;
3683 FRAME_PTR f
= (FRAME_PTR
) client_data
;
3684 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
3690 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
3692 gtk_widget_size_request (w
, &req
);
3693 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
3694 xg_height_changed (f
);
3698 /* This callback is called when the mouse enters or leaves a tool bar item.
3699 It is used for displaying and hiding the help text.
3700 W is the tool bar item, a button.
3701 EVENT is either an enter event or leave event.
3702 CLIENT_DATA is an integer that is the index of the button in the
3703 tool bar. 0 is the first button.
3705 Returns FALSE to tell GTK to keep processing this event. */
3708 xg_tool_bar_help_callback (w
, event
, client_data
)
3710 GdkEventCrossing
*event
;
3711 gpointer client_data
;
3713 /* The EMACS_INT cast avoids a warning. */
3714 int idx
= (int) (EMACS_INT
) client_data
;
3715 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3716 Lisp_Object help
, frame
;
3718 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3721 if (event
->type
== GDK_ENTER_NOTIFY
)
3723 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3724 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
3727 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
3732 XSETFRAME (frame
, f
);
3733 kbd_buffer_store_help_event (frame
, help
);
3739 /* This callback is called when a tool bar item shall be redrawn.
3740 It modifies the expose event so that the GtkImage widget redraws the
3741 whole image. This to overcome a bug that makes GtkImage draw the image
3742 in the wrong place when it tries to redraw just a part of the image.
3743 W is the GtkImage to be redrawn.
3744 EVENT is the expose event for W.
3745 CLIENT_DATA is unused.
3747 Returns FALSE to tell GTK to keep processing this event. */
3750 xg_tool_bar_item_expose_callback (w
, event
, client_data
)
3752 GdkEventExpose
*event
;
3753 gpointer client_data
;
3757 gdk_drawable_get_size (event
->window
, &width
, &height
);
3759 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
3760 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
3762 event
->area
.x
= max (0, event
->area
.x
);
3763 event
->area
.y
= max (0, event
->area
.y
);
3765 event
->area
.width
= max (width
, event
->area
.width
);
3766 event
->area
.height
= max (height
, event
->area
.height
);
3771 /* Attach a tool bar to frame F. */
3774 xg_pack_tool_bar (f
)
3777 struct x_output
*x
= f
->output_data
.x
;
3778 int vbox_pos
= x
->menubar_widget
? 1 : 0;
3780 x
->handlebox_widget
= gtk_handle_box_new ();
3781 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
3782 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
3783 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
3784 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
3786 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
3789 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3792 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
3794 gtk_widget_show_all (x
->handlebox_widget
);
3797 /* Create a tool bar for frame F. */
3800 xg_create_tool_bar (f
)
3803 struct x_output
*x
= f
->output_data
.x
;
3806 x
->toolbar_widget
= gtk_toolbar_new ();
3807 x
->toolbar_detached
= 0;
3809 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
3811 /* We only have icons, so override any user setting. We could
3812 use the caption property of the toolbar item (see update_frame_tool_bar
3813 below), but some of those strings are long, making the toolbar so
3814 long it does not fit on the screen. The GtkToolbar widget makes every
3815 item equal size, so the longest caption determine the size of every
3816 tool bar item. I think the creators of the GtkToolbar widget
3817 counted on 4 or 5 character long strings. */
3818 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
3819 gtk_toolbar_set_orientation (GTK_TOOLBAR (x
->toolbar_widget
),
3820 GTK_ORIENTATION_HORIZONTAL
);
3824 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
3826 /* Find the right-to-left image named by RTL in the tool bar images for F.
3827 Returns IMAGE if RTL is not found. */
3830 find_rtl_image (f
, image
, rtl
)
3836 Lisp_Object file
, rtl_name
;
3837 struct gcpro gcpro1
, gcpro2
;
3838 GCPRO2 (file
, rtl_name
);
3840 rtl_name
= Ffile_name_nondirectory (rtl
);
3842 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3844 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3845 if (!NILP (file
= file_for_image (rtl_image
)))
3847 file
= call1 (intern ("file-name-sans-extension"),
3848 Ffile_name_nondirectory (file
));
3849 if (EQ (Fequal (file
, rtl_name
), Qt
))
3860 /* Update the tool bar for frame F. Add new buttons and remove old. */
3862 extern Lisp_Object Qx_gtk_map_stock
;
3865 update_frame_tool_bar (f
)
3869 GtkRequisition old_req
, new_req
;
3870 struct x_output
*x
= f
->output_data
.x
;
3871 int hmargin
= 0, vmargin
= 0;
3872 GtkToolbar
*wtoolbar
;
3874 GtkTextDirection dir
;
3875 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
3877 if (! FRAME_GTK_WIDGET (f
))
3882 if (INTEGERP (Vtool_bar_button_margin
)
3883 && XINT (Vtool_bar_button_margin
) > 0)
3885 hmargin
= XFASTINT (Vtool_bar_button_margin
);
3886 vmargin
= XFASTINT (Vtool_bar_button_margin
);
3888 else if (CONSP (Vtool_bar_button_margin
))
3890 if (INTEGERP (XCAR (Vtool_bar_button_margin
))
3891 && XINT (XCAR (Vtool_bar_button_margin
)) > 0)
3892 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
3894 if (INTEGERP (XCDR (Vtool_bar_button_margin
))
3895 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
3896 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
3899 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
3900 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
3901 i.e. zero. This means that margins less than
3902 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
3903 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3904 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
3906 if (! x
->toolbar_widget
)
3907 xg_create_tool_bar (f
);
3909 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
3910 gtk_widget_size_request (GTK_WIDGET (wtoolbar
), &old_req
);
3911 dir
= gtk_widget_get_direction (x
->toolbar_widget
);
3913 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
3915 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
3916 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
3920 struct image
*img
= NULL
;
3922 Lisp_Object stock
= Qnil
;
3923 GtkStockItem stock_item
;
3924 char *stock_name
= NULL
;
3925 char *icon_name
= NULL
;
3927 GtkWidget
*wbutton
= NULL
;
3928 GtkWidget
*weventbox
;
3929 Lisp_Object specified_file
;
3931 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (x
->toolbar_widget
), i
);
3935 weventbox
= gtk_bin_get_child (GTK_BIN (ti
));
3936 wbutton
= gtk_bin_get_child (GTK_BIN (weventbox
));
3939 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
3941 /* Ignore invalid image specifications. */
3942 if (!valid_image_p (image
))
3944 if (wbutton
) gtk_widget_hide (wbutton
);
3948 specified_file
= file_for_image (image
);
3949 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
3950 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
3952 if (STRINGP (stock
))
3954 stock_name
= SSDATA (stock
);
3955 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
3957 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
3958 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
3960 icon_name
= stock_name
+ 2;
3964 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
3967 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3969 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
3970 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
3978 if (stock_name
== NULL
&& icon_name
== NULL
)
3980 /* No stock image, or stock item not known. Try regular image. */
3982 /* If image is a vector, choose the image according to the
3984 if (dir
== GTK_TEXT_DIR_RTL
3985 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
3988 image
= find_rtl_image (f
, image
, rtl
);
3991 if (VECTORP (image
))
3995 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
3996 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
3999 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4000 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4002 xassert (ASIZE (image
) >= idx
);
4003 image
= AREF (image
, idx
);
4008 img_id
= lookup_image (f
, image
);
4009 img
= IMAGE_FROM_ID (f
, img_id
);
4010 prepare_image_for_display (f
, img
);
4012 if (img
->load_failed_p
|| img
->pixmap
== None
)
4015 gtk_widget_hide_all (GTK_WIDGET (ti
));
4018 /* Insert an empty (non-image) button */
4019 weventbox
= gtk_event_box_new ();
4020 wbutton
= gtk_button_new ();
4021 gtk_button_set_focus_on_click (GTK_BUTTON (wbutton
), FALSE
);
4022 gtk_button_set_relief (GTK_BUTTON (wbutton
),
4024 gtk_container_add (GTK_CONTAINER (weventbox
), wbutton
);
4025 ti
= gtk_tool_item_new ();
4026 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4027 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
), ti
, -1);
4038 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4039 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4040 (gpointer
) xstrdup (stock_name
),
4041 (GDestroyNotify
) xfree
);
4045 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4046 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4047 (gpointer
) xstrdup (icon_name
),
4048 (GDestroyNotify
) xfree
);
4052 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4053 /* Save the image so we can see if an update is needed when
4054 this function is called again. */
4055 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4056 (gpointer
)img
->pixmap
);
4059 gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4060 wbutton
= gtk_button_new ();
4061 gtk_button_set_focus_on_click (GTK_BUTTON (wbutton
), FALSE
);
4062 gtk_button_set_relief (GTK_BUTTON (wbutton
), GTK_RELIEF_NONE
);
4063 gtk_container_add (GTK_CONTAINER (wbutton
), w
);
4064 weventbox
= gtk_event_box_new ();
4065 gtk_container_add (GTK_CONTAINER (weventbox
), wbutton
);
4066 ti
= gtk_tool_item_new ();
4067 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4068 gtk_toolbar_insert (GTK_TOOLBAR (x
->toolbar_widget
), ti
, -1);
4071 /* The EMACS_INT cast avoids a warning. */
4072 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4073 G_CALLBACK (xg_tool_bar_menu_proxy
),
4074 (gpointer
) (EMACS_INT
) i
);
4076 g_signal_connect (G_OBJECT (wbutton
), "clicked",
4077 G_CALLBACK (xg_tool_bar_callback
),
4078 (gpointer
) (EMACS_INT
) i
);
4080 gtk_widget_show_all (GTK_WIDGET (ti
));
4083 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4085 /* Catch expose events to overcome an annoying redraw bug, see
4086 comment for xg_tool_bar_item_expose_callback. */
4087 g_signal_connect (G_OBJECT (ti
),
4089 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4092 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4093 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4095 /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
4096 no distinction based on modifiers in the activate callback,
4097 so we have to do it ourselves. */
4098 g_signal_connect (wbutton
, "button-release-event",
4099 G_CALLBACK (xg_tool_bar_button_cb
),
4102 g_object_set_data (G_OBJECT (wbutton
), XG_FRAME_DATA
, (gpointer
)f
);
4104 /* Use enter/leave notify to show help. We use the events
4105 rather than the GtkButton specific signals "enter" and
4106 "leave", so we can have only one callback. The event
4107 will tell us what kind of event it is. */
4108 /* The EMACS_INT cast avoids a warning. */
4109 g_signal_connect (G_OBJECT (weventbox
),
4110 "enter-notify-event",
4111 G_CALLBACK (xg_tool_bar_help_callback
),
4112 (gpointer
) (EMACS_INT
) i
);
4113 g_signal_connect (G_OBJECT (weventbox
),
4114 "leave-notify-event",
4115 G_CALLBACK (xg_tool_bar_help_callback
),
4116 (gpointer
) (EMACS_INT
) i
);
4120 GtkWidget
*wimage
= gtk_bin_get_child (GTK_BIN (wbutton
));
4121 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
4122 XG_TOOL_BAR_IMAGE_DATA
);
4123 gpointer old_stock_name
= g_object_get_data (G_OBJECT (wimage
),
4124 XG_TOOL_BAR_STOCK_NAME
);
4125 gpointer old_icon_name
= g_object_get_data (G_OBJECT (wimage
),
4126 XG_TOOL_BAR_ICON_NAME
);
4128 (! old_stock_name
|| strcmp (old_stock_name
, stock_name
) != 0))
4130 gtk_image_set_from_stock (GTK_IMAGE (wimage
),
4131 stock_name
, icon_size
);
4132 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4133 (gpointer
) xstrdup (stock_name
),
4134 (GDestroyNotify
) xfree
);
4135 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4137 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
, NULL
);
4139 else if (icon_name
&&
4140 (! old_icon_name
|| strcmp (old_icon_name
, icon_name
) != 0))
4142 gtk_image_set_from_icon_name (GTK_IMAGE (wimage
),
4143 icon_name
, icon_size
);
4144 g_object_set_data_full (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
,
4145 (gpointer
) xstrdup (icon_name
),
4146 (GDestroyNotify
) xfree
);
4147 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4149 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4152 else if (img
&& old_img
!= img
->pixmap
)
4154 (void) xg_get_image_for_pixmap (f
, img
, x
->widget
, wimage
);
4155 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
4156 (gpointer
)img
->pixmap
);
4158 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_STOCK_NAME
,
4160 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_ICON_NAME
, NULL
);
4163 gtk_misc_set_padding (GTK_MISC (wimage
), hmargin
, vmargin
);
4165 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4166 gtk_widget_show_all (GTK_WIDGET (ti
));
4172 /* Remove buttons not longer needed. We just hide them so they
4173 can be reused later on. */
4176 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (x
->toolbar_widget
), i
++);
4177 if (ti
) gtk_widget_hide_all (GTK_WIDGET (ti
));
4178 } while (ti
!= NULL
);
4181 if (pack_tool_bar
&& f
->n_tool_bar_items
!= 0)
4182 xg_pack_tool_bar (f
);
4185 gtk_widget_size_request (GTK_WIDGET (x
->toolbar_widget
), &new_req
);
4186 if (old_req
.height
!= new_req
.height
4187 && ! FRAME_X_OUTPUT (f
)->toolbar_detached
)
4189 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
4190 xg_height_changed (f
);
4195 /* Deallocate all resources for the tool bar on frame F.
4196 Remove the tool bar. */
4199 free_frame_tool_bar (f
)
4202 struct x_output
*x
= f
->output_data
.x
;
4204 if (x
->toolbar_widget
)
4206 int is_packed
= x
->handlebox_widget
!= 0;
4208 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4209 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4211 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4212 x
->handlebox_widget
);
4214 gtk_widget_destroy (x
->toolbar_widget
);
4216 x
->toolbar_widget
= 0;
4217 x
->handlebox_widget
= 0;
4218 FRAME_TOOLBAR_HEIGHT (f
) = 0;
4219 xg_height_changed (f
);
4227 /***********************************************************************
4229 ***********************************************************************/
4233 GtkBindingSet
*binding_set
;
4236 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4237 we keep it permanently linked in. */
4242 xg_ignore_gtk_scrollbar
= 0;
4243 xg_detached_menus
= 0;
4244 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4245 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4247 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4248 id_to_widget
.widgets
= 0;
4250 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4251 bindings. It doesn't seem to be any way to remove properties,
4252 so we set it to VoidSymbol which in X means "no key". */
4253 gtk_settings_set_string_property (gtk_settings_get_default (),
4254 "gtk-menu-bar-accel",
4258 /* Make GTK text input widgets use Emacs style keybindings. This is
4260 gtk_settings_set_string_property (gtk_settings_get_default (),
4261 "gtk-key-theme-name",
4265 /* Make dialogs close on C-g. Since file dialog inherits from
4266 dialog, this works for them also. */
4267 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4268 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4271 /* Make menus close on C-g. */
4272 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4273 (GTK_TYPE_MENU_SHELL
));
4274 gtk_binding_entry_add_signal (binding_set
, GDK_g
, GDK_CONTROL_MASK
,
4278 #endif /* USE_GTK */
4280 /* arch-tag: fe7104da-bc1e-4aba-9bd1-f349c528f7e3
4281 (do not change this comment) */