1 /* Functions for creating and updating GTK widgets.
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
29 #include "blockinput.h"
33 #include "termhooks.h"
34 #include <gdk/gdkkeysyms.h>
36 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
37 (PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
39 /***********************************************************************
41 ***********************************************************************/
42 /* The timer for scroll bar repetition and menu bar timeouts.
43 NULL if no timer is started. */
44 static struct atimer
*xg_timer
;
46 /* The cursor used for scroll bars and popup menus.
47 We only have one cursor for all scroll bars and all popup menus. */
48 static GdkCursor
*xg_left_ptr_cursor
;
51 /* The next two variables and functions are taken from lwlib. */
52 static widget_value
*widget_value_free_list
;
53 static int malloc_cpt
;
55 /* Allocate a widget_value structure, either by taking one from the
56 widget_value_free_list or by malloc:ing a new one.
58 Return a pointer to the allocated structure. */
60 malloc_widget_value ()
63 if (widget_value_free_list
)
65 wv
= widget_value_free_list
;
66 widget_value_free_list
= wv
->free_list
;
71 wv
= (widget_value
*) malloc (sizeof (widget_value
));
74 memset (wv
, 0, sizeof (widget_value
));
78 /* This is analogous to free. It frees only what was allocated
79 by malloc_widget_value, and no substructures. */
81 free_widget_value (wv
)
89 /* When the number of already allocated cells is too big,
96 wv
->free_list
= widget_value_free_list
;
97 widget_value_free_list
= wv
;
101 /* Set *CURSOR on W and all widgets W contain. We must do like this
102 for scroll bars and menu because they create widgets internally,
103 and it is those widgets that are visible.
105 If *CURSOR is NULL, create a GDK_LEFT_PTR cursor and set *CURSOR to
106 the created cursor. */
108 xg_set_cursor (w
, cursor
)
112 GList
*children
= gdk_window_peek_children (w
->window
);
114 /* Create the cursor unless already created. */
116 *cursor
= gdk_cursor_new (GDK_LEFT_PTR
);
118 gdk_window_set_cursor (w
->window
, *cursor
);
120 /* The scroll bar widget has more than one GDK window (had to look at
121 the source to figure this out), and there is no way to set cursor
122 on widgets in GTK. So we must set the cursor for all GDK windows.
125 for ( ; children
; children
= g_list_next (children
))
126 gdk_window_set_cursor (GDK_WINDOW (children
->data
), *cursor
);
129 /* Timer function called when a timeout occurs for xg_timer.
130 This function processes all GTK events in a recursive event loop.
131 This is done because GTK timer events are not seen by Emacs event
132 detection, Emacs only looks for X events. When a scroll bar has the
133 pointer (detected by button press/release events below) an Emacs
134 timer is started, and this function can then check if the GTK timer
135 has expired by calling the GTK event loop.
136 Also, when a menu is active, it has a small timeout before it
137 pops down the sub menu under it. */
139 xg_process_timeouts (timer
)
140 struct atimer
*timer
;
143 /* Ideally we would like to just handle timer events, like the Xt version
144 of this does in xterm.c, but there is no such feature in GTK. */
145 while (gtk_events_pending ())
146 gtk_main_iteration ();
150 /* Start the xg_timer with an interval of 0.1 seconds, if not already started.
151 xg_process_timeouts is called when the timer expires. The timer
152 stared is continuous, i.e. runs until xg_stop_timer is called. */
159 EMACS_SET_SECS_USECS (interval
, 0, 100000);
160 xg_timer
= start_atimer (ATIMER_CONTINUOUS
,
167 /* Stop the xg_timer if started. */
173 cancel_atimer (xg_timer
);
178 /* Insert NODE into linked LIST. */
180 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
182 xg_list_node
*list_start
= list
->next
;
184 if (list_start
) list_start
->prev
= node
;
185 node
->next
= list_start
;
190 /* Remove NODE from linked LIST. */
192 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
194 xg_list_node
*list_start
= list
->next
;
195 if (node
== list_start
)
197 list
->next
= node
->next
;
198 if (list
->next
) list
->next
->prev
= 0;
202 node
->prev
->next
= node
->next
;
203 if (node
->next
) node
->next
->prev
= node
->prev
;
207 /* Allocate and return a utf8 version of STR. If STR is already
208 utf8 or NULL, just return STR.
209 If not, a new string is allocated and the caller must free the result
212 get_utf8_string (str
)
215 char *utf8_str
= str
;
217 /* If not UTF-8, try current locale. */
218 if (str
&& !g_utf8_validate (str
, -1, NULL
))
219 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
226 /***********************************************************************
227 General functions for creating widgets, resizing, events, e.t.c.
228 ***********************************************************************/
230 /* Make a geometry string and pass that to GTK. It seems this is the
231 only way to get geometry position right if the user explicitly
232 asked for a position when starting Emacs.
233 F is the frame we shall set geometry for. */
238 if (f
->output_data
.x
->size_hint_flags
& USPosition
)
240 int left
= f
->output_data
.x
->left_pos
;
241 int xneg
= f
->output_data
.x
->size_hint_flags
& XNegative
;
242 int top
= f
->output_data
.x
->top_pos
;
243 int yneg
= f
->output_data
.x
->size_hint_flags
& YNegative
;
251 sprintf (geom_str
, "=%dx%d%c%d%c%d",
253 FRAME_TOTAL_PIXEL_HEIGHT (f
),
254 (xneg
? '-' : '+'), left
,
255 (yneg
? '-' : '+'), top
);
257 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
259 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
264 /* Resize the outer window of frame F after chainging the height.
265 This happend when the menu bar or the tool bar is added or removed.
266 COLUMNS/ROWS is the size the edit area shall have after the resize. */
268 xg_resize_outer_widget (f
, columns
, rows
)
273 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
274 PIXEL_WIDTH (f
), FRAME_TOTAL_PIXEL_HEIGHT (f
));
276 /* base_height is now changed. */
277 x_wm_set_size_hint (f
, 0, 0);
279 /* If we are not mapped yet, set geometry once again, as window
280 height now have changed. */
281 if (! GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f
)))
284 xg_frame_set_char_size (f
, columns
, rows
);
285 gdk_window_process_all_updates ();
288 /* Function to handle resize of our widgets. Since Emacs has some layouts
289 that does not fit well with GTK standard containers, we do most layout
291 F is the frame to resize.
292 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
294 xg_resize_widgets (f
, pixelwidth
, pixelheight
)
296 int pixelwidth
, pixelheight
;
298 int mbheight
= FRAME_MENUBAR_HEIGHT (f
);
299 int tbheight
= FRAME_TOOLBAR_HEIGHT (f
);
300 int rows
= PIXEL_TO_CHAR_HEIGHT (f
, pixelheight
- mbheight
- tbheight
);
301 int columns
= PIXEL_TO_CHAR_WIDTH (f
, pixelwidth
);
303 if (FRAME_GTK_WIDGET (f
)
304 && (columns
!= FRAME_WIDTH (f
) || rows
!= FRAME_HEIGHT (f
)
305 || pixelwidth
!= PIXEL_WIDTH (f
) || pixelheight
!= PIXEL_HEIGHT (f
)))
307 struct x_output
*x
= f
->output_data
.x
;
310 all
.y
= mbheight
+ tbheight
;
313 all
.width
= pixelwidth
;
314 all
.height
= pixelheight
- mbheight
- tbheight
;
316 gtk_widget_size_allocate (x
->edit_widget
, &all
);
317 gdk_window_process_all_updates ();
319 change_frame_size (f
, rows
, columns
, 0, 1, 0);
320 SET_FRAME_GARBAGED (f
);
321 cancel_mouse_face (f
);
326 /* Update our widget size to be COLS/ROWS characters for frame F. */
328 xg_frame_set_char_size (f
, cols
, rows
)
333 int pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
)
334 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
335 int pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
337 /* Take into account the size of the scroll bar. Always use the
338 number of columns occupied by the scroll bar here otherwise we
339 might end up with a frame width that is not a multiple of the
340 frame's character width which is bad for vertically split
342 f
->output_data
.x
->vertical_scroll_bar_extra
343 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
345 : (FRAME_SCROLL_BAR_COLS (f
)
346 * FONT_WIDTH (f
->output_data
.x
->font
)));
348 compute_fringe_widths (f
, 0);
350 /* Must resize our top level widget. Font size may have changed,
351 but not rows/cols. */
352 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
353 pixelwidth
, pixelheight
);
354 xg_resize_widgets (f
, pixelwidth
, pixelheight
);
357 /* Convert an X Window WSESC to its corresponding GtkWidget.
358 Must be done like this, because GtkWidget:s can have "hidden"
359 X Window that aren't accessible.
361 Return 0 if no widget match WDESC. */
363 xg_win_to_widget (wdesc
)
367 GtkWidget
*gwdesc
= 0;
370 gdkwin
= gdk_xid_table_lookup (wdesc
);
374 event
.any
.window
= gdkwin
;
375 gwdesc
= gtk_get_event_widget (&event
);
382 /* Fill in the GdkColor C so that it represents PIXEL.
383 W is the widget that color will be used for. Used to find colormap. */
385 xg_pix_to_gcolor (w
, pixel
, c
)
390 GdkColormap
*map
= gtk_widget_get_colormap (w
);
391 gdk_colormap_query_color (map
, pixel
, c
);
394 /* Create and set up the GTK widgets for frame F.
395 Return 0 if creation failed, non-zero otherwise. */
397 xg_create_frame_widgets (f
)
410 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
411 wvbox
= gtk_vbox_new (FALSE
, 0);
412 wfixed
= gtk_fixed_new (); /* Must have this to place scroll bars */
414 if (! wtop
|| ! wvbox
|| ! wfixed
)
416 if (wtop
) gtk_widget_destroy (wtop
);
417 if (wvbox
) gtk_widget_destroy (wvbox
);
418 if (wfixed
) gtk_widget_destroy (wfixed
);
423 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
424 gtk_widget_set_name (wtop
, EMACS_CLASS
);
425 gtk_widget_set_name (wvbox
, "pane");
426 gtk_widget_set_name (wfixed
, SDATA (Vx_resource_name
));
428 /* If this frame has a title or name, set it in the title bar. */
429 if (! NILP (f
->title
)) title
= SDATA (f
->title
);
430 else if (! NILP (f
->name
)) title
= SDATA (f
->name
);
432 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
434 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
435 FRAME_GTK_WIDGET (f
) = wfixed
;
436 f
->output_data
.x
->vbox_widget
= wvbox
;
438 gtk_fixed_set_has_window (GTK_FIXED (wfixed
), TRUE
);
440 gtk_widget_set_size_request (wfixed
,
444 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
445 gtk_box_pack_end (GTK_BOX (wvbox
), wfixed
, TRUE
, TRUE
, 0);
447 if (FRAME_EXTERNAL_TOOL_BAR (f
))
448 update_frame_tool_bar (f
);
450 /* The tool bar is created but first there are no items in it.
451 This causes it to be zero height. Later items are added, but then
452 the frame is already mapped, so there is a "jumping" resize.
453 This makes geometry handling difficult, for example -0-0 will end
454 up in the wrong place as tool bar height has not been taken into account.
455 So we cheat a bit by setting a height that is what it will have
456 later on when tool bar items are added. */
457 if (FRAME_EXTERNAL_TOOL_BAR (f
) && FRAME_TOOLBAR_HEIGHT (f
) == 0)
458 FRAME_TOOLBAR_HEIGHT (f
) = 34;
460 gtk_widget_set_double_buffered (wvbox
, FALSE
);
461 gtk_widget_set_double_buffered (wfixed
, FALSE
);
462 gtk_widget_set_double_buffered (wtop
, FALSE
);
464 /* GTK documents says use gtk_window_set_resizable. But then a user
465 can't shrink the window from its starting size. */
466 gtk_window_set_policy (GTK_WINDOW (wtop
), TRUE
, TRUE
, TRUE
);
467 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
468 SDATA (Vx_resource_name
),
469 SDATA (Vx_resource_class
));
471 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
472 GTK is to destroy the widget. We want Emacs to do that instead. */
473 g_signal_connect (G_OBJECT (wtop
), "delete-event",
474 G_CALLBACK (gtk_true
), 0);
476 /* Convert our geometry parameters into a geometry string
478 GTK will itself handle calculating the real position this way. */
481 gtk_widget_add_events (wfixed
,
482 GDK_POINTER_MOTION_MASK
484 | GDK_BUTTON_PRESS_MASK
485 | GDK_BUTTON_RELEASE_MASK
487 | GDK_ENTER_NOTIFY_MASK
488 | GDK_LEAVE_NOTIFY_MASK
489 | GDK_FOCUS_CHANGE_MASK
491 | GDK_VISIBILITY_NOTIFY_MASK
);
493 /* Must realize the windows so the X window gets created. It is used
494 by callers of this function. */
495 gtk_widget_realize (wfixed
);
496 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
498 /* Since GTK clears its window by filling with the background color,
499 we must keep X and GTK background in sync. */
500 xg_pix_to_gcolor (wfixed
, f
->output_data
.x
->background_pixel
, &bg
);
501 gtk_widget_modify_bg (wfixed
, GTK_STATE_NORMAL
, &bg
);
503 /* Also, do not let any background pixmap to be set, this looks very
504 bad as Emacs overwrites the background pixmap with its own idea
505 of background color. */
506 style
= gtk_widget_get_modifier_style (wfixed
);
508 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
509 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
510 gtk_widget_modify_style (wfixed
, style
);
512 /* GTK does not set any border, and they look bad with GTK. */
513 f
->output_data
.x
->border_width
= 0;
514 f
->output_data
.x
->internal_border_width
= 0;
521 /* Set the normal size hints for the window manager, for frame F.
522 FLAGS is the flags word to use--or 0 meaning preserve the flags
523 that the window now has.
524 If USER_POSITION is nonzero, we set the User Position
525 flag (this is useful when FLAGS is 0). */
527 x_wm_set_size_hint (f
, flags
, user_position
)
532 if (FRAME_GTK_OUTER_WIDGET (f
))
534 /* Must use GTK routines here, otherwise GTK resets the size hints
535 to its own defaults. */
536 GdkGeometry size_hints
;
538 int base_width
, base_height
;
539 int min_rows
= 0, min_cols
= 0;
540 int win_gravity
= f
->output_data
.x
->win_gravity
;
544 memset (&size_hints
, 0, sizeof (size_hints
));
545 f
->output_data
.x
->size_hints
= size_hints
;
546 f
->output_data
.x
->hint_flags
= hint_flags
;
549 flags
= f
->output_data
.x
->size_hint_flags
;
551 size_hints
= f
->output_data
.x
->size_hints
;
552 hint_flags
= f
->output_data
.x
->hint_flags
;
554 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
555 size_hints
.width_inc
= FONT_WIDTH (f
->output_data
.x
->font
);
556 size_hints
.height_inc
= f
->output_data
.x
->line_height
;
558 hint_flags
|= GDK_HINT_BASE_SIZE
;
559 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
560 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0)
561 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
563 check_frame_size (f
, &min_rows
, &min_cols
);
565 size_hints
.base_width
= base_width
;
566 size_hints
.base_height
= base_height
;
567 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
568 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
571 /* These currently have a one to one mapping with the X values, but I
572 don't think we should rely on that. */
573 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
574 size_hints
.win_gravity
= 0;
575 if (win_gravity
== NorthWestGravity
)
576 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
577 else if (win_gravity
== NorthGravity
)
578 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
579 else if (win_gravity
== NorthEastGravity
)
580 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
581 else if (win_gravity
== WestGravity
)
582 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
583 else if (win_gravity
== CenterGravity
)
584 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
585 else if (win_gravity
== EastGravity
)
586 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
587 else if (win_gravity
== SouthWestGravity
)
588 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
589 else if (win_gravity
== SouthGravity
)
590 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
591 else if (win_gravity
== SouthEastGravity
)
592 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
593 else if (win_gravity
== StaticGravity
)
594 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
596 if (flags
& PPosition
) hint_flags
|= GDK_HINT_POS
;
597 if (flags
& USPosition
) hint_flags
|= GDK_HINT_USER_POS
;
598 if (flags
& USSize
) hint_flags
|= GDK_HINT_USER_SIZE
;
602 hint_flags
&= ~GDK_HINT_POS
;
603 hint_flags
|= GDK_HINT_USER_POS
;
608 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
609 FRAME_GTK_OUTER_WIDGET (f
),
613 f
->output_data
.x
->size_hints
= size_hints
;
614 f
->output_data
.x
->hint_flags
= hint_flags
;
619 /* Change background color of a frame.
620 Since GTK uses the background colour to clear the window, we must
621 keep the GTK and X colors in sync.
622 F is the frame to change,
623 BG is the pixel value to change to. */
625 xg_set_background_color (f
, bg
)
629 if (FRAME_GTK_WIDGET (f
))
634 xg_pix_to_gcolor (FRAME_GTK_WIDGET (f
), bg
, &gdk_bg
);
635 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &gdk_bg
);
642 /***********************************************************************
644 ***********************************************************************/
645 /* Return the dialog title to use for a dialog of type KEY.
646 This is the encoding used by lwlib. We use the same for GTK. */
648 get_dialog_title (char key
)
658 title
= "Information";
677 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
678 the dialog, but return TRUE so the event does not propagate further
679 in GTK. This prevents GTK from destroying the dialog widget automatically
680 and we can always destrou the widget manually, regardles of how
681 it was popped down (button press or WM_DELETE_WINDOW).
682 W is the dialog widget.
683 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
684 user_data is NULL (not used).
686 Returns TRUE to end propagation of event. */
688 dialog_delete_callback (w
, event
, user_data
)
693 gtk_widget_unmap (w
);
697 /* Create a popup dialog window. See also xg_create_widget below.
698 WV is a widget_value describing the dialog.
699 SELECT_CB is the callback to use when a button has been pressed.
700 DEACTIVATE_CB is the callback to use when the dialog pops down.
702 Returns the GTK dialog widget. */
704 create_dialog (wv
, select_cb
, deactivate_cb
)
707 GCallback deactivate_cb
;
709 char *title
= get_dialog_title (wv
->name
[0]);
710 int total_buttons
= wv
->name
[1] - '0';
711 int right_buttons
= wv
->name
[4] - '0';
714 int button_spacing
= 10;
715 GtkWidget
*wdialog
= gtk_dialog_new ();
720 GtkWidget
*whbox_down
;
722 /* If the number of buttons is greater than 4, make two rows of buttons
723 instead. This looks better. */
724 int make_two_rows
= total_buttons
> 4;
726 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
727 left_buttons
= total_buttons
- right_buttons
;
729 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
730 gtk_widget_set_name (wdialog
, "emacs-dialog");
732 cur_box
= GTK_BOX (GTK_DIALOG (wdialog
)->action_area
);
736 wvbox
= gtk_vbox_new (TRUE
, button_spacing
);
737 whbox_up
= gtk_hbox_new (FALSE
, 0);
738 whbox_down
= gtk_hbox_new (FALSE
, 0);
740 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
741 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
742 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
744 cur_box
= GTK_BOX (whbox_up
);
747 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
748 G_CALLBACK (dialog_delete_callback
), 0);
752 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
753 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
756 for (item
= wv
->contents
; item
; item
= item
->next
)
758 char *utf8_label
= get_utf8_string (item
->value
);
762 if (item
->name
&& strcmp (item
->name
, "message") == 0)
764 /* This is the text part of the dialog. */
765 w
= gtk_label_new (utf8_label
);
766 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
769 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
), w
,
771 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
773 /* Try to make dialog look better. Must realize first so
774 the widget can calculate the size it needs. */
775 gtk_widget_realize (w
);
776 gtk_widget_size_request (w
, &req
);
777 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog
)->vbox
),
779 if (item
->value
&& strlen (item
->value
) > 0)
780 button_spacing
= 2*req
.width
/strlen (item
->value
);
784 /* This is one button to add to the dialog. */
785 w
= gtk_button_new_with_mnemonic (utf8_label
);
787 gtk_widget_set_sensitive (w
, FALSE
);
789 g_signal_connect (G_OBJECT (w
), "clicked",
790 select_cb
, item
->call_data
);
792 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
793 if (++button_nr
== left_buttons
)
796 cur_box
= GTK_BOX (whbox_down
);
798 gtk_box_pack_start (cur_box
,
805 if (utf8_label
&& utf8_label
!= item
->value
)
821 /* Callback function invoked when the Ok button is pressed in
823 W is the file dialog widget,
824 ARG points to an integer where we record what has happend. */
826 xg_file_sel_ok (w
, arg
)
830 *(int*)arg
= XG_FILE_OK
;
833 /* Callback function invoked when the Cancel button is pressed in
835 W is the file dialog widget,
836 ARG points to an integer where we record what has happend. */
838 xg_file_sel_cancel (w
, arg
)
842 *(int*)arg
= XG_FILE_CANCEL
;
845 /* Callback function invoked when the file dialog is destroyed (i.e.
846 popped down). We must keep track of this, because if this
847 happens, GTK destroys the widget. But if for example, Ok is pressed,
848 the dialog is popped down, but the dialog widget is not destroyed.
849 W is the file dialog widget,
850 ARG points to an integer where we record what has happend. */
852 xg_file_sel_destroy (w
, arg
)
856 *(int*)arg
= XG_FILE_DESTROYED
;
859 /* Read a file name from the user using a file dialog.
860 F is the current frame.
861 PROMPT is a prompt to show to the user. May not be NULL.
862 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
863 If MUSTMATCH_P is non-zero, the returned file name must be an existing
866 Returns a file name or NULL if no file was selected.
867 The returned string must be freed by the caller. */
869 xg_get_file_name (f
, prompt
, default_filename
, mustmatch_p
)
872 char *default_filename
;
876 GtkFileSelection
*filesel
;
877 int filesel_done
= XG_FILE_NOT_DONE
;
880 filewin
= gtk_file_selection_new (prompt
);
881 filesel
= GTK_FILE_SELECTION (filewin
);
883 gtk_widget_set_name (filewin
, "emacs-filedialog");
885 gtk_window_set_transient_for (GTK_WINDOW (filewin
),
886 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
887 gtk_window_set_destroy_with_parent (GTK_WINDOW (filewin
), TRUE
);
889 g_signal_connect (G_OBJECT (filesel
->ok_button
),
891 G_CALLBACK (xg_file_sel_ok
),
893 g_signal_connect (G_OBJECT (filesel
->cancel_button
),
895 G_CALLBACK (xg_file_sel_cancel
),
897 g_signal_connect (G_OBJECT (filesel
),
899 G_CALLBACK (xg_file_sel_destroy
),
902 if (default_filename
)
903 gtk_file_selection_set_filename (filesel
, default_filename
);
907 /* The selection_entry part of filesel is not documented. */
908 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
909 gtk_file_selection_hide_fileop_buttons (filesel
);
913 gtk_widget_show_all (filewin
);
915 while (filesel_done
== XG_FILE_NOT_DONE
)
916 gtk_main_iteration ();
918 if (filesel_done
== XG_FILE_OK
)
919 fn
= xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
921 if (filesel_done
!= XG_FILE_DESTROYED
)
922 gtk_widget_destroy (filewin
);
928 /***********************************************************************
930 ***********************************************************************/
932 /* The name of menu items that can be used for citomization. Since GTK
933 RC files are very crude and primitive, we have to set this on all
934 menu item names so a user can easily cutomize menu items. */
936 #define MENU_ITEM_NAME "emacs-menuitem"
939 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
940 during GC. The next member points to the items. */
941 static xg_list_node xg_menu_cb_list
;
943 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
944 during GC. The next member points to the items. */
945 static xg_list_node xg_menu_item_cb_list
;
947 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
948 F is the frame CL_DATA will be initialized for.
949 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
951 The menu bar and all sub menus under the menu bar in a frame
952 share the same structure, hence the reference count.
954 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
955 allocated xg_menu_cb_data if CL_DATA is NULL. */
956 static xg_menu_cb_data
*
957 make_cl_data (cl_data
, f
, highlight_cb
)
958 xg_menu_cb_data
*cl_data
;
960 GCallback highlight_cb
;
964 cl_data
= (xg_menu_cb_data
*) xmalloc (sizeof (*cl_data
));
966 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
967 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
968 cl_data
->highlight_cb
= highlight_cb
;
969 cl_data
->ref_count
= 0;
971 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
974 cl_data
->ref_count
++;
979 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
980 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
982 When the menu bar is updated, menu items may have been added and/or
983 removed, so menu_bar_vector and menu_bar_items_used change. We must
984 then update CL_DATA since it is used to determine which menu
985 item that is invoked in the menu.
986 HIGHLIGHT_CB could change, there is no check that the same
987 function is given when modifying a menu bar as was given when
988 creating the menu bar. */
990 update_cl_data (cl_data
, f
, highlight_cb
)
991 xg_menu_cb_data
*cl_data
;
993 GCallback highlight_cb
;
998 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
999 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
1000 cl_data
->highlight_cb
= highlight_cb
;
1004 /* Decrease reference count for CL_DATA.
1005 If reference count is zero, free CL_DATA. */
1007 unref_cl_data (cl_data
)
1008 xg_menu_cb_data
*cl_data
;
1010 if (cl_data
&& cl_data
->ref_count
> 0)
1012 cl_data
->ref_count
--;
1013 if (cl_data
->ref_count
== 0)
1015 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
1021 /* Function that marks all lisp data during GC. */
1027 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
1028 mark_object (&((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
1030 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
1032 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
1034 if (! NILP (cb_data
->help
))
1035 mark_object (&cb_data
->help
);
1040 /* Callback called when a menu item is destroyed. Used to free data.
1041 W is the widget that is being destroyed (not used).
1042 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
1044 menuitem_destroy_callback (w
, client_data
)
1046 gpointer client_data
;
1050 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1051 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
1056 /* Callback called when the pointer enters/leaves a menu item.
1058 EVENT is either an enter event or leave event.
1059 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W.
1061 Returns FALSE to tell GTK to keep processing this event. */
1063 menuitem_highlight_callback (w
, event
, client_data
)
1065 GdkEventCrossing
*event
;
1066 gpointer client_data
;
1070 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
1071 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : client_data
;
1073 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
1075 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
1076 (*func
) (w
, call_data
);
1083 /* Callback called when a menu is destroyed. Used to free data.
1084 W is the widget that is being destroyed (not used).
1085 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
1087 menu_destroy_callback (w
, client_data
)
1089 gpointer client_data
;
1091 unref_cl_data ((xg_menu_cb_data
*) client_data
);
1094 /* Callback called when a menu does a grab or ungrab. That means the
1095 menu has been activated or deactivated.
1096 Used to start a timer so the small timeout the menus in GTK uses before
1097 popping down a menu is seen by Emacs (see xg_process_timeouts above).
1098 W is the widget that does the grab (not used).
1099 UNGRAB_P is TRUE if this is an ungrab, FALSE if it is a grab.
1100 CLIENT_DATA is NULL (not used). */
1102 menu_grab_callback (GtkWidget
*widget
,
1104 gpointer client_data
)
1106 /* Keep track of total number of grabs. */
1109 if (ungrab_p
) cnt
--;
1112 if (cnt
> 0 && ! xg_timer
) xg_start_timer ();
1113 else if (cnt
== 0 && xg_timer
) xg_stop_timer ();
1116 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
1117 must be non-NULL) and can be inserted into a menu item.
1119 Returns the GtkHBox. */
1121 make_widget_for_menu_item (utf8_label
, utf8_key
)
1129 wbox
= gtk_hbox_new (FALSE
, 0);
1130 wlbl
= gtk_label_new_with_mnemonic (utf8_label
);
1131 wkey
= gtk_label_new (utf8_key
);
1133 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
1134 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
1136 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
1137 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
1139 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
1140 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
1145 /* Make and return a menu item widget with the key to the right.
1146 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
1147 UTF8_KEY is the text representing the key binding.
1148 ITEM is the widget_value describing the menu item.
1150 GROUP is an in/out parameter. If the menu item to be created is not
1151 part of any radio menu group, *GROUP contains NULL on entry and exit.
1152 If the menu item to be created is part of a radio menu group, on entry
1153 *GROUP contains the group to use, or NULL if this is the first item
1154 in the group. On exit, *GROUP contains the radio item group.
1156 Unfortunately, keys don't line up as nicely as in Motif,
1157 but the MacOS X version doesn't either, so I guess that is OK. */
1159 make_menu_item (utf8_label
, utf8_key
, item
, group
)
1166 GtkWidget
*wtoadd
= 0;
1169 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1171 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
1174 if (utf8_key
) w
= gtk_check_menu_item_new ();
1175 else w
= gtk_check_menu_item_new_with_mnemonic (utf8_label
);
1176 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
1178 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
1180 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
1181 else w
= gtk_radio_menu_item_new_with_mnemonic (*group
, utf8_label
);
1182 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
1184 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
1189 if (utf8_key
) w
= gtk_menu_item_new ();
1190 else w
= gtk_menu_item_new_with_mnemonic (utf8_label
);
1193 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1194 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
1199 /* Return non-zero if NAME specifies a separator (GTK only has one
1202 xg_separator_p (char *name
)
1204 if (! name
) return 0;
1206 return strcmp (name
, "--") == 0
1207 || strncmp (name
, "--:", 3) == 0
1208 || strcmp (name
, "---") == 0;
1211 GtkWidget
*xg_did_tearoff
;
1213 /* Callback invoked when a detached menu window is removed. Here we
1214 delete the popup menu.
1215 WIDGET is the top level window that is removed (the parent of the menu).
1216 EVENT is the event that triggers the window removal.
1217 CLIENT_DATA points to the menu that is detached.
1219 Returns TRUE to tell GTK to stop processing this event. */
1221 tearoff_remove (widget
, event
, client_data
)
1224 gpointer client_data
;
1226 gtk_widget_destroy (GTK_WIDGET (client_data
));
1230 /* Callback invoked when a menu is detached. It sets the xg_did_tearoff
1232 WIDGET is the GtkTearoffMenuItem.
1233 CLIENT_DATA is not used. */
1235 tearoff_activate (widget
, client_data
)
1237 gpointer client_data
;
1239 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
1240 if (! gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
1243 xg_did_tearoff
= menu
;
1246 /* If a detach of a popup menu is done, this function should be called
1247 to keep the menu around until the detached window is removed.
1248 MENU is the top level menu for the popup,
1249 SUBMENU is the menu that got detached (that is MENU or a
1250 submenu of MENU), see the xg_did_tearoff variable. */
1252 xg_keep_popup (menu
, submenu
)
1258 /* Find the top widget for the detached menu. */
1259 p
= gtk_widget_get_toplevel (submenu
);
1261 /* Delay destroying the menu until the detached menu is removed. */
1262 g_signal_connect (G_OBJECT (p
), "unmap_event",
1263 G_CALLBACK (tearoff_remove
), menu
);
1268 /* Create a menu item widget, and connect the callbacks.
1269 ITEM decribes the menu item.
1270 F is the frame the created menu belongs to.
1271 SELECT_CB is the callback to use when a menu item is selected.
1272 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1273 CL_DATA points to the callback data to be used for this menu.
1274 GROUP is an in/out parameter. If the menu item to be created is not
1275 part of any radio menu group, *GROUP contains NULL on entry and exit.
1276 If the menu item to be created is part of a radio menu group, on entry
1277 *GROUP contains the group to use, or NULL if this is the first item
1278 in the group. On exit, *GROUP contains the radio item group.
1280 Returns the created GtkWidget. */
1282 xg_create_one_menuitem (item
, f
, select_cb
, highlight_cb
, cl_data
, group
)
1285 GCallback select_cb
;
1286 GCallback highlight_cb
;
1287 xg_menu_cb_data
*cl_data
;
1293 xg_menu_item_cb_data
*cb_data
;
1295 utf8_label
= get_utf8_string (item
->name
);
1296 utf8_key
= get_utf8_string (item
->key
);
1298 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
1300 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
1301 if (utf8_key
&& utf8_key
!= item
->key
) g_free (utf8_key
);
1303 cb_data
= xmalloc (sizeof (xg_menu_item_cb_data
));
1305 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
1307 cb_data
->unhighlight_id
= cb_data
->highlight_id
= cb_data
->select_id
= 0;
1308 cb_data
->help
= item
->help
;
1309 cb_data
->cl_data
= cl_data
;
1310 cb_data
->call_data
= item
->call_data
;
1312 g_signal_connect (G_OBJECT (w
),
1314 G_CALLBACK (menuitem_destroy_callback
),
1317 /* Put cb_data in widget, so we can get at it when modifying menubar */
1318 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
1320 /* final item, not a submenu */
1321 if (item
->call_data
&& ! item
->contents
)
1325 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
1328 if (! NILP (item
->help
) && highlight_cb
)
1330 /* We use enter/leave notify instead of select/deselect because
1331 select/deselect doesn't go well with detached menus. */
1332 cb_data
->highlight_id
1333 = g_signal_connect (G_OBJECT (w
),
1334 "enter-notify-event",
1335 G_CALLBACK (menuitem_highlight_callback
),
1337 cb_data
->unhighlight_id
1338 = g_signal_connect (G_OBJECT (w
),
1339 "leave-notify-event",
1340 G_CALLBACK (menuitem_highlight_callback
),
1347 /* Create a full menu tree specified by DATA.
1348 F is the frame the created menu belongs to.
1349 SELECT_CB is the callback to use when a menu item is selected.
1350 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
1351 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1352 POP_UP_P is non-zero if we shall create a popup menu.
1353 MENU_BAR_P is non-zero if we shall create a menu bar.
1354 ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
1355 if MENU_BAR_P is non-zero.
1356 TOPMENU is the topmost GtkWidget that others shall be placed under.
1357 It may be NULL, in that case we create the appropriate widget
1358 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
1359 CL_DATA is the callback data we shall use for this menu, or NULL
1360 if we haven't set the first callback yet.
1361 NAME is the name to give to the top level menu if this function
1362 creates it. May be NULL to not set any name.
1364 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
1367 This function calls itself to create submenus. */
1370 create_menus (data
, f
, select_cb
, deactivate_cb
, highlight_cb
,
1371 pop_up_p
, menu_bar_p
, add_tearoff_p
, topmenu
, cl_data
, name
)
1374 GCallback select_cb
;
1375 GCallback deactivate_cb
;
1376 GCallback highlight_cb
;
1381 xg_menu_cb_data
*cl_data
;
1385 GtkWidget
*wmenu
= topmenu
;
1386 GSList
*group
= NULL
;
1390 if (! menu_bar_p
) wmenu
= gtk_menu_new ();
1391 else wmenu
= gtk_menu_bar_new ();
1393 /* Put cl_data on the top menu for easier access. */
1394 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
1395 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
1396 g_signal_connect (G_OBJECT (wmenu
), "destroy",
1397 G_CALLBACK (menu_destroy_callback
), cl_data
);
1400 gtk_widget_set_name (wmenu
, name
);
1403 g_signal_connect (G_OBJECT (wmenu
),
1404 "deactivate", deactivate_cb
, 0);
1406 g_signal_connect (G_OBJECT (wmenu
),
1407 "grab-notify", G_CALLBACK (menu_grab_callback
), 0);
1410 if (! menu_bar_p
&& add_tearoff_p
)
1412 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
1413 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
1415 g_signal_connect (G_OBJECT (tearoff
), "activate",
1416 G_CALLBACK (tearoff_activate
), 0);
1419 for (item
= data
; item
; item
= item
->next
)
1423 if (pop_up_p
&& !item
->contents
&& !item
->call_data
1424 && !xg_separator_p (item
->name
))
1427 /* A title for a popup. We do the same as GTK does when
1428 creating titles, but it does not look good. */
1430 utf8_label
= get_utf8_string (item
->name
);
1432 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
1433 w
= gtk_menu_item_new_with_mnemonic (utf8_label
);
1434 gtk_widget_set_sensitive (w
, FALSE
);
1435 if (utf8_label
&& utf8_label
!= item
->name
) g_free (utf8_label
);
1437 else if (xg_separator_p (item
->name
))
1440 /* GTK only have one separator type. */
1441 w
= gtk_separator_menu_item_new ();
1445 w
= xg_create_one_menuitem (item
,
1447 item
->contents
? 0 : select_cb
,
1454 GtkWidget
*submenu
= create_menus (item
->contents
,
1465 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
1469 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
1470 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
1476 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
1477 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
1478 with some text and buttons.
1479 F is the frame the created item belongs to.
1480 NAME is the name to use for the top widget.
1481 VAL is a widget_value structure describing items to be created.
1482 SELECT_CB is the callback to use when a menu item is selected or
1483 a dialog button is pressed.
1484 DEACTIVATE_CB is the callback to use when an item is deactivated.
1485 For a menu, when a sub menu is not shown anymore, for a dialog it is
1486 called when the dialog is popped down.
1487 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1489 Returns the widget created. */
1491 xg_create_widget (type
, name
, f
, val
,
1492 select_cb
, deactivate_cb
, highlight_cb
)
1497 GCallback select_cb
;
1498 GCallback deactivate_cb
;
1499 GCallback highlight_cb
;
1502 if (strcmp (type
, "dialog") == 0)
1504 w
= create_dialog (val
, select_cb
, deactivate_cb
);
1505 gtk_window_set_transient_for (GTK_WINDOW (w
),
1506 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1507 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1510 gtk_widget_set_name (w
, "emacs-dialog");
1512 else if (strcmp (type
, "menubar") == 0 || strcmp (type
, "popup") == 0)
1514 w
= create_menus (val
->contents
,
1519 strcmp (type
, "popup") == 0,
1520 strcmp (type
, "menubar") == 0,
1526 /* Set the cursor to an arrow for popup menus when they are mapped.
1527 This is done by default for menu bar menus. */
1528 if (strcmp (type
, "popup") == 0)
1530 /* Must realize so the GdkWindow inside the widget is created. */
1531 gtk_widget_realize (w
);
1532 xg_set_cursor (w
, &xg_left_ptr_cursor
);
1537 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
1544 /* Return the label for menu item WITEM. */
1546 xg_get_menu_item_label (witem
)
1549 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
1550 return gtk_label_get_label (wlabel
);
1553 /* Return non-zero if the menu item WITEM has the text LABEL. */
1555 xg_item_label_same_p (witem
, label
)
1560 char *utf8_label
= get_utf8_string (label
);
1561 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
1563 if (! old_label
&& ! utf8_label
)
1565 else if (old_label
&& utf8_label
)
1566 is_same
= strcmp (utf8_label
, old_label
) == 0;
1568 if (utf8_label
&& utf8_label
!= label
) g_free (utf8_label
);
1573 /* Remove widgets in LIST from container WCONT. */
1575 remove_from_container (wcont
, list
)
1581 for (iter
= list
; iter
; iter
= g_list_next (iter
))
1583 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
1585 /* Add a ref to w so we can explicitly destroy it later. */
1587 gtk_container_remove (GTK_CONTAINER (wcont
), w
);
1589 /* If there is a menu under this widget that has been detached,
1590 there is a reference to it, and just removing w from the
1591 container does not destroy the submenu. By explicitly
1592 destroying w we make sure the submenu is destroyed, thus
1593 removing the detached window also if there was one. */
1594 gtk_widget_destroy (w
);
1598 /* Update the top level names in MENUBAR (i.e. not submenus).
1599 F is the frame the menu bar belongs to.
1600 *LIST is a list with the current menu bar names (menu item widgets).
1601 ITER is the item within *LIST that shall be updated.
1602 POS is the numerical position, starting at 0, of ITER in *LIST.
1603 VAL describes what the menu bar shall look like after the update.
1604 SELECT_CB is the callback to use when a menu item is selected.
1605 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1606 CL_DATA points to the callback data to be used for this menu bar.
1608 This function calls itself to walk through the menu bar names. */
1610 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
1611 select_cb
, highlight_cb
, cl_data
)
1618 GCallback select_cb
;
1619 GCallback highlight_cb
;
1620 xg_menu_cb_data
*cl_data
;
1622 if (! iter
&& ! val
)
1624 else if (iter
&& ! val
)
1626 /* Item(s) have been removed. Remove all remaining items. */
1627 remove_from_container (menubar
, iter
);
1633 else if (! iter
&& val
)
1635 /* Item(s) added. Add all new items in one call. */
1636 create_menus (val
, f
, select_cb
, 0, highlight_cb
,
1637 0, 1, 0, menubar
, cl_data
, 0);
1643 /* Below this neither iter or val is NULL */
1644 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
1646 /* This item is still the same, check next item. */
1648 iter
= g_list_next (iter
);
1651 else /* This item is changed. */
1653 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
1654 GtkMenuItem
*witem2
= 0;
1655 int val_in_menubar
= 0;
1656 int iter_in_new_menubar
= 0;
1660 /* See if the changed entry (val) is present later in the menu bar */
1662 iter2
&& ! val_in_menubar
;
1663 iter2
= g_list_next (iter2
))
1665 witem2
= GTK_MENU_ITEM (iter2
->data
);
1666 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
1669 /* See if the current entry (iter) is present later in the
1670 specification for the new menu bar. */
1671 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
1672 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
1674 if (val_in_menubar
&& ! iter_in_new_menubar
)
1678 /* This corresponds to:
1683 gtk_widget_ref (GTK_WIDGET (witem
));
1684 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
1685 gtk_widget_destroy (GTK_WIDGET (witem
));
1687 /* Must get new list since the old changed. */
1688 g_list_free (*list
);
1689 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
1690 while (nr
-- > 0) iter
= g_list_next (iter
);
1692 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
1694 /* This corresponds to:
1697 Rename B to X. This might seem to be a strange thing to do,
1698 since if there is a menu under B it will be totally wrong for X.
1699 But consider editing a C file. Then there is a C-mode menu
1700 (corresponds to B above).
1701 If then doing C-x C-f the minibuf menu (X above) replaces the
1702 C-mode menu. When returning from the minibuffer, we get
1703 back the C-mode menu. Thus we do:
1704 Rename B to X (C-mode to minibuf menu)
1705 Rename X to B (minibuf to C-mode menu).
1706 If the X menu hasn't been invoked, the menu under B
1707 is up to date when leaving the minibuffer. */
1708 GtkLabel
*wlabel
= GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem
)));
1709 char *utf8_label
= get_utf8_string (val
->name
);
1711 gtk_label_set_text_with_mnemonic (wlabel
, utf8_label
);
1713 iter
= g_list_next (iter
);
1717 else if (! val_in_menubar
&& iter_in_new_menubar
)
1719 /* This corresponds to:
1726 GtkWidget
*w
= xg_create_one_menuitem (val
,
1733 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
1734 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
1736 g_list_free (*list
);
1737 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
1738 while (nr
-- > 0) iter
= g_list_next (iter
);
1739 iter
= g_list_next (iter
);
1743 else /* if (val_in_menubar && iter_in_new_menubar) */
1746 /* This corresponds to:
1751 gtk_widget_ref (GTK_WIDGET (witem2
));
1752 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
1753 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
1754 GTK_WIDGET (witem2
), pos
);
1755 gtk_widget_unref (GTK_WIDGET (witem2
));
1757 g_list_free (*list
);
1758 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
1759 while (nr
-- > 0) iter
= g_list_next (iter
);
1765 /* Update the rest of the menu bar. */
1766 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
1767 select_cb
, highlight_cb
, cl_data
);
1770 /* Update the menu item W so it corresponds to VAL.
1771 SELECT_CB is the callback to use when a menu item is selected.
1772 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1773 CL_DATA is the data to set in the widget for menu invokation. */
1775 xg_update_menu_item (val
, w
, select_cb
, highlight_cb
, cl_data
)
1778 GCallback select_cb
;
1779 GCallback highlight_cb
;
1780 xg_menu_cb_data
*cl_data
;
1787 const char *old_label
= 0;
1788 const char *old_key
= 0;
1789 xg_menu_item_cb_data
*cb_data
;
1791 wchild
= gtk_bin_get_child (GTK_BIN (w
));
1792 utf8_label
= get_utf8_string (val
->name
);
1793 utf8_key
= get_utf8_string (val
->key
);
1795 /* See if W is a menu item with a key. See make_menu_item above. */
1796 if (GTK_IS_HBOX (wchild
))
1798 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
1800 wlbl
= GTK_LABEL (list
->data
);
1801 wkey
= GTK_LABEL (list
->next
->data
);
1806 /* Remove the key and keep just the label. */
1807 gtk_widget_ref (GTK_WIDGET (wlbl
));
1808 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
1809 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
1814 else /* Just a label. */
1816 wlbl
= GTK_LABEL (wchild
);
1818 /* Check if there is now a key. */
1821 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
1822 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
1824 wlbl
= GTK_LABEL (list
->data
);
1825 wkey
= GTK_LABEL (list
->next
->data
);
1828 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
1829 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
1834 if (wkey
) old_key
= gtk_label_get_label (wkey
);
1835 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
1837 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
1838 gtk_label_set_text (wkey
, utf8_key
);
1840 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
1841 gtk_label_set_text_with_mnemonic (wlbl
, utf8_label
);
1843 if (utf8_key
&& utf8_key
!= val
->key
) g_free (utf8_key
);
1844 if (utf8_label
&& utf8_label
!= val
->name
) g_free (utf8_label
);
1846 if (! val
->enabled
&& GTK_WIDGET_SENSITIVE (w
))
1847 gtk_widget_set_sensitive (w
, FALSE
);
1848 else if (val
->enabled
&& ! GTK_WIDGET_SENSITIVE (w
))
1849 gtk_widget_set_sensitive (w
, TRUE
);
1851 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
1855 cb_data
->call_data
= val
->call_data
;
1856 cb_data
->help
= val
->help
;
1857 cb_data
->cl_data
= cl_data
;
1859 /* We assume the callback functions don't change. */
1860 if (val
->call_data
&& ! val
->contents
)
1862 /* This item shall have a select callback. */
1863 if (! cb_data
->select_id
)
1865 = g_signal_connect (G_OBJECT (w
), "activate",
1866 select_cb
, cb_data
);
1868 else if (cb_data
->select_id
)
1870 g_signal_handler_disconnect (w
, cb_data
->select_id
);
1871 cb_data
->select_id
= 0;
1874 if (NILP (cb_data
->help
))
1876 /* Shall not have help. Remove if any existed previously. */
1877 if (cb_data
->highlight_id
)
1879 g_signal_handler_disconnect (G_OBJECT (w
),
1880 cb_data
->highlight_id
);
1881 cb_data
->highlight_id
= 0;
1883 if (cb_data
->unhighlight_id
)
1885 g_signal_handler_disconnect (G_OBJECT (w
),
1886 cb_data
->unhighlight_id
);
1887 cb_data
->unhighlight_id
= 0;
1890 else if (! cb_data
->highlight_id
&& highlight_cb
)
1892 /* Have help now, but didn't previously. Add callback. */
1893 cb_data
->highlight_id
1894 = g_signal_connect (G_OBJECT (w
),
1895 "enter-notify-event",
1896 G_CALLBACK (menuitem_highlight_callback
),
1898 cb_data
->unhighlight_id
1899 = g_signal_connect (G_OBJECT (w
),
1900 "leave-notify-event",
1901 G_CALLBACK (menuitem_highlight_callback
),
1907 /* Update the toggle menu item W so it corresponds to VAL. */
1909 xg_update_toggle_item (val
, w
)
1913 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
1916 /* Update the radio menu item W so it corresponds to VAL. */
1918 xg_update_radio_item (val
, w
)
1922 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
1925 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
1926 SUBMENU may be NULL, in that case a new menu is created.
1927 F is the frame the menu bar belongs to.
1928 VAL describes the contents of the menu bar.
1929 SELECT_CB is the callback to use when a menu item is selected.
1930 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
1931 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
1932 CL_DATA is the call back data to use for any newly created items.
1934 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
1938 xg_update_submenu (submenu
, f
, val
,
1939 select_cb
, deactivate_cb
, highlight_cb
, cl_data
)
1943 GCallback select_cb
;
1944 GCallback deactivate_cb
;
1945 GCallback highlight_cb
;
1946 xg_menu_cb_data
*cl_data
;
1948 GtkWidget
*newsub
= submenu
;
1952 int has_tearoff_p
= 0;
1953 GList
*first_radio
= 0;
1956 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
1958 for (cur
= val
, iter
= list
;
1960 iter
= g_list_next (iter
), cur
= cur
->next
)
1962 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
1964 /* Skip tearoff items, they have no counterpart in val. */
1965 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
1968 iter
= g_list_next (iter
);
1969 if (iter
) w
= GTK_WIDGET (iter
->data
);
1973 /* Remember first radio button in a group. If we get a mismatch in
1974 a radio group we must rebuild the whole group so that the connections
1975 in GTK becomes correct. */
1976 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
1978 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
1979 && ! GTK_IS_RADIO_MENU_ITEM (w
))
1982 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
1984 if (! xg_separator_p (cur
->name
))
1987 else if (GTK_IS_CHECK_MENU_ITEM (w
))
1989 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
1991 xg_update_toggle_item (cur
, w
);
1992 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
1994 else if (GTK_IS_RADIO_MENU_ITEM (w
))
1996 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
1998 xg_update_radio_item (cur
, w
);
1999 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2001 else if (GTK_IS_MENU_ITEM (w
))
2003 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
2006 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
2007 xg_separator_p (cur
->name
))
2010 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
2012 sub
= gtk_menu_item_get_submenu (witem
);
2013 if (sub
&& ! cur
->contents
)
2015 /* Not a submenu anymore. */
2016 gtk_widget_ref (sub
);
2017 gtk_menu_item_remove_submenu (witem
);
2018 gtk_widget_destroy (sub
);
2020 else if (cur
->contents
)
2024 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
2025 select_cb
, deactivate_cb
,
2026 highlight_cb
, cl_data
);
2028 /* If this item just became a submenu, we must set it. */
2030 gtk_menu_item_set_submenu (witem
, nsub
);
2035 /* Structural difference. Remove everything from here and down
2041 /* Remove widgets from first structual change. */
2044 /* If we are adding new menu items below, we must remove from
2045 first radio button so that radio groups become correct. */
2046 if (cur
&& first_radio
) remove_from_container (submenu
, first_radio
);
2047 else remove_from_container (submenu
, iter
);
2052 /* More items added. Create them. */
2053 newsub
= create_menus (cur
,
2066 if (list
) g_list_free (list
);
2071 /* Update the MENUBAR.
2072 F is the frame the menu bar belongs to.
2073 VAL describes the contents of the menu bar.
2074 If DEEP_P is non-zero, rebuild all but the top level menu names in
2075 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
2076 SELECT_CB is the callback to use when a menu item is selected.
2077 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2078 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
2080 xg_modify_menubar_widgets (menubar
, f
, val
, deep_p
,
2081 select_cb
, deactivate_cb
, highlight_cb
)
2086 GCallback select_cb
;
2087 GCallback deactivate_cb
;
2088 GCallback highlight_cb
;
2090 xg_menu_cb_data
*cl_data
;
2091 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2095 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
2100 widget_value
*cur
= val
->contents
;
2101 xg_update_menubar (menubar
, f
, &list
, list
, 0, cur
,
2102 select_cb
, highlight_cb
, cl_data
);
2108 /* Update all sub menus.
2109 We must keep the submenu names (GTK menu item widgets) since the
2110 X Window in the XEvent that activates the menu are those widgets. */
2112 /* Update cl_data, menu_item things in F may have changed. */
2113 update_cl_data (cl_data
, f
, highlight_cb
);
2115 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
2122 /* Find sub menu that corresponds to val and update it. */
2123 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2125 witem
= GTK_MENU_ITEM (iter
->data
);
2126 if (xg_item_label_same_p (witem
, cur
->name
))
2128 sub
= gtk_menu_item_get_submenu (witem
);
2133 newsub
= xg_update_submenu (sub
,
2140 /* sub may still be NULL. If we just updated non deep and added
2141 a new menu bar item, it has no sub menu yet. So we set the
2142 newly created sub menu under witem. */
2144 gtk_menu_item_set_submenu (witem
, newsub
);
2150 gtk_widget_show_all (menubar
);
2153 /* Recompute all the widgets of frame F, when the menu bar has been
2154 changed. Value is non-zero if widgets were updated. */
2157 xg_update_frame_menubar (f
)
2160 struct x_output
*x
= f
->output_data
.x
;
2163 if (!x
->menubar_widget
|| GTK_WIDGET_MAPPED (x
->menubar_widget
))
2168 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
2170 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
2172 gtk_widget_show_all (x
->menubar_widget
);
2173 gtk_widget_size_request (x
->menubar_widget
, &req
);
2175 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
2177 /* The height has changed, resize outer widget and set columns
2178 rows to what we had before adding the menu bar. */
2179 xg_resize_outer_widget (f
, FRAME_WIDTH (f
), FRAME_HEIGHT (f
));
2181 SET_FRAME_GARBAGED (f
);
2187 /* Get rid of the menu bar of frame F, and free its storage.
2188 This is used when deleting a frame, and when turning off the menu bar. */
2191 free_frame_menubar (f
)
2194 struct x_output
*x
= f
->output_data
.x
;
2196 if (x
->menubar_widget
)
2200 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
2201 /* The menubar and its children shall be deleted when removed from
2203 x
->menubar_widget
= 0;
2204 FRAME_MENUBAR_HEIGHT (f
) = 0;
2206 /* The height has changed, resize outer widget and set columns
2207 rows to what we had before removing the menu bar. */
2208 xg_resize_outer_widget (f
, FRAME_WIDTH (f
), FRAME_HEIGHT (f
));
2210 SET_FRAME_GARBAGED (f
);
2217 /***********************************************************************
2218 Scroll bar functions
2219 ***********************************************************************/
2222 /* Setting scroll bar values invokes the callback. Use this variable
2223 to indicate that callback should do nothing. */
2224 int xg_ignore_gtk_scrollbar
;
2226 /* After we send a scroll bar event, x_set_toolkit_scroll_bar_thumb will
2227 be called. For some reason that needs to be debugged, it gets called
2228 with bad values. Thus, we set this variable to ignore those calls. */
2229 int xg_ignore_next_thumb
;
2231 /* SET_SCROLL_BAR_X_WINDOW assumes the second argument fits in
2232 32 bits. But we want to store pointers, and they may be larger
2233 than 32 bits. Keep a mapping from integer index to widget pointers
2234 to get around the 32 bit limitation. */
2237 GtkWidget
**widgets
;
2242 /* Grow this much every time we need to allocate more */
2243 #define ID_TO_WIDGET_INCR 32
2245 /* Store the widget pointer W in id_to_widget and return the integer index. */
2247 xg_store_widget_in_map (w
)
2252 if (id_to_widget
.max_size
== id_to_widget
.used
)
2254 int new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
2256 id_to_widget
.widgets
= xrealloc (id_to_widget
.widgets
,
2257 sizeof (GtkWidget
*)*new_size
);
2259 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
2260 id_to_widget
.widgets
[i
] = 0;
2261 id_to_widget
.max_size
= new_size
;
2264 /* Just loop over the array and find a free place. After all,
2265 how many scroll bars are we creating? Should be a small number.
2266 The check above guarantees we will find a free place. */
2267 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
2269 if (! id_to_widget
.widgets
[i
])
2271 id_to_widget
.widgets
[i
] = w
;
2272 ++id_to_widget
.used
;
2278 /* Should never end up here */
2282 /* Remove pointer at IDX from id_to_widget.
2283 Called when scroll bar is destroyed. */
2285 xg_remove_widget_from_map (idx
)
2288 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2290 id_to_widget
.widgets
[idx
] = 0;
2291 --id_to_widget
.used
;
2295 /* Get the widget pointer at IDX from id_to_widget. */
2297 xg_get_widget_from_map (idx
)
2300 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
2301 return id_to_widget
.widgets
[idx
];
2306 /* Return the scrollbar id for X Window WID.
2307 Return -1 if WID not in id_to_widget. */
2309 xg_get_scroll_id_for_window (wid
)
2315 w
= xg_win_to_widget (wid
);
2319 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
2320 if (id_to_widget
.widgets
[idx
] == w
)
2327 /* Callback invoked when scroll bar WIDGET is destroyed.
2328 DATA is the index into id_to_widget for WIDGET.
2329 We free pointer to last scroll bar value here and remove the index. */
2331 xg_gtk_scroll_destroy (widget
, data
)
2338 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
2340 xg_remove_widget_from_map (id
);
2343 /* Callback for button press/release events. Used to start timer so that
2344 the scroll bar repetition timer in GTK gets handeled.
2345 WIDGET is the scroll bar widget the event is for (not used).
2346 EVENT contains the event.
2347 USER_DATA is 0 (not used).
2349 Returns FALSE to tell GTK that it shall continue propagate the event
2352 scroll_bar_button_cb (widget
, event
, user_data
)
2354 GdkEventButton
*event
;
2357 if (event
->type
== GDK_BUTTON_PRESS
&& ! xg_timer
)
2359 else if (event
->type
== GDK_BUTTON_RELEASE
&& xg_timer
)
2365 /* Create a scroll bar widget for frame F. Store the scroll bar
2367 SCROLL_CALLBACK is the callback to invoke when the value of the
2369 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
2370 to set resources for the widget. */
2372 xg_create_scroll_bar (f
, bar
, scroll_callback
, scroll_bar_name
)
2374 struct scroll_bar
*bar
;
2375 GCallback scroll_callback
;
2376 char *scroll_bar_name
;
2382 /* Page, step increment values are not so important here, they
2383 will be corrected in x_set_toolkit_scroll_bar_thumb. */
2384 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
2387 wscroll
= gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj
));
2388 gtk_widget_set_name (wscroll
, scroll_bar_name
);
2389 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
2391 scroll_id
= xg_store_widget_in_map (wscroll
);
2393 g_signal_connect (G_OBJECT (vadj
),
2397 g_signal_connect (G_OBJECT (wscroll
),
2399 G_CALLBACK (xg_gtk_scroll_destroy
),
2400 (gpointer
)scroll_id
);
2402 /* Connect to button press and button release to detect if any scroll bar
2404 g_signal_connect (G_OBJECT (wscroll
),
2405 "button-press-event",
2406 G_CALLBACK (scroll_bar_button_cb
),
2408 g_signal_connect (G_OBJECT (wscroll
),
2409 "button-release-event",
2410 G_CALLBACK (scroll_bar_button_cb
),
2413 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
),
2416 /* Set the cursor to an arrow. */
2417 xg_set_cursor (wscroll
, &xg_left_ptr_cursor
);
2419 SET_SCROLL_BAR_X_WINDOW (bar
, scroll_id
);
2422 /* Make the scroll bar represented by SCROLLBAR_ID visible. */
2424 xg_show_scroll_bar (scrollbar_id
)
2427 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
2429 gtk_widget_show (w
);
2432 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
2434 xg_remove_scroll_bar (f
, scrollbar_id
)
2438 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
2441 gtk_widget_destroy (w
);
2442 SET_FRAME_GARBAGED (f
);
2447 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
2449 TOP/LEFT are the new pixel positions where the bar shall appear.
2450 WIDTH, HEIGHT is the size in pixels the bar shall have. */
2452 xg_update_scrollbar_pos (f
, scrollbar_id
, top
, left
, width
, height
)
2461 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
2465 int gheight
= max (height
, 1);
2467 gtk_fixed_move (GTK_FIXED (f
->output_data
.x
->edit_widget
),
2468 wscroll
, left
, top
);
2470 gtk_widget_set_size_request (wscroll
, width
, gheight
);
2472 /* Must force out update so wscroll gets the resize.
2473 Otherwise, the gdk_window_clear clears the old window size. */
2474 gdk_window_process_all_updates ();
2476 /* The scroll bar doesn't explicitly redraw the whole window
2477 when a resize occurs. Since the scroll bar seems to be fixed
2478 in width it doesn't fill the space reserved, so we must clear
2479 the whole window. */
2480 gdk_window_clear (wscroll
->window
);
2482 /* Since we are not using a pure gtk event loop, we must force out
2483 pending update events with this call. */
2484 gdk_window_process_all_updates ();
2486 SET_FRAME_GARBAGED (f
);
2487 cancel_mouse_face (f
);
2491 /* Set the thumb size and position of scroll bar BAR. We are currently
2492 displaying PORTION out of a whole WHOLE, and our position POSITION. */
2494 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
2495 struct scroll_bar
*bar
;
2496 int portion
, position
, whole
;
2498 GtkWidget
*wscroll
= xg_get_widget_from_map (SCROLL_BAR_X_WINDOW (bar
));
2500 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2503 if (wscroll
&& ! xg_ignore_next_thumb
)
2510 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
2516 shown
= (gdouble
) portion
/ whole
;
2517 top
= (gdouble
) position
/ whole
;
2520 size
= shown
* whole
;
2521 size
= min (size
, whole
);
2522 size
= max (size
, 1);
2524 value
= top
* whole
;
2525 value
= min (value
, whole
- size
);
2526 value
= max (value
, XG_SB_MIN
);
2528 adj
->upper
= max (whole
, size
);
2529 adj
->page_size
= (int)size
;
2531 /* Assume a page increment is about 95% of the page size */
2532 adj
->page_increment
= (int) (0.95*adj
->page_size
);
2534 /* Assume all lines are equal. */
2535 adj
->step_increment
= portion
/ max (1, FRAME_HEIGHT (f
));
2537 /* gtk_range_set_value invokes the callback. Set
2538 ignore_gtk_scrollbar to make the callback do nothing */
2539 xg_ignore_gtk_scrollbar
= 1;
2540 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
2541 xg_ignore_gtk_scrollbar
= 0;
2544 /* Make sure the scroll bar is redrawn with new thumb */
2545 gtk_widget_queue_draw (wscroll
);
2546 gdk_window_process_all_updates ();
2547 xg_ignore_next_thumb
= 0;
2552 /***********************************************************************
2554 ***********************************************************************/
2555 /* The key for the data we put in the GtkImage widgets. The data is
2556 the image used by Emacs. We use this to see if we need to update
2557 the GtkImage with a new image. */
2558 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
2560 /* Callback function invoked when a tool bar item is pressed.
2561 W is the button widget in the tool bar that got pressed,
2562 CLIENT_DATA is an integer that is the index of the button in the
2563 tool bar. 0 is the first button. */
2565 xg_tool_bar_callback (w
, client_data
)
2567 gpointer client_data
;
2569 int idx
= (int)client_data
;
2570 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
2571 Lisp_Object key
, frame
;
2572 struct input_event event
;
2574 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
2577 idx
*= TOOL_BAR_ITEM_NSLOTS
;
2579 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
2580 XSETFRAME (frame
, f
);
2581 event
.kind
= TOOL_BAR_EVENT
;
2582 event
.frame_or_window
= frame
;
2584 kbd_buffer_store_event (&event
);
2586 event
.kind
= TOOL_BAR_EVENT
;
2587 event
.frame_or_window
= frame
;
2589 event
.modifiers
= 0; /* These are not available. */
2590 kbd_buffer_store_event (&event
);
2593 /* This callback is called when a tool bar is detached. We must set
2594 the height of the tool bar to zero when this happens so frame sizes
2595 are correctly calculated.
2596 WBOX is the handle box widget that enables detach/attach of the tool bar.
2597 W is the tool bar widget.
2598 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
2600 xg_tool_bar_detach_callback (wbox
, w
, client_data
)
2603 gpointer client_data
;
2605 FRAME_PTR f
= (FRAME_PTR
) client_data
;
2609 /* When detaching a tool bar, not everything dissapear. There are
2610 a few pixels left that are used to drop the tool bar back into
2612 int bw
= gtk_container_get_border_width (GTK_CONTAINER (wbox
));
2613 FRAME_TOOLBAR_HEIGHT (f
) = 2;
2615 /* The height has changed, resize outer widget and set columns
2616 rows to what we had before detaching the tool bar. */
2617 xg_resize_outer_widget (f
, FRAME_WIDTH (f
), FRAME_HEIGHT (f
));
2621 /* This callback is called when a tool bar is reattached. We must set
2622 the height of the tool bar when this happens so frame sizes
2623 are correctly calculated.
2624 WBOX is the handle box widget that enables detach/attach of the tool bar.
2625 W is the tool bar widget.
2626 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
2628 xg_tool_bar_attach_callback (wbox
, w
, client_data
)
2631 gpointer client_data
;
2633 FRAME_PTR f
= (FRAME_PTR
) client_data
;
2639 gtk_widget_size_request (w
, &req
);
2640 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
2642 /* The height has changed, resize outer widget and set columns
2643 rows to what we had before detaching the tool bar. */
2644 xg_resize_outer_widget (f
, FRAME_WIDTH (f
), FRAME_HEIGHT (f
));
2648 /* This callback is called when the mouse enters or leaves a tool bar item.
2649 It is used for displaying and hiding the help text.
2650 W is the tool bar item, a button.
2651 EVENT is either an enter event or leave event.
2652 CLIENT_DATA is an integer that is the index of the button in the
2653 tool bar. 0 is the first button.
2655 Returns FALSE to tell GTK to keep processing this event. */
2657 xg_tool_bar_help_callback (w
, event
, client_data
)
2659 GdkEventCrossing
*event
;
2660 gpointer client_data
;
2662 int idx
= (int)client_data
;
2663 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
2664 Lisp_Object help
, frame
;
2666 if (! GTK_IS_BUTTON (w
))
2671 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
2674 if (event
->type
== GDK_ENTER_NOTIFY
)
2676 idx
*= TOOL_BAR_ITEM_NSLOTS
;
2677 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
2680 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
2685 XSETFRAME (frame
, f
);
2686 kbd_buffer_store_help_event (frame
, help
);
2692 /* This callback is called when a tool bar item shall be redrawn.
2693 It modifies the expose event so that the GtkImage widget redraws the
2694 whole image. This to overcome a bug that makes GtkImage draw the image
2695 in the wrong place when it tries to redraw just a part of the image.
2696 W is the GtkImage to be redrawn.
2697 EVENT is the expose event for W.
2698 CLIENT_DATA is unused.
2700 Returns FALSE to tell GTK to keep processing this event. */
2702 xg_tool_bar_item_expose_callback (w
, event
, client_data
)
2704 GdkEventExpose
*event
;
2705 gpointer client_data
;
2707 event
->area
.x
= event
->area
.y
= 0;
2708 event
->area
.width
= event
->area
.height
= 1000;
2712 /* This callback is called when a tool bar shall be redrawn.
2713 We need to update the tool bar from here in case the image cache
2714 has deleted the pixmaps used in the tool bar.
2715 W is the GtkToolbar to be redrawn.
2716 EVENT is the expose event for W.
2717 CLIENT_DATA is pointing to the frame for this tool bar.
2719 Returns FALSE to tell GTK to keep processing this event. */
2721 xg_tool_bar_expose_callback (w
, event
, client_data
)
2723 GdkEventExpose
*event
;
2724 gpointer client_data
;
2726 update_frame_tool_bar((FRAME_PTR
)client_data
);
2731 xg_create_tool_bar (f
)
2734 struct x_output
*x
= f
->output_data
.x
;
2736 int vbox_pos
= x
->menubar_widget
? 1 : 0;
2738 x
->toolbar_widget
= gtk_toolbar_new ();
2739 x
->handlebox_widget
= gtk_handle_box_new ();
2740 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
2743 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
2746 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
2749 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
2751 /* We only have icons, so override any user setting. We could
2752 use the caption property of the toolbar item (see update_frame_tool_bar
2753 below), but some of those strings are long, making the toolbar so
2754 long it does not fit on the screen. The GtkToolbar widget makes every
2755 item equal size, so the longest caption determine the size of every
2756 tool bar item. I think the creators of the GtkToolbar widget
2757 counted on 4 or 5 character long strings. */
2758 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
2759 gtk_toolbar_set_orientation (GTK_TOOLBAR (x
->toolbar_widget
),
2760 GTK_ORIENTATION_HORIZONTAL
);
2762 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
2763 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
2764 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
2765 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
2766 g_signal_connect (G_OBJECT (x
->toolbar_widget
),
2768 G_CALLBACK (xg_tool_bar_expose_callback
),
2771 gtk_widget_show_all (x
->handlebox_widget
);
2773 gtk_widget_size_request (x
->toolbar_widget
, &req
);
2774 FRAME_TOOLBAR_HEIGHT (f
) = req
.height
;
2776 /* The height has changed, resize outer widget and set columns
2777 rows to what we had before adding the tool bar. */
2778 xg_resize_outer_widget (f
, FRAME_WIDTH (f
), FRAME_HEIGHT (f
));
2780 SET_FRAME_GARBAGED (f
);
2784 update_frame_tool_bar (f
)
2788 GtkRequisition old_req
, new_req
;
2791 struct x_output
*x
= f
->output_data
.x
;
2793 if (! FRAME_GTK_WIDGET (f
))
2798 if (! x
->toolbar_widget
)
2799 xg_create_tool_bar (f
);
2801 gtk_widget_size_request (x
->toolbar_widget
, &old_req
);
2803 icon_list
= gtk_container_get_children (GTK_CONTAINER (x
->toolbar_widget
));
2806 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
2808 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
2810 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
2811 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
2816 GtkWidget
*wicon
= iter
? GTK_WIDGET (iter
->data
) : 0;
2818 if (iter
) iter
= g_list_next (iter
);
2820 /* If image is a vector, choose the image according to the
2822 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
2823 if (VECTORP (image
))
2827 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
2828 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
2831 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
2832 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
2834 xassert (ASIZE (image
) >= idx
);
2835 image
= AREF (image
, idx
);
2840 /* Ignore invalid image specifications. */
2841 if (!valid_image_p (image
))
2843 if (wicon
) gtk_widget_hide (wicon
);
2847 img_id
= lookup_image (f
, image
);
2848 img
= IMAGE_FROM_ID (f
, img_id
);
2849 prepare_image_for_display (f
, img
);
2851 if (img
->load_failed_p
|| img
->pixmap
== None
)
2853 if (wicon
) gtk_widget_hide (wicon
);
2859 GdkPixmap
*gpix
= gdk_pixmap_foreign_new (img
->pixmap
);
2860 GdkBitmap
*gmask
= img
->mask
?
2861 (GdkBitmap
*) gdk_pixmap_foreign_new (img
->mask
) : 0;
2863 GtkWidget
*w
= gtk_image_new_from_pixmap (gpix
, gmask
);
2864 gtk_toolbar_append_item (GTK_TOOLBAR (x
->toolbar_widget
),
2867 GTK_SIGNAL_FUNC (xg_tool_bar_callback
),
2870 /* Save the image so we can see if an update is needed when
2871 this function is called again. */
2872 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
2873 (gpointer
)img
->pixmap
);
2875 /* Catch expose events to overcome an annoying redraw bug, see
2876 comment for xg_tool_bar_item_expose_callback. */
2877 g_signal_connect (G_OBJECT (w
),
2879 G_CALLBACK (xg_tool_bar_item_expose_callback
),
2882 /* We must set sensitive on the button that is the parent
2883 of the GtkImage parent. Go upwards until we find the button. */
2884 while (! GTK_IS_BUTTON (w
))
2885 w
= gtk_widget_get_parent (w
);
2889 /* Save the frame in the button so the xg_tool_bar_callback
2891 g_object_set_data (G_OBJECT (w
), XG_FRAME_DATA
, (gpointer
)f
);
2892 gtk_widget_set_sensitive (w
, enabled_p
);
2894 /* Use enter/leave notify to show help. We use the events
2895 rather than the GtkButton specific signals "enter" and
2896 "leave", so we can have only one callback. The event
2897 will tell us what kind of event it is. */
2898 g_signal_connect (G_OBJECT (w
),
2899 "enter-notify-event",
2900 G_CALLBACK (xg_tool_bar_help_callback
),
2902 g_signal_connect (G_OBJECT (w
),
2903 "leave-notify-event",
2904 G_CALLBACK (xg_tool_bar_help_callback
),
2910 /* The child of the tool bar is a button. Inside that button
2911 is a vbox. Inside that vbox is the GtkImage. */
2912 GtkWidget
*wvbox
= gtk_bin_get_child (GTK_BIN (wicon
));
2913 GList
*chlist
= gtk_container_get_children (GTK_CONTAINER (wvbox
));
2914 GtkImage
*wimage
= GTK_IMAGE (chlist
->data
);
2915 Pixmap old_img
= (Pixmap
)g_object_get_data (G_OBJECT (wimage
),
2916 XG_TOOL_BAR_IMAGE_DATA
);
2917 g_list_free (chlist
);
2919 if (old_img
!= img
->pixmap
)
2921 GdkPixmap
*gpix
= gdk_pixmap_foreign_new (img
->pixmap
);
2922 GdkBitmap
*gmask
= img
->mask
?
2923 (GdkBitmap
*) gdk_pixmap_foreign_new (img
->mask
) : 0;
2925 gtk_image_set_from_pixmap (wimage
, gpix
, gmask
);
2928 g_object_set_data (G_OBJECT (wimage
), XG_TOOL_BAR_IMAGE_DATA
,
2929 (gpointer
)img
->pixmap
);
2931 gtk_widget_set_sensitive (wicon
, enabled_p
);
2932 gtk_widget_show (wicon
);
2938 /* Remove buttons not longer needed. We just hide them so they
2939 can be reused later on. */
2942 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2943 gtk_widget_hide (w
);
2944 iter
= g_list_next (iter
);
2947 gtk_widget_size_request (x
->toolbar_widget
, &new_req
);
2948 if (old_req
.height
!= new_req
.height
)
2950 FRAME_TOOLBAR_HEIGHT (f
) = new_req
.height
;
2951 xg_resize_outer_widget (f
, FRAME_WIDTH (f
), FRAME_HEIGHT (f
));
2954 /* Must force out update so changed images gets redrawn. */
2955 gdk_window_process_all_updates ();
2957 if (icon_list
) g_list_free (icon_list
);
2963 free_frame_tool_bar (f
)
2966 struct x_output
*x
= f
->output_data
.x
;
2968 if (x
->toolbar_widget
)
2971 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
2972 x
->handlebox_widget
);
2973 x
->toolbar_widget
= 0;
2974 x
->handlebox_widget
= 0;
2975 FRAME_TOOLBAR_HEIGHT (f
) = 0;
2977 /* The height has changed, resize outer widget and set columns
2978 rows to what we had before removing the tool bar. */
2979 xg_resize_outer_widget (f
, FRAME_WIDTH (f
), FRAME_HEIGHT (f
));
2981 SET_FRAME_GARBAGED (f
);
2988 /***********************************************************************
2990 ***********************************************************************/
2994 xg_ignore_gtk_scrollbar
= 0;
2995 xg_ignore_next_thumb
= 0;
2996 xg_left_ptr_cursor
= 0;
2999 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
3000 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
3002 id_to_widget
.max_size
= id_to_widget
.used
= 0;
3003 id_to_widget
.widgets
= 0;
3005 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
3006 bindings. It doesn't seem to be any way to remove properties,
3007 so we set it to VoidSymbol which in X means "no key". */
3008 gtk_settings_set_string_property (gtk_settings_get_default (),
3009 "gtk-menu-bar-accel",
3013 /* Make GTK text input widgets use Emacs style keybindings. This is
3015 gtk_settings_set_string_property (gtk_settings_get_default (),
3016 "gtk-key-theme-name",
3021 #endif /* USE_GTK */