1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
11 * Porting to GTK+ was done by:
13 * (C) 1998,1999,2000 by Marcin Dalecki <martin@dalecki.de>
15 * With GREAT support and continuous encouragements by Andy Kahn and of
16 * course Bram Moolenaar!
18 * Support for GTK+ 2 was added by:
20 * (C) 2002,2003 Jason Hildebrand <jason@peaceworks.ca>
21 * Daniel Elstner <daniel.elstner@gmx.net>
23 * Best supporting actor (He helped somewhat, aesthetically speaking):
24 * Maxime Romano <verbophobe@hotmail.com>
28 # include "gui_gtk_f.h"
31 /* GTK defines MAX and MIN, but some system header files as well. Undefine
32 * them and don't use them. */
43 /* Gnome redefines _() and N_(). Grrr... */
53 # ifdef bindtextdomain
54 # undef bindtextdomain
56 # if defined(FEAT_GETTEXT) && !defined(ENABLE_NLS)
57 # define ENABLE_NLS /* so the texts in the dialog boxes are translated */
62 #if defined(FEAT_GUI_DIALOG) && !defined(HAVE_GTK2)
63 # include "../pixmaps/alert.xpm"
64 # include "../pixmaps/error.xpm"
65 # include "../pixmaps/generic.xpm"
66 # include "../pixmaps/info.xpm"
67 # include "../pixmaps/quest.xpm"
70 #if defined(FEAT_TOOLBAR) && !defined(HAVE_GTK2)
72 * Icons used by the toolbar code.
74 #include "../pixmaps/tb_new.xpm"
75 #include "../pixmaps/tb_open.xpm"
76 #include "../pixmaps/tb_close.xpm"
77 #include "../pixmaps/tb_save.xpm"
78 #include "../pixmaps/tb_print.xpm"
79 #include "../pixmaps/tb_cut.xpm"
80 #include "../pixmaps/tb_copy.xpm"
81 #include "../pixmaps/tb_paste.xpm"
82 #include "../pixmaps/tb_find.xpm"
83 #include "../pixmaps/tb_find_next.xpm"
84 #include "../pixmaps/tb_find_prev.xpm"
85 #include "../pixmaps/tb_find_help.xpm"
86 #include "../pixmaps/tb_exit.xpm"
87 #include "../pixmaps/tb_undo.xpm"
88 #include "../pixmaps/tb_redo.xpm"
89 #include "../pixmaps/tb_help.xpm"
90 #include "../pixmaps/tb_macro.xpm"
91 #include "../pixmaps/tb_make.xpm"
92 #include "../pixmaps/tb_save_all.xpm"
93 #include "../pixmaps/tb_jump.xpm"
94 #include "../pixmaps/tb_ctags.xpm"
95 #include "../pixmaps/tb_load_session.xpm"
96 #include "../pixmaps/tb_save_session.xpm"
97 #include "../pixmaps/tb_new_session.xpm"
98 #include "../pixmaps/tb_blank.xpm"
99 #include "../pixmaps/tb_maximize.xpm"
100 #include "../pixmaps/tb_split.xpm"
101 #include "../pixmaps/tb_minimize.xpm"
102 #include "../pixmaps/tb_shell.xpm"
103 #include "../pixmaps/tb_replace.xpm"
104 #include "../pixmaps/tb_vsplit.xpm"
105 #include "../pixmaps/tb_maxwidth.xpm"
106 #include "../pixmaps/tb_minwidth.xpm"
107 #endif /* FEAT_TOOLBAR && !HAVE_GTK2 */
110 # include <gdk/gdkkeysyms.h>
111 # include <gdk/gdk.h>
113 # include <gdk/gdkwin32.h>
115 # include <gdk/gdkx.h>
118 # include <gtk/gtk.h>
120 /* define these items to be able to generate prototypes without GTK */
121 typedef int GtkWidget
;
122 # define gpointer int
124 # define GdkPixmap int
125 # define GdkBitmap int
126 # define GtkIconFactory int
127 # define GtkToolbar int
128 # define GtkAdjustment int
129 # define gboolean int
130 # define GdkEventKey int
131 # define CancelData int
134 static void entry_activate_cb(GtkWidget
*widget
, gpointer data
);
135 static void entry_changed_cb(GtkWidget
*entry
, GtkWidget
*dialog
);
136 static void find_replace_cb(GtkWidget
*widget
, gpointer data
);
138 static void gui_gtk_position_in_parent(GtkWidget
*parent
, GtkWidget
*child
, gui_win_pos_T where
);
141 #if defined(FEAT_TOOLBAR) && defined(HAVE_GTK2)
143 * Table from BuiltIn## icon indices to GTK+ stock IDs. Order must exactly
144 * match toolbar_names[] in menu.c! All stock icons including the "vim-*"
145 * ones can be overridden in your gtkrc file.
147 static const char * const menu_stock_ids
[] =
149 /* 00 */ GTK_STOCK_NEW
,
150 /* 01 */ GTK_STOCK_OPEN
,
151 /* 02 */ GTK_STOCK_SAVE
,
152 /* 03 */ GTK_STOCK_UNDO
,
153 /* 04 */ GTK_STOCK_REDO
,
154 /* 05 */ GTK_STOCK_CUT
,
155 /* 06 */ GTK_STOCK_COPY
,
156 /* 07 */ GTK_STOCK_PASTE
,
157 /* 08 */ GTK_STOCK_PRINT
,
158 /* 09 */ GTK_STOCK_HELP
,
159 /* 10 */ GTK_STOCK_FIND
,
160 /* 11 */ "vim-save-all",
161 /* 12 */ "vim-session-save",
162 /* 13 */ "vim-session-new",
163 /* 14 */ "vim-session-load",
164 /* 15 */ GTK_STOCK_EXECUTE
,
165 /* 16 */ GTK_STOCK_FIND_AND_REPLACE
,
166 /* 17 */ GTK_STOCK_CLOSE
, /* FIXME: fuzzy */
167 /* 18 */ "vim-window-maximize",
168 /* 19 */ "vim-window-minimize",
169 /* 20 */ "vim-window-split",
170 /* 21 */ "vim-shell",
171 /* 22 */ GTK_STOCK_GO_BACK
,
172 /* 23 */ GTK_STOCK_GO_FORWARD
,
173 /* 24 */ "vim-find-help",
174 /* 25 */ GTK_STOCK_CONVERT
,
175 /* 26 */ GTK_STOCK_JUMP_TO
,
176 /* 27 */ "vim-build-tags",
177 /* 28 */ "vim-window-split-vertical",
178 /* 29 */ "vim-window-maximize-width",
179 /* 30 */ "vim-window-minimize-width",
180 /* 31 */ GTK_STOCK_QUIT
184 add_stock_icon(GtkIconFactory
*factory
,
185 const char *stock_id
,
186 const guint8
*inline_data
,
190 GtkIconSet
*icon_set
;
192 pixbuf
= gdk_pixbuf_new_from_inline(data_length
, inline_data
, FALSE
, NULL
);
193 icon_set
= gtk_icon_set_new_from_pixbuf(pixbuf
);
195 gtk_icon_factory_add(factory
, stock_id
, icon_set
);
197 gtk_icon_set_unref(icon_set
);
198 g_object_unref(pixbuf
);
202 lookup_menu_iconfile(char_u
*iconfile
, char_u
*dest
)
204 expand_env(iconfile
, dest
, MAXPATHL
);
206 if (mch_isFullName(dest
))
208 return vim_fexists(dest
);
212 static const char suffixes
[][4] = {"png", "xpm", "bmp"};
213 char_u buf
[MAXPATHL
];
216 for (i
= 0; i
< G_N_ELEMENTS(suffixes
); ++i
)
217 if (gui_find_bitmap(dest
, buf
, (char *)suffixes
[i
]) == OK
)
228 load_menu_iconfile(char_u
*name
, GtkIconSize icon_size
)
230 GtkWidget
*image
= NULL
;
231 GtkIconSet
*icon_set
;
232 GtkIconSource
*icon_source
;
235 * Rather than loading the icon directly into a GtkImage, create
236 * a new GtkIconSet and put it in there. This way we can easily
237 * scale the toolbar icons on the fly when needed.
239 icon_set
= gtk_icon_set_new();
240 icon_source
= gtk_icon_source_new();
242 gtk_icon_source_set_filename(icon_source
, (const char *)name
);
243 gtk_icon_set_add_source(icon_set
, icon_source
);
245 image
= gtk_image_new_from_icon_set(icon_set
, icon_size
);
247 gtk_icon_source_free(icon_source
);
248 gtk_icon_set_unref(icon_set
);
254 create_menu_icon(vimmenu_T
*menu
, GtkIconSize icon_size
)
256 GtkWidget
*image
= NULL
;
257 char_u buf
[MAXPATHL
];
259 /* First use a specified "icon=" argument. */
260 if (menu
->iconfile
!= NULL
&& lookup_menu_iconfile(menu
->iconfile
, buf
))
261 image
= load_menu_iconfile(buf
, icon_size
);
263 /* If not found and not builtin specified try using the menu name. */
264 if (image
== NULL
&& !menu
->icon_builtin
265 && lookup_menu_iconfile(menu
->name
, buf
))
266 image
= load_menu_iconfile(buf
, icon_size
);
268 /* Still not found? Then use a builtin icon, a blank one as fallback. */
271 const char *stock_id
;
272 const int n_ids
= G_N_ELEMENTS(menu_stock_ids
);
274 if (menu
->iconidx
>= 0 && menu
->iconidx
< n_ids
)
275 stock_id
= menu_stock_ids
[menu
->iconidx
];
277 stock_id
= GTK_STOCK_MISSING_IMAGE
;
279 image
= gtk_image_new_from_stock(stock_id
, icon_size
);
287 toolbar_button_focus_in_event(GtkWidget
*widget
, GdkEventFocus
*event
, gpointer data
)
289 /* When we're in a GtkPlug, we don't have window focus events, only widget focus.
290 * To emulate stand-alone gvim, if a button gets focus (e.g., <Tab> into GtkPlug)
291 * immediately pass it to mainwin.
293 if (gtk_socket_id
!= 0)
294 gtk_widget_grab_focus(gui
.drawarea
);
298 #endif /* FEAT_TOOLBAR && HAVE_GTK2 */
300 #if (defined(FEAT_TOOLBAR) && defined(HAVE_GTK2)) || defined(PROTO)
303 gui_gtk_register_stock_icons(void)
305 # include "../pixmaps/stock_icons.h"
306 GtkIconFactory
*factory
;
308 factory
= gtk_icon_factory_new();
309 # define ADD_ICON(Name, Data) add_stock_icon(factory, Name, Data, (int)sizeof(Data))
311 ADD_ICON("vim-build-tags", stock_vim_build_tags
);
312 ADD_ICON("vim-find-help", stock_vim_find_help
);
313 ADD_ICON("vim-save-all", stock_vim_save_all
);
314 ADD_ICON("vim-session-load", stock_vim_session_load
);
315 ADD_ICON("vim-session-new", stock_vim_session_new
);
316 ADD_ICON("vim-session-save", stock_vim_session_save
);
317 ADD_ICON("vim-shell", stock_vim_shell
);
318 ADD_ICON("vim-window-maximize", stock_vim_window_maximize
);
319 ADD_ICON("vim-window-maximize-width", stock_vim_window_maximize_width
);
320 ADD_ICON("vim-window-minimize", stock_vim_window_minimize
);
321 ADD_ICON("vim-window-minimize-width", stock_vim_window_minimize_width
);
322 ADD_ICON("vim-window-split", stock_vim_window_split
);
323 ADD_ICON("vim-window-split-vertical", stock_vim_window_split_vertical
);
326 gtk_icon_factory_add_default(factory
);
327 g_object_unref(factory
);
330 #endif /* FEAT_TOOLBAR && HAVE_GTK2 */
334 * Only use accelerators when gtk_menu_ensure_uline_accel_group() is
335 * available, which is in version 1.2.1. That was the first version where
336 * accelerators properly worked (according to the change log).
338 #ifdef GTK_CHECK_VERSION
339 # if GTK_CHECK_VERSION(1, 2, 1)
340 # define GTK_USE_ACCEL
344 #if defined(FEAT_MENU) || defined(PROTO)
347 * Translate Vim's mnemonic tagging to GTK+ style and convert to UTF-8
348 * if necessary. The caller must vim_free() the returned string.
353 * & _ stripped if use_mnemonic == FALSE
354 * <Tab> end of menu label text
357 translate_mnemonic_tag(char_u
*name
, int use_mnemonic
)
362 int n_underscores
= 0;
365 name
= CONVERT_TO_UTF8(name
);
370 for (psrc
= name
; *psrc
!= NUL
&& *psrc
!= TAB
; ++psrc
)
374 buf
= alloc((unsigned)(psrc
- name
+ n_underscores
+ 1));
378 for (psrc
= name
; *psrc
!= NUL
&& *psrc
!= TAB
; ++psrc
)
385 else if (*psrc
!= '&')
389 else if (*(psrc
+ 1) == '&')
393 else if (use_mnemonic
)
402 CONVERT_TO_UTF8_FREE(name
);
410 menu_item_new(vimmenu_T
*menu
, GtkWidget
*parent_widget
)
416 /* It would be neat to have image menu items, but that would require major
417 * changes to Vim's menu system. Not to mention that all the translations
418 * had to be updated. */
419 menu
->id
= gtk_menu_item_new();
420 box
= gtk_hbox_new(FALSE
, 20);
422 use_mnemonic
= (p_wak
[0] != 'n' || !GTK_IS_MENU_BAR(parent_widget
));
423 text
= translate_mnemonic_tag(menu
->name
, use_mnemonic
);
425 menu
->label
= gtk_label_new_with_mnemonic((const char *)text
);
428 gtk_box_pack_start(GTK_BOX(box
), menu
->label
, FALSE
, FALSE
, 0);
430 if (menu
->actext
!= NULL
&& menu
->actext
[0] != NUL
)
432 text
= CONVERT_TO_UTF8(menu
->actext
);
434 gtk_box_pack_end(GTK_BOX(box
),
435 gtk_label_new((const char *)text
),
438 CONVERT_TO_UTF8_FREE(text
);
441 gtk_container_add(GTK_CONTAINER(menu
->id
), box
);
442 gtk_widget_show_all(menu
->id
);
445 # else /* !HAVE_GTK2 */
448 * Create a highly customized menu item by hand instead of by using:
450 * gtk_menu_item_new_with_label(menu->dname);
452 * This is neccessary, since there is no other way in GTK+ 1 to get the
453 * not automatically parsed accellerator stuff right.
456 menu_item_new(vimmenu_T
*menu
, GtkWidget
*parent_widget
)
464 widget
= gtk_widget_new(GTK_TYPE_MENU_ITEM
,
465 "GtkWidget::visible", TRUE
,
466 "GtkWidget::sensitive", TRUE
,
467 /* "GtkWidget::parent", parent->submenu_id, */
469 bin
= gtk_widget_new(GTK_TYPE_HBOX
,
470 "GtkWidget::visible", TRUE
,
471 "GtkWidget::parent", widget
,
472 "GtkBox::spacing", 16,
474 label
= gtk_widget_new(GTK_TYPE_ACCEL_LABEL
,
475 "GtkWidget::visible", TRUE
,
476 "GtkWidget::parent", bin
,
477 "GtkAccelLabel::accel_widget", widget
,
478 "GtkMisc::xalign", 0.0,
483 gtk_widget_new(GTK_TYPE_LABEL
,
484 "GtkWidget::visible", TRUE
,
485 "GtkWidget::parent", bin
,
486 "GtkLabel::label", menu
->actext
,
487 "GtkMisc::xalign", 1.0,
491 * Translate VIM accelerator tagging into GTK+'s. Note that since GTK uses
492 * underscores as the accelerator key, we need to add an additional under-
493 * score for each understore that appears in the menu name.
495 # ifdef GTK_USE_ACCEL
496 name
= translate_mnemonic_tag(menu
->name
,
497 (p_wak
[0] != 'n' || !GTK_IS_MENU_BAR(parent_widget
)));
499 name
= translate_mnemonic_tag(menu
->name
, FALSE
);
502 /* let GTK do its thing */
503 accel_key
= gtk_label_parse_uline(GTK_LABEL(label
), (const char *)name
);
506 # ifdef GTK_USE_ACCEL
507 /* Don't add accelator if 'winaltkeys' is "no". */
508 if (accel_key
!= GDK_VoidSymbol
)
510 if (GTK_IS_MENU_BAR(parent_widget
))
513 gtk_widget_add_accelerator(widget
,
516 accel_key
, GDK_MOD1_MASK
,
521 gtk_widget_add_accelerator(widget
,
523 gtk_menu_ensure_uline_accel_group(GTK_MENU(parent_widget
)),
528 # endif /* GTK_USE_ACCEL */
533 # endif /* !HAVE_GTK2 */
536 gui_mch_add_menu(vimmenu_T
*menu
, int idx
)
539 GtkWidget
*parent_widget
;
541 if (menu
->name
[0] == ']' || menu_is_popup(menu
->name
))
543 menu
->submenu_id
= gtk_menu_new();
547 parent
= menu
->parent
;
549 if ((parent
!= NULL
&& parent
->submenu_id
== NULL
)
550 || !menu_is_menubar(menu
->name
))
553 parent_widget
= (parent
!= NULL
) ? parent
->submenu_id
: gui
.menubar
;
554 menu_item_new(menu
, parent_widget
);
556 /* since the tearoff should always appear first, increment idx */
557 if (parent
!= NULL
&& !menu_is_popup(parent
->name
))
560 gtk_menu_shell_insert(GTK_MENU_SHELL(parent_widget
), menu
->id
, idx
);
564 * The "Help" menu is a special case, and should be placed at the far
565 * right hand side of the menu-bar. It's detected by its high priority.
567 * Right-aligning "Help" is considered bad UI design nowadays.
568 * Thus lets disable this for GTK+ 2 to match the environment.
570 if (parent
== NULL
&& menu
->priority
>= 9999)
571 gtk_menu_item_right_justify(GTK_MENU_ITEM(menu
->id
));
574 menu
->submenu_id
= gtk_menu_new();
576 gtk_menu_set_accel_group(GTK_MENU(menu
->submenu_id
), gui
.accel_group
);
577 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu
->id
), menu
->submenu_id
);
579 menu
->tearoff_handle
= gtk_tearoff_menu_item_new();
580 if (vim_strchr(p_go
, GO_TEAROFF
) != NULL
)
581 gtk_widget_show(menu
->tearoff_handle
);
582 gtk_menu_prepend(GTK_MENU(menu
->submenu_id
), menu
->tearoff_handle
);
587 menu_item_activate(GtkWidget
*widget
, gpointer data
)
589 gui_menu_cb((vimmenu_T
*)data
);
592 /* Work around a bug in GTK+ 1: we don't seem to get a focus-in
593 * event after clicking a menu item shown via :popup. */
595 gui_focus_change(TRUE
);
598 /* make sure the menu action is taken immediately */
599 if (gtk_main_level() > 0)
603 # if defined(FEAT_TOOLBAR) && !defined(HAVE_GTK2)
605 * These are the pixmaps used for the default buttons.
606 * Order must exactly match toolbar_names[] in menu.c!
608 static char **(built_in_pixmaps
[]) =
645 * creates a blank pixmap using tb_blank
648 pixmap_create_from_xpm(char **xpm
, GdkPixmap
**pixmap
, GdkBitmap
**mask
)
650 *pixmap
= gdk_pixmap_colormap_create_from_xpm_d(
652 gtk_widget_get_colormap(gui
.mainwin
),
659 * creates a pixmap by using a built-in number
662 pixmap_create_by_num(int pixmap_num
, GdkPixmap
**pixmap
, GdkBitmap
**mask
)
664 if (pixmap_num
>= 0 && pixmap_num
< (sizeof(built_in_pixmaps
)
665 / sizeof(built_in_pixmaps
[0])))
666 pixmap_create_from_xpm(built_in_pixmaps
[pixmap_num
], pixmap
, mask
);
670 * Creates a pixmap by using the pixmap "name" found in 'runtimepath'/bitmaps/
673 pixmap_create_by_dir(char_u
*name
, GdkPixmap
**pixmap
, GdkBitmap
**mask
)
675 char_u full_pathname
[MAXPATHL
+ 1];
677 if (gui_find_bitmap(name
, full_pathname
, "xpm") == OK
)
678 *pixmap
= gdk_pixmap_colormap_create_from_xpm(
680 gtk_widget_get_colormap(gui
.mainwin
),
682 &gui
.mainwin
->style
->bg
[GTK_STATE_NORMAL
],
683 (const char *)full_pathname
);
687 * Creates a pixmap by using the pixmap "fname".
690 pixmap_create_from_file(char_u
*fname
, GdkPixmap
**pixmap
, GdkBitmap
**mask
)
692 *pixmap
= gdk_pixmap_colormap_create_from_xpm(
694 gtk_widget_get_colormap(gui
.mainwin
),
696 &gui
.mainwin
->style
->bg
[GTK_STATE_NORMAL
],
697 (const char *)fname
);
700 # endif /* FEAT_TOOLBAR && !HAVE_GTK2 */
703 gui_mch_add_menu_item(vimmenu_T
*menu
, int idx
)
707 parent
= menu
->parent
;
710 if (menu_is_toolbar(parent
->name
))
714 toolbar
= GTK_TOOLBAR(gui
.toolbar
);
715 menu
->submenu_id
= NULL
;
717 if (menu_is_separator(menu
->name
))
719 gtk_toolbar_insert_space(toolbar
, idx
);
728 text
= CONVERT_TO_UTF8(menu
->dname
);
729 tooltip
= CONVERT_TO_UTF8(menu
->strings
[MENU_INDEX_TIP
]);
730 if (tooltip
!= NULL
&& !utf_valid_string(tooltip
, NULL
))
731 /* Invalid text, can happen when 'encoding' is changed. Avoid
732 * a nasty GTK error message, skip the tooltip. */
733 CONVERT_TO_UTF8_FREE(tooltip
);
735 menu
->id
= gtk_toolbar_insert_item(
738 (const char *)tooltip
,
740 create_menu_icon(menu
, gtk_toolbar_get_icon_size(toolbar
)),
741 G_CALLBACK(&menu_item_activate
),
745 if (gtk_socket_id
!= 0)
746 gtk_signal_connect(GTK_OBJECT(menu
->id
), "focus_in_event",
747 GTK_SIGNAL_FUNC(toolbar_button_focus_in_event
), NULL
);
749 CONVERT_TO_UTF8_FREE(text
);
750 CONVERT_TO_UTF8_FREE(tooltip
);
752 # else /* !HAVE_GTK2 */
754 GdkPixmap
*pixmap
= NULL
;
755 GdkBitmap
*mask
= NULL
;
757 /* First try user specified bitmap, then builtin, the a blank. */
758 if (menu
->iconfile
!= NULL
)
760 char_u buf
[MAXPATHL
+ 1];
762 gui_find_iconfile(menu
->iconfile
, buf
, "xpm");
763 pixmap_create_from_file(buf
, &pixmap
, &mask
);
765 if (pixmap
== NULL
&& !menu
->icon_builtin
)
766 pixmap_create_by_dir(menu
->name
, &pixmap
, &mask
);
767 if (pixmap
== NULL
&& menu
->iconidx
>= 0)
768 pixmap_create_by_num(menu
->iconidx
, &pixmap
, &mask
);
770 pixmap_create_from_xpm(tb_blank_xpm
, &pixmap
, &mask
);
772 return; /* should at least have blank pixmap, but if not... */
774 menu
->id
= gtk_toolbar_insert_item(
776 (char *)(menu
->dname
),
777 (char *)(menu
->strings
[MENU_INDEX_TIP
]),
778 (char *)(menu
->dname
),
779 gtk_pixmap_new(pixmap
, mask
),
780 GTK_SIGNAL_FUNC(menu_item_activate
),
783 # endif /* !HAVE_GTK2 */
787 # endif /* FEAT_TOOLBAR */
789 /* No parent, must be a non-menubar menu */
790 if (parent
== NULL
|| parent
->submenu_id
== NULL
)
793 /* Make place for the possible tearoff handle item. Not in the popup
794 * menu, it doesn't have a tearoff item. */
795 if (!menu_is_popup(parent
->name
))
798 if (menu_is_separator(menu
->name
))
800 /* Separator: Just add it */
801 menu
->id
= gtk_menu_item_new();
802 gtk_widget_set_sensitive(menu
->id
, FALSE
);
803 gtk_widget_show(menu
->id
);
804 gtk_menu_insert(GTK_MENU(parent
->submenu_id
), menu
->id
, idx
);
809 /* Add textual menu item. */
810 menu_item_new(menu
, parent
->submenu_id
);
811 gtk_widget_show(menu
->id
);
812 gtk_menu_insert(GTK_MENU(parent
->submenu_id
), menu
->id
, idx
);
814 if (menu
->id
!= NULL
)
815 gtk_signal_connect(GTK_OBJECT(menu
->id
), "activate",
816 GTK_SIGNAL_FUNC(menu_item_activate
), menu
);
819 #endif /* FEAT_MENU */
823 gui_mch_set_text_area_pos(int x
, int y
, int w
, int h
)
825 gtk_form_move_resize(GTK_FORM(gui
.formwin
), gui
.drawarea
, x
, y
, w
, h
);
829 #if defined(FEAT_MENU) || defined(PROTO)
831 * Enable or disable accelators for the toplevel menus.
834 gui_gtk_set_mnemonics(int enable
)
838 # if !defined(HAVE_GTK2) && defined(GTK_USE_ACCEL)
842 for (menu
= root_menu
; menu
!= NULL
; menu
= menu
->next
)
844 if (menu
->id
== NULL
)
847 # if defined(HAVE_GTK2)
848 name
= translate_mnemonic_tag(menu
->name
, enable
);
849 gtk_label_set_text_with_mnemonic(GTK_LABEL(menu
->label
),
853 # if defined(GTK_USE_ACCEL)
854 name
= translate_mnemonic_tag(menu
->name
, TRUE
);
857 accel_key
= gtk_label_parse_uline(GTK_LABEL(menu
->label
),
859 if (accel_key
!= GDK_VoidSymbol
)
860 gtk_widget_remove_accelerator(menu
->id
, gui
.accel_group
,
861 accel_key
, GDK_MOD1_MASK
);
862 if (enable
&& accel_key
!= GDK_VoidSymbol
)
863 gtk_widget_add_accelerator(menu
->id
, "activate_item",
865 accel_key
, GDK_MOD1_MASK
,
871 name
= translate_mnemonic_tag(menu
->name
, FALSE
);
872 gtk_label_parse_uline(GTK_LABEL(menu
->label
), (const char *)name
);
881 recurse_tearoffs(vimmenu_T
*menu
, int val
)
883 for (; menu
!= NULL
; menu
= menu
->next
)
885 if (menu
->submenu_id
!= NULL
&& menu
->tearoff_handle
!= NULL
886 && menu
->name
[0] != ']' && !menu_is_popup(menu
->name
))
889 gtk_widget_show(menu
->tearoff_handle
);
891 gtk_widget_hide(menu
->tearoff_handle
);
893 recurse_tearoffs(menu
->children
, val
);
898 gui_mch_toggle_tearoffs(int enable
)
900 recurse_tearoffs(root_menu
, enable
);
902 #endif /* FEAT_MENU */
905 #if defined(FEAT_TOOLBAR) && !defined(HAVE_GTK2)
907 * Seems like there's a hole in the GTK Toolbar API: there's no provision for
908 * removing an item from the toolbar. Therefore I need to resort to going
909 * really deeply into the internal widget structures.
911 * <danielk> I'm not sure the statement above is true -- at least with
912 * GTK+ 2 one can just call gtk_widget_destroy() and be done with it.
913 * It is true though that you couldn't remove space items before GTK+ 2
914 * (without digging into the internals that is). But the code below
915 * doesn't seem to handle those either. Well, it's obsolete anyway.
918 toolbar_remove_item_by_text(GtkToolbar
*tb
, const char *text
)
920 GtkContainer
*container
;
922 GtkToolbarChild
*gtbc
;
924 g_return_if_fail(tb
!= NULL
);
925 g_return_if_fail(GTK_IS_TOOLBAR(tb
));
926 container
= GTK_CONTAINER(&tb
->container
);
928 for (childl
= tb
->children
; childl
; childl
= childl
->next
)
930 gtbc
= (GtkToolbarChild
*)childl
->data
;
932 if (gtbc
->type
!= GTK_TOOLBAR_CHILD_SPACE
933 && strcmp(GTK_LABEL(gtbc
->label
)->label
, text
) == 0)
935 gboolean was_visible
;
937 was_visible
= GTK_WIDGET_VISIBLE(gtbc
->widget
);
938 gtk_widget_unparent(gtbc
->widget
);
940 tb
->children
= g_list_remove_link(tb
->children
, childl
);
945 if (was_visible
&& GTK_WIDGET_VISIBLE(container
))
946 gtk_widget_queue_resize(GTK_WIDGET(container
));
952 #endif /* FEAT_TOOLBAR && !HAVE_GTK2 */
955 #if defined(FEAT_TOOLBAR) && defined(HAVE_GTK2)
957 get_menu_position(vimmenu_T
*menu
)
962 for (node
= menu
->parent
->children
; node
!= menu
; node
= node
->next
)
964 g_return_val_if_fail(node
!= NULL
, -1);
970 #endif /* FEAT_TOOLBAR && HAVE_GTK2 */
973 #if defined(FEAT_TOOLBAR) || defined(PROTO)
975 gui_mch_menu_set_tip(vimmenu_T
*menu
)
977 if (menu
->id
!= NULL
&& menu
->parent
!= NULL
978 && gui
.toolbar
!= NULL
&& menu_is_toolbar(menu
->parent
->name
))
983 tooltip
= CONVERT_TO_UTF8(menu
->strings
[MENU_INDEX_TIP
]);
984 if (tooltip
== NULL
|| utf_valid_string(tooltip
, NULL
))
985 /* Only set the tooltip when it's valid utf-8. */
987 tooltip
= menu
->strings
[MENU_INDEX_TIP
];
989 gtk_tooltips_set_tip(GTK_TOOLBAR(gui
.toolbar
)->tooltips
,
990 menu
->id
, (const char *)tooltip
, NULL
);
992 CONVERT_TO_UTF8_FREE(tooltip
);
996 #endif /* FEAT_TOOLBAR */
999 #if defined(FEAT_MENU) || defined(PROTO)
1001 * Destroy the machine specific menu widget.
1004 gui_mch_destroy_menu(vimmenu_T
*menu
)
1006 # ifdef FEAT_TOOLBAR
1007 if (menu
->parent
!= NULL
&& menu_is_toolbar(menu
->parent
->name
))
1010 if (menu_is_separator(menu
->name
))
1011 gtk_toolbar_remove_space(GTK_TOOLBAR(gui
.toolbar
),
1012 get_menu_position(menu
));
1013 else if (menu
->id
!= NULL
)
1014 gtk_widget_destroy(menu
->id
);
1016 toolbar_remove_item_by_text(GTK_TOOLBAR(gui
.toolbar
),
1017 (const char *)menu
->dname
);
1021 # endif /* FEAT_TOOLBAR */
1023 if (menu
->submenu_id
!= NULL
)
1024 gtk_widget_destroy(menu
->submenu_id
);
1026 if (menu
->id
!= NULL
)
1027 gtk_widget_destroy(menu
->id
);
1030 menu
->submenu_id
= NULL
;
1033 #endif /* FEAT_MENU */
1040 gui_mch_set_scrollbar_thumb(scrollbar_T
*sb
, long val
, long size
, long max
)
1044 GtkAdjustment
*adjustment
;
1046 adjustment
= gtk_range_get_adjustment(GTK_RANGE(sb
->id
));
1048 adjustment
->lower
= 0.0;
1049 adjustment
->value
= val
;
1050 adjustment
->upper
= max
+ 1;
1051 adjustment
->page_size
= size
;
1052 adjustment
->page_increment
= size
< 3L ? 1L : size
- 2L;
1053 adjustment
->step_increment
= 1.0;
1056 g_signal_handler_block(GTK_OBJECT(adjustment
),
1057 (gulong
)sb
->handler_id
);
1059 gtk_signal_handler_block(GTK_OBJECT(adjustment
),
1060 (guint
)sb
->handler_id
);
1062 gtk_adjustment_changed(adjustment
);
1064 g_signal_handler_unblock(GTK_OBJECT(adjustment
),
1065 (gulong
)sb
->handler_id
);
1067 gtk_signal_handler_unblock(GTK_OBJECT(adjustment
),
1068 (guint
)sb
->handler_id
);
1074 gui_mch_set_scrollbar_pos(scrollbar_T
*sb
, int x
, int y
, int w
, int h
)
1077 gtk_form_move_resize(GTK_FORM(gui
.formwin
), sb
->id
, x
, y
, w
, h
);
1081 * Take action upon scrollbar dragging.
1084 adjustment_value_changed(GtkAdjustment
*adjustment
, gpointer data
)
1088 int dragging
= FALSE
;
1091 /* cancel any preediting */
1092 if (im_is_preediting())
1096 sb
= gui_find_scrollbar((long)data
);
1097 value
= (long)adjustment
->value
;
1099 * The dragging argument must be right for the scrollbar to work with
1100 * closed folds. This isn't documented, hopefully this will keep on
1101 * working in later GTK versions.
1103 * FIXME: Well, it doesn't work in GTK2. :)
1104 * HACK: Get the mouse pointer position, if it appears to be on an arrow
1105 * button set "dragging" to FALSE. This assumes square buttons!
1116 GdkModifierType state
;
1120 /* vertical scrollbar: need to set "dragging" properly in case
1121 * there are closed folds. */
1122 gdk_window_get_pointer(sb
->id
->window
, &x
, &y
, &state
);
1123 gdk_window_get_size(sb
->id
->window
, &width
, &height
);
1124 if (x
>= 0 && x
< width
&& y
>= 0 && y
< height
)
1128 /* up arrow: move one (closed fold) line up */
1130 value
= sb
->wp
->w_topline
- 2;
1132 else if (y
> height
- width
)
1134 /* down arrow: move one (closed fold) line down */
1136 value
= sb
->wp
->w_topline
;
1141 dragging
= (GTK_RANGE(sb
->id
)->scroll_type
== GTK_SCROLL_NONE
);
1145 gui_drag_scrollbar(sb
, value
, dragging
);
1147 if (gtk_main_level() > 0)
1151 /* SBAR_VERT or SBAR_HORIZ */
1153 gui_mch_create_scrollbar(scrollbar_T
*sb
, int orient
)
1155 if (orient
== SBAR_HORIZ
)
1156 sb
->id
= gtk_hscrollbar_new(NULL
);
1157 else if (orient
== SBAR_VERT
)
1158 sb
->id
= gtk_vscrollbar_new(NULL
);
1162 GtkAdjustment
*adjustment
;
1164 GTK_WIDGET_UNSET_FLAGS(sb
->id
, GTK_CAN_FOCUS
);
1165 gtk_form_put(GTK_FORM(gui
.formwin
), sb
->id
, 0, 0);
1167 adjustment
= gtk_range_get_adjustment(GTK_RANGE(sb
->id
));
1169 sb
->handler_id
= gtk_signal_connect(
1170 GTK_OBJECT(adjustment
), "value_changed",
1171 GTK_SIGNAL_FUNC(adjustment_value_changed
),
1172 GINT_TO_POINTER(sb
->ident
));
1177 #if defined(FEAT_WINDOWS) || defined(PROTO)
1179 gui_mch_destroy_scrollbar(scrollbar_T
*sb
)
1183 gtk_widget_destroy(sb
->id
);
1190 #if defined(FEAT_BROWSE) || defined(PROTO)
1192 * Implementation of the file selector related stuff
1194 #if defined(HAVE_GTK2) && GTK_CHECK_VERSION(2,4,0)
1195 # define USE_FILE_CHOOSER
1198 #ifndef USE_FILE_CHOOSER
1201 browse_ok_cb(GtkWidget
*widget
, gpointer cbdata
)
1203 gui_T
*vw
= (gui_T
*)cbdata
;
1205 if (vw
->browse_fname
!= NULL
)
1206 g_free(vw
->browse_fname
);
1208 vw
->browse_fname
= (char_u
*)g_strdup(gtk_file_selection_get_filename(
1209 GTK_FILE_SELECTION(vw
->filedlg
)));
1210 gtk_widget_hide(vw
->filedlg
);
1211 if (gtk_main_level() > 0)
1217 browse_cancel_cb(GtkWidget
*widget
, gpointer cbdata
)
1219 gui_T
*vw
= (gui_T
*)cbdata
;
1221 if (vw
->browse_fname
!= NULL
)
1223 g_free(vw
->browse_fname
);
1224 vw
->browse_fname
= NULL
;
1226 gtk_widget_hide(vw
->filedlg
);
1227 if (gtk_main_level() > 0)
1233 browse_destroy_cb(GtkWidget
* widget
)
1235 if (gui
.browse_fname
!= NULL
)
1237 g_free(gui
.browse_fname
);
1238 gui
.browse_fname
= NULL
;
1242 if (gtk_main_level() > 0)
1250 * Put up a file requester.
1251 * Returns the selected name in allocated memory, or NULL for Cancel.
1252 * saving, select file to write
1253 * title title for the window
1255 * ext not used (extension added)
1256 * initdir initial directory, NULL for current dir
1257 * filter not used (file name filter)
1261 gui_mch_browse(int saving
,
1268 #ifdef USE_FILE_CHOOSER
1271 char_u dirbuf
[MAXPATHL
];
1275 title
= CONVERT_TO_UTF8(title
);
1278 /* Concatenate "initdir" and "dflt". */
1279 if (initdir
== NULL
|| *initdir
== NUL
)
1280 mch_dirname(dirbuf
, MAXPATHL
);
1281 else if (STRLEN(initdir
) + 2 < MAXPATHL
)
1282 STRCPY(dirbuf
, initdir
);
1285 /* Always need a trailing slash for a directory. */
1286 add_pathsep(dirbuf
);
1287 if (dflt
!= NULL
&& *dflt
!= NUL
1288 && STRLEN(dirbuf
) + 2 + STRLEN(dflt
) < MAXPATHL
)
1289 STRCAT(dirbuf
, dflt
);
1291 /* If our pointer is currently hidden, then we should show it. */
1292 gui_mch_mousehide(FALSE
);
1294 #ifdef USE_FILE_CHOOSER
1295 /* We create the dialog each time, so that the button text can be "Open"
1296 * or "Save" according to the action. */
1297 fc
= gtk_file_chooser_dialog_new((const gchar
*)title
,
1298 GTK_WINDOW(gui
.mainwin
),
1299 saving
? GTK_FILE_CHOOSER_ACTION_SAVE
1300 : GTK_FILE_CHOOSER_ACTION_OPEN
,
1301 saving
? GTK_STOCK_SAVE
: GTK_STOCK_OPEN
, GTK_RESPONSE_ACCEPT
,
1302 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1304 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc
),
1305 (const gchar
*)dirbuf
);
1307 gui
.browse_fname
= NULL
;
1308 if (gtk_dialog_run(GTK_DIALOG(fc
)) == GTK_RESPONSE_ACCEPT
)
1312 filename
= gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fc
));
1313 gui
.browse_fname
= (char_u
*)g_strdup(filename
);
1316 gtk_widget_destroy(GTK_WIDGET(fc
));
1320 if (gui
.filedlg
== NULL
)
1322 GtkFileSelection
*fs
; /* shortcut */
1324 gui
.filedlg
= gtk_file_selection_new((const gchar
*)title
);
1325 gtk_window_set_modal(GTK_WINDOW(gui
.filedlg
), TRUE
);
1326 gtk_window_set_transient_for(GTK_WINDOW(gui
.filedlg
),
1327 GTK_WINDOW(gui
.mainwin
));
1328 fs
= GTK_FILE_SELECTION(gui
.filedlg
);
1330 gtk_container_border_width(GTK_CONTAINER(fs
), 4);
1332 gtk_signal_connect(GTK_OBJECT(fs
->ok_button
),
1333 "clicked", GTK_SIGNAL_FUNC(browse_ok_cb
), &gui
);
1334 gtk_signal_connect(GTK_OBJECT(fs
->cancel_button
),
1335 "clicked", GTK_SIGNAL_FUNC(browse_cancel_cb
), &gui
);
1336 /* gtk_signal_connect() doesn't work for destroy, it causes a hang */
1337 gtk_signal_connect_object(GTK_OBJECT(gui
.filedlg
),
1338 "destroy", GTK_SIGNAL_FUNC(browse_destroy_cb
),
1339 GTK_OBJECT(gui
.filedlg
));
1342 gtk_window_set_title(GTK_WINDOW(gui
.filedlg
), (const gchar
*)title
);
1344 gtk_file_selection_set_filename(GTK_FILE_SELECTION(gui
.filedlg
),
1345 (const gchar
*)dirbuf
);
1347 gui_gtk_position_in_parent(GTK_WIDGET(gui
.mainwin
),
1348 GTK_WIDGET(gui
.filedlg
), VW_POS_MOUSE
);
1351 gtk_widget_show(gui
.filedlg
);
1352 while (gui
.filedlg
&& GTK_WIDGET_DRAWABLE(gui
.filedlg
))
1353 gtk_main_iteration_do(TRUE
);
1357 CONVERT_TO_UTF8_FREE(title
);
1359 if (gui
.browse_fname
== NULL
)
1362 /* shorten the file name if possible */
1363 mch_dirname(dirbuf
, MAXPATHL
);
1364 p
= shorten_fname(gui
.browse_fname
, dirbuf
);
1366 p
= gui
.browse_fname
;
1367 return vim_strsave(p
);
1370 #if defined(HAVE_GTK2) || defined(PROTO)
1373 * Put up a directory selector
1374 * Returns the selected name in allocated memory, or NULL for Cancel.
1375 * title title for the window
1377 * initdir initial directory, NULL for current dir
1385 # if defined(GTK_FILE_CHOOSER) /* Only in GTK 2.4 and later. */
1386 char_u dirbuf
[MAXPATHL
];
1388 GtkWidget
*dirdlg
; /* file selection dialog */
1389 char_u
*dirname
= NULL
;
1391 title
= CONVERT_TO_UTF8(title
);
1393 dirdlg
= gtk_file_chooser_dialog_new(
1394 (const gchar
*)title
,
1395 GTK_WINDOW(gui
.mainwin
),
1396 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
,
1397 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1398 GTK_STOCK_OK
, GTK_RESPONSE_ACCEPT
,
1401 CONVERT_TO_UTF8_FREE(title
);
1403 /* if our pointer is currently hidden, then we should show it. */
1404 gui_mch_mousehide(FALSE
);
1406 /* GTK appears to insist on an absolute path. */
1407 if (initdir
== NULL
|| *initdir
== NUL
1408 || vim_FullName(initdir
, dirbuf
, MAXPATHL
- 10, FALSE
) == FAIL
)
1409 mch_dirname(dirbuf
, MAXPATHL
- 10);
1411 /* Always need a trailing slash for a directory.
1412 * Also add a dummy file name, so that we get to the directory. */
1413 add_pathsep(dirbuf
);
1414 STRCAT(dirbuf
, "@zd(*&1|");
1415 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dirdlg
),
1416 (const gchar
*)dirbuf
);
1418 /* Run the dialog. */
1419 if (gtk_dialog_run(GTK_DIALOG(dirdlg
)) == GTK_RESPONSE_ACCEPT
)
1420 dirname
= (char_u
*)gtk_file_chooser_get_filename(
1421 GTK_FILE_CHOOSER(dirdlg
));
1422 gtk_widget_destroy(dirdlg
);
1423 if (dirname
== NULL
)
1426 /* shorten the file name if possible */
1427 mch_dirname(dirbuf
, MAXPATHL
);
1428 p
= shorten_fname(dirname
, dirbuf
);
1429 if (p
== NULL
|| *p
== NUL
)
1436 /* For GTK 2.2 and earlier: fall back to ordinary file selector. */
1437 return gui_mch_browse(0, title
, NULL
, NULL
, initdir
, NULL
);
1443 #endif /* FEAT_BROWSE */
1445 #if defined(FEAT_GUI_DIALOG) && !defined(HAVE_GTK2)
1447 static char_u
*dialog_textfield
= NULL
;
1448 static GtkWidget
*dialog_textentry
;
1451 dlg_destroy(GtkWidget
*dlg
)
1453 if (dialog_textfield
!= NULL
)
1457 text
= gtk_entry_get_text(GTK_ENTRY(dialog_textentry
));
1458 vim_strncpy(dialog_textfield
, (char_u
*)text
, IOSIZE
- 1);
1461 /* Destroy the dialog, will break the waiting loop. */
1462 gtk_widget_destroy(dlg
);
1465 # ifdef FEAT_GUI_GNOME
1468 gui_gnome_dialog( int type
,
1477 char_u
*buttons_copy
, *p
, *next
;
1478 char **buttons_list
;
1481 /* make a copy, so that we can insert NULs */
1482 if ((buttons_copy
= vim_strsave(buttons
)) == NULL
)
1485 /* determine exact number of buttons and allocate array to hold them */
1486 for (butcount
= 0, p
= buttons
; *p
; p
++)
1492 buttons_list
= g_new0(char *, butcount
+ 1);
1498 gdtype
= GNOME_MESSAGE_BOX_ERROR
;
1501 gdtype
= GNOME_MESSAGE_BOX_WARNING
;
1504 gdtype
= GNOME_MESSAGE_BOX_INFO
;
1507 gdtype
= GNOME_MESSAGE_BOX_QUESTION
;
1510 gdtype
= GNOME_MESSAGE_BOX_GENERIC
;
1514 for (cur
= 0; cur
< butcount
; ++cur
)
1516 for (next
= p
; *next
; ++next
)
1518 if (*next
== DLG_HOTKEY_CHAR
)
1519 mch_memmove(next
, next
+ 1, STRLEN(next
));
1520 if (*next
== DLG_BUTTON_SEP
)
1527 /* this should probably go into a table, but oh well */
1528 if (g_strcasecmp((char *)p
, "Ok") == 0)
1529 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_OK
);
1530 else if (g_strcasecmp((char *)p
, "Cancel") == 0)
1531 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_CANCEL
);
1532 else if (g_strcasecmp((char *)p
, "Yes") == 0)
1533 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_YES
);
1534 else if (g_strcasecmp((char *)p
, "No") == 0)
1535 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_NO
);
1536 else if (g_strcasecmp((char *)p
, "Close") == 0)
1537 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_CLOSE
);
1538 else if (g_strcasecmp((char *)p
, "Help") == 0)
1539 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_HELP
);
1540 else if (g_strcasecmp((char *)p
, "Apply") == 0)
1541 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_APPLY
);
1544 * these aren't really used that often anyway, but are listed here as
1545 * placeholders in case we need them.
1547 else if (g_strcasecmp((char *)p
, "Next") == 0)
1548 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_NEXT
);
1549 else if (g_strcasecmp((char *)p
, "Prev") == 0)
1550 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_PREV
);
1551 else if (g_strcasecmp((char *)p
, "Up") == 0)
1552 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_UP
);
1553 else if (g_strcasecmp((char *)p
, "Down") == 0)
1554 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_DOWN
);
1555 else if (g_strcasecmp((char *)p
, "Font") == 0)
1556 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_FONT
);
1559 buttons_list
[cur
] = g_strdup((char *)p
);
1566 vim_free(buttons_copy
);
1568 dlg
= gnome_message_box_newv((const char *)message
,
1569 (const char *)gdtype
,
1570 (const char **)buttons_list
);
1571 for (cur
= 0; cur
< butcount
; ++cur
)
1572 g_free(buttons_list
[cur
]);
1573 g_free(buttons_list
);
1575 dialog_textfield
= textfield
;
1576 if (textfield
!= NULL
)
1578 /* Add text entry field */
1579 dialog_textentry
= gtk_entry_new();
1580 gtk_box_pack_start(GTK_BOX(GNOME_DIALOG(dlg
)->vbox
), dialog_textentry
,
1582 gtk_entry_set_text(GTK_ENTRY(dialog_textentry
),
1583 (const gchar
*)textfield
);
1584 gtk_entry_select_region(GTK_ENTRY(dialog_textentry
), 0,
1586 gtk_entry_set_max_length(GTK_ENTRY(dialog_textentry
), IOSIZE
- 1);
1587 gtk_entry_set_position(GTK_ENTRY(dialog_textentry
), STRLEN(textfield
));
1588 gtk_widget_show(dialog_textentry
);
1589 gtk_window_set_focus(GTK_WINDOW(dlg
), dialog_textentry
);
1592 gtk_signal_connect_object(GTK_OBJECT(dlg
), "destroy",
1593 GTK_SIGNAL_FUNC(dlg_destroy
), GTK_OBJECT(dlg
));
1594 gnome_dialog_set_default(GNOME_DIALOG(dlg
), dfltbutton
+ 1);
1595 gui_gtk_position_in_parent(GTK_WIDGET(gui
.mainwin
),
1596 GTK_WIDGET(dlg
), VW_POS_MOUSE
);
1598 return (1 + gnome_dialog_run_and_close(GNOME_DIALOG(dlg
)));
1601 # endif /* FEAT_GUI_GNOME */
1603 typedef struct _ButtonData
1610 typedef struct _CancelData
1619 dlg_button_clicked(GtkWidget
* widget
, ButtonData
*data
)
1621 *(data
->status
) = data
->index
+ 1;
1622 dlg_destroy(data
->dialog
);
1626 * This makes the Escape key equivalent to the cancel button.
1630 dlg_key_press_event(GtkWidget
* widget
, GdkEventKey
* event
, CancelData
*data
)
1632 /* Ignore hitting Enter when there is no default button. */
1633 if (data
->ignore_enter
&& event
->keyval
== GDK_Return
)
1636 if (event
->keyval
!= GDK_Escape
&& event
->keyval
!= GDK_Return
)
1639 /* The result value of 0 from a dialog is signaling cancelation.
1641 *(data
->status
) = (event
->keyval
== GDK_Return
);
1642 dlg_destroy(data
->dialog
);
1648 * Callback function for when the dialog was destroyed by a window manager.
1651 dlg_destroy_cb(int *p
)
1653 *p
= TRUE
; /* set dialog_destroyed to break out of the loop */
1654 if (gtk_main_level() > 0)
1660 gui_mch_dialog( int type
, /* type of dialog */
1661 char_u
*title
, /* title of dialog */
1662 char_u
*message
, /* message text */
1663 char_u
*buttons
, /* names of buttons */
1664 int def_but
, /* default button */
1665 char_u
*textfield
) /* text for textfield or NULL */
1671 int dialog_status
= -1;
1672 int dialog_destroyed
= FALSE
;
1679 GtkWidget
*dialogmessage
;
1680 GtkWidget
*action_area
;
1681 GtkWidget
*sub_area
;
1682 GtkWidget
*separator
;
1683 GtkAccelGroup
*accel_group
;
1685 GdkPixmap
*icon
= NULL
;
1686 GdkBitmap
*mask
= NULL
;
1687 char **icon_data
= NULL
;
1691 CancelData cancel_data
;
1693 /* if our pointer is currently hidden, then we should show it. */
1694 gui_mch_mousehide(FALSE
);
1696 # ifdef FEAT_GUI_GNOME
1697 /* If Gnome is available, use it for the dialog. */
1698 if (gtk_socket_id
== 0)
1699 return gui_gnome_dialog(type
, title
, message
, buttons
, def_but
,
1704 title
= (char_u
*)_("Vim dialog...");
1706 if ((type
< 0) || (type
> VIM_LAST_TYPE
))
1709 /* Check 'v' flag in 'guioptions': vertical button placement. */
1710 vertical
= (vim_strchr(p_go
, GO_VERTICAL
) != NULL
);
1712 dialog
= gtk_window_new(GTK_WINDOW_DIALOG
);
1713 gtk_window_set_title(GTK_WINDOW(dialog
), (const gchar
*)title
);
1714 gtk_window_set_transient_for(GTK_WINDOW(dialog
), GTK_WINDOW(gui
.mainwin
));
1715 gtk_widget_realize(dialog
);
1716 gdk_window_set_decorations(dialog
->window
, GDK_DECOR_BORDER
);
1717 gdk_window_set_functions(dialog
->window
, GDK_FUNC_MOVE
);
1719 cancel_data
.status
= &dialog_status
;
1720 cancel_data
.dialog
= dialog
;
1721 gtk_signal_connect_after(GTK_OBJECT(dialog
), "key_press_event",
1722 GTK_SIGNAL_FUNC(dlg_key_press_event
),
1723 (gpointer
) &cancel_data
);
1724 /* Catch the destroy signal, otherwise we don't notice a window manager
1725 * destroying the dialog window. */
1726 gtk_signal_connect_object(GTK_OBJECT(dialog
), "destroy",
1727 GTK_SIGNAL_FUNC(dlg_destroy_cb
),
1728 (gpointer
)&dialog_destroyed
);
1730 gtk_grab_add(dialog
);
1732 /* this makes it look beter on Motif style window managers */
1733 frame
= gtk_frame_new(NULL
);
1734 gtk_container_add(GTK_CONTAINER(dialog
), frame
);
1735 gtk_widget_show(frame
);
1737 vbox
= gtk_vbox_new(FALSE
, 0);
1738 gtk_container_add(GTK_CONTAINER(frame
), vbox
);
1739 gtk_widget_show(vbox
);
1741 table
= gtk_table_new(1, 3, FALSE
);
1742 gtk_table_set_row_spacings(GTK_TABLE(table
), 4);
1743 gtk_table_set_col_spacings(GTK_TABLE(table
), 8);
1744 gtk_container_border_width(GTK_CONTAINER(table
), 4);
1745 gtk_box_pack_start(GTK_BOX(vbox
), table
, 4, 4, 0);
1746 gtk_widget_show(table
);
1752 icon_data
= generic_xpm
;
1755 icon_data
= error_xpm
;
1758 icon_data
= alert_xpm
;
1761 icon_data
= info_xpm
;
1764 icon_data
= quest_xpm
;
1767 icon_data
= generic_xpm
;
1769 icon
= gdk_pixmap_colormap_create_from_xpm_d(NULL
,
1770 gtk_widget_get_colormap(dialog
),
1771 &mask
, NULL
, icon_data
);
1774 pixmap
= gtk_pixmap_new(icon
, mask
);
1775 /* gtk_misc_set_alignment(GTK_MISC(pixmap), 0.5, 0.5); */
1776 gtk_table_attach_defaults(GTK_TABLE(table
), pixmap
, 0, 1, 0, 1);
1777 gtk_widget_show(pixmap
);
1781 dialogmessage
= gtk_label_new((const gchar
*)message
);
1782 gtk_table_attach_defaults(GTK_TABLE(table
), dialogmessage
, 1, 2, 0, 1);
1783 gtk_widget_show(dialogmessage
);
1785 dialog_textfield
= textfield
;
1786 if (textfield
!= NULL
)
1788 /* Add text entry field */
1789 dialog_textentry
= gtk_entry_new();
1790 gtk_widget_set_usize(dialog_textentry
, 400, -2);
1791 gtk_box_pack_start(GTK_BOX(vbox
), dialog_textentry
, TRUE
, TRUE
, 0);
1792 gtk_entry_set_text(GTK_ENTRY(dialog_textentry
),
1793 (const gchar
*)textfield
);
1794 gtk_entry_select_region(GTK_ENTRY(dialog_textentry
), 0,
1796 gtk_entry_set_max_length(GTK_ENTRY(dialog_textentry
), IOSIZE
- 1);
1797 gtk_entry_set_position(GTK_ENTRY(dialog_textentry
), STRLEN(textfield
));
1798 gtk_widget_show(dialog_textentry
);
1801 /* Add box for buttons */
1802 action_area
= gtk_hbox_new(FALSE
, 0);
1803 gtk_container_border_width(GTK_CONTAINER(action_area
), 4);
1804 gtk_box_pack_end(GTK_BOX(vbox
), action_area
, FALSE
, TRUE
, 0);
1805 gtk_widget_show(action_area
);
1807 /* Add a [vh]box in the hbox to center the buttons in the dialog. */
1809 sub_area
= gtk_vbox_new(FALSE
, 0);
1811 sub_area
= gtk_hbox_new(FALSE
, 0);
1812 gtk_container_set_border_width(GTK_CONTAINER(sub_area
), 0);
1813 gtk_box_pack_start(GTK_BOX(action_area
), sub_area
, TRUE
, FALSE
, 0);
1814 gtk_widget_show(sub_area
);
1817 * Create the buttons.
1821 * Translate the Vim accelerator character into an underscore for GTK+.
1822 * Double underscores to keep them in the label.
1824 /* count the number of underscores */
1826 for (p
= buttons
; *p
; ++p
)
1830 /* make a copy of "buttons" with the translated characters */
1831 names
= alloc(STRLEN(buttons
) + i
);
1836 for (i
= 0; buttons
[i
]; ++i
)
1838 if (buttons
[i
] == DLG_HOTKEY_CHAR
)
1842 if (buttons
[i
] == '_')
1849 /* Count the number of buttons and allocate button[] and data[]. */
1851 for (p
= names
; *p
; ++p
)
1852 if (*p
== DLG_BUTTON_SEP
)
1854 button
= (GtkWidget
**)alloc((unsigned)(butcount
* sizeof(GtkWidget
*)));
1855 data
= (ButtonData
*)alloc((unsigned)(butcount
* sizeof(ButtonData
)));
1856 if (button
== NULL
|| data
== NULL
)
1864 /* Attach the new accelerator group to the window. */
1865 accel_group
= gtk_accel_group_new();
1866 gtk_accel_group_attach(accel_group
, GTK_OBJECT(dialog
));
1869 for (butcount
= 0; *p
; ++butcount
)
1873 # ifdef GTK_USE_ACCEL
1877 /* Chunk out this single button. */
1878 for (next
= p
; *next
; ++next
)
1880 if (*next
== DLG_BUTTON_SEP
)
1887 button
[butcount
] = gtk_button_new();
1888 GTK_WIDGET_SET_FLAGS(button
[butcount
], GTK_CAN_DEFAULT
);
1890 label
= gtk_accel_label_new("");
1891 gtk_accel_label_set_accel_widget(GTK_ACCEL_LABEL(label
), dialog
);
1893 # ifdef GTK_USE_ACCEL
1894 accel_key
= gtk_label_parse_uline(GTK_LABEL(label
), (const gchar
*)p
);
1895 /* Don't add accelator if 'winaltkeys' is "no". */
1896 if (accel_key
!= GDK_VoidSymbol
)
1898 gtk_widget_add_accelerator(button
[butcount
],
1905 (void)gtk_label_parse_uline(GTK_LABEL(label
), (const gchar
*)p
);
1908 gtk_container_add(GTK_CONTAINER(button
[butcount
]), label
);
1909 gtk_widget_show_all(button
[butcount
]);
1911 data
[butcount
].status
= &dialog_status
;
1912 data
[butcount
].index
= butcount
;
1913 data
[butcount
].dialog
= dialog
;
1914 gtk_signal_connect(GTK_OBJECT(button
[butcount
]),
1915 (const char *)"clicked",
1916 GTK_SIGNAL_FUNC(dlg_button_clicked
),
1917 (gpointer
) &data
[butcount
]);
1919 gtk_box_pack_start(GTK_BOX(sub_area
), button
[butcount
],
1926 cancel_data
.ignore_enter
= FALSE
;
1929 --def_but
; /* 1 is first button */
1930 if (def_but
>= butcount
)
1934 gtk_widget_grab_focus(button
[def_but
]);
1935 gtk_widget_grab_default(button
[def_but
]);
1938 /* No default, ignore hitting Enter. */
1939 cancel_data
.ignore_enter
= TRUE
;
1942 if (textfield
!= NULL
)
1943 gtk_window_set_focus(GTK_WINDOW(dialog
), dialog_textentry
);
1945 separator
= gtk_hseparator_new();
1946 gtk_box_pack_end(GTK_BOX(vbox
), separator
, FALSE
, TRUE
, 0);
1947 gtk_widget_show(separator
);
1951 gui_gtk_position_in_parent(GTK_WIDGET(gui
.mainwin
),
1952 GTK_WIDGET(dialog
), VW_POS_MOUSE
);
1954 gtk_widget_show(dialog
);
1956 /* loop here until the dialog goes away */
1957 while (dialog_status
== -1 && !dialog_destroyed
1958 && GTK_WIDGET_DRAWABLE(dialog
))
1959 gtk_main_iteration_do(TRUE
);
1961 if (dialog_status
< 0)
1963 if (dialog_status
!= 1 && textfield
!= NULL
)
1964 *textfield
= NUL
; /* dialog was cancelled */
1966 /* let the garbage collector know that we don't need it any longer */
1967 gtk_accel_group_unref(accel_group
);
1972 return dialog_status
;
1975 #endif /* FEAT_GUI_DIALOG && !HAVE_GTK2 */
1978 #if (defined(FEAT_GUI_DIALOG) && defined(HAVE_GTK2)) || defined(PROTO)
1981 create_message_dialog(int type
, char_u
*title
, char_u
*message
)
1984 GtkMessageType message_type
;
1988 case VIM_ERROR
: message_type
= GTK_MESSAGE_ERROR
; break;
1989 case VIM_WARNING
: message_type
= GTK_MESSAGE_WARNING
; break;
1990 case VIM_QUESTION
: message_type
= GTK_MESSAGE_QUESTION
; break;
1991 default: message_type
= GTK_MESSAGE_INFO
; break;
1994 message
= CONVERT_TO_UTF8(message
);
1995 dialog
= gtk_message_dialog_new(GTK_WINDOW(gui
.mainwin
),
1996 GTK_DIALOG_DESTROY_WITH_PARENT
,
1999 "%s", (const char *)message
);
2000 CONVERT_TO_UTF8_FREE(message
);
2004 title
= CONVERT_TO_UTF8(title
);
2005 gtk_window_set_title(GTK_WINDOW(dialog
), (const char *)title
);
2006 CONVERT_TO_UTF8_FREE(title
);
2008 else if (type
== VIM_GENERIC
)
2010 gtk_window_set_title(GTK_WINDOW(dialog
), "VIM");
2017 * Split up button_string into individual button labels by inserting
2018 * NUL bytes. Also replace the Vim-style mnemonic accelerator prefix
2019 * '&' with '_'. button_string must point to allocated memory!
2020 * Return an allocated array of pointers into button_string.
2023 split_button_string(char_u
*button_string
, int *n_buttons
)
2027 unsigned int count
= 1;
2029 for (p
= button_string
; *p
!= NUL
; ++p
)
2030 if (*p
== DLG_BUTTON_SEP
)
2033 array
= (char **)alloc((count
+ 1) * sizeof(char *));
2038 array
[count
++] = (char *)button_string
;
2039 for (p
= button_string
; *p
!= NUL
; )
2041 if (*p
== DLG_BUTTON_SEP
)
2044 array
[count
++] = (char *)p
;
2046 else if (*p
== DLG_HOTKEY_CHAR
)
2051 array
[count
] = NULL
; /* currently not relied upon, but doesn't hurt */
2059 split_button_translation(const char *message
)
2061 char **buttons
= NULL
;
2066 for (str
= (char_u
*)message
; *str
!= NUL
; ++str
)
2067 if (*str
== DLG_BUTTON_SEP
)
2070 str
= (char_u
*)_(message
);
2073 if (output_conv
.vc_type
!= CONV_NONE
)
2074 str
= string_convert(&output_conv
, str
, NULL
);
2076 str
= vim_strsave(str
);
2079 buttons
= split_button_string(str
, &n_buttons
);
2082 * Uh-oh... this should never ever happen. But we don't wanna crash
2083 * if the translation is broken, thus fall back to the untranslated
2084 * buttons string in case of emergency.
2086 if (buttons
== NULL
|| n_buttons
!= n_expected
)
2091 str
= vim_strsave((char_u
*)message
);
2094 buttons
= split_button_string(str
, &n_buttons
);
2095 if (buttons
== NULL
)
2103 button_equal(const char *a
, const char *b
)
2105 while (*a
!= '\0' && *b
!= '\0')
2107 if (*a
== '_' && *++a
== '\0')
2109 if (*b
== '_' && *++b
== '\0')
2112 if (g_unichar_tolower(g_utf8_get_char(a
))
2113 != g_unichar_tolower(g_utf8_get_char(b
)))
2116 a
= g_utf8_next_char(a
);
2117 b
= g_utf8_next_char(b
);
2120 return (*a
== '\0' && *b
== '\0');
2124 dialog_add_buttons(GtkDialog
*dialog
, char_u
*button_string
)
2127 char **ync
; /* "yes no cancel" */
2132 button_string
= vim_strsave(button_string
); /* must be writable */
2133 if (button_string
== NULL
)
2136 /* Check 'v' flag in 'guioptions': vertical button placement. */
2137 if (vim_strchr(p_go
, GO_VERTICAL
) != NULL
)
2139 GtkWidget
*vbutton_box
;
2141 vbutton_box
= gtk_vbutton_box_new();
2142 gtk_widget_show(vbutton_box
);
2143 gtk_box_pack_end(GTK_BOX(GTK_DIALOG(dialog
)->vbox
),
2144 vbutton_box
, TRUE
, FALSE
, 0);
2145 /* Overrule the "action_area" value, hopefully this works... */
2146 GTK_DIALOG(dialog
)->action_area
= vbutton_box
;
2150 * Yes this is ugly, I don't particularly like it either. But doing it
2151 * this way has the compelling advantage that translations need not to
2152 * be touched at all. See below what 'ok' and 'ync' are used for.
2154 ok
= split_button_translation(N_("&Ok"));
2155 ync
= split_button_translation(N_("&Yes\n&No\n&Cancel"));
2156 buttons
= split_button_string(button_string
, &n_buttons
);
2159 * Yes, the buttons are in reversed order to match the GNOME 2 desktop
2160 * environment. Don't hit me -- it's all about consistency.
2161 * Well, apparently somebody changed his mind: with GTK 2.2.4 it works the
2162 * other way around...
2164 for (idx
= 1; idx
<= n_buttons
; ++idx
)
2169 label
= buttons
[idx
- 1];
2171 * Perform some guesswork to find appropriate stock items for the
2172 * buttons. We have to compare with a sample of the translated
2173 * button string to get things right. Yes, this is hackish :/
2175 * But even the common button labels aren't necessarily translated,
2176 * since anyone can create their own dialogs using Vim functions.
2177 * Thus we have to check for those too.
2179 if (ok
!= NULL
&& ync
!= NULL
) /* almost impossible to fail */
2181 if (button_equal(label
, ok
[0])) label
= GTK_STOCK_OK
;
2182 else if (button_equal(label
, ync
[0])) label
= GTK_STOCK_YES
;
2183 else if (button_equal(label
, ync
[1])) label
= GTK_STOCK_NO
;
2184 else if (button_equal(label
, ync
[2])) label
= GTK_STOCK_CANCEL
;
2185 else if (button_equal(label
, "Ok")) label
= GTK_STOCK_OK
;
2186 else if (button_equal(label
, "Yes")) label
= GTK_STOCK_YES
;
2187 else if (button_equal(label
, "No")) label
= GTK_STOCK_NO
;
2188 else if (button_equal(label
, "Cancel")) label
= GTK_STOCK_CANCEL
;
2190 label8
= CONVERT_TO_UTF8((char_u
*)label
);
2191 gtk_dialog_add_button(dialog
, (const gchar
*)label8
, idx
);
2192 CONVERT_TO_UTF8_FREE(label8
);
2202 vim_free(button_string
);
2206 * Allow mnemonic accelerators to be activated without pressing <Alt>.
2207 * I'm not sure if it's a wise idea to do this. However, the old GTK+ 1.2
2208 * GUI used to work this way, and I consider the impact on UI consistency
2209 * low enough to justify implementing this as a special Vim feature.
2211 typedef struct _DialogInfo
2213 int ignore_enter
; /* no default button, ignore "Enter" */
2214 int noalt
; /* accept accelerators without Alt */
2215 GtkDialog
*dialog
; /* Widget of the dialog */
2220 dialog_key_press_event_cb(GtkWidget
*widget
, GdkEventKey
*event
, gpointer data
)
2222 DialogInfo
*di
= (DialogInfo
*)data
;
2224 /* Close the dialog when hitting "Esc". */
2225 if (event
->keyval
== GDK_Escape
)
2227 gtk_dialog_response(di
->dialog
, GTK_RESPONSE_REJECT
);
2232 && (event
->state
& gtk_accelerator_get_default_mod_mask()) == 0)
2234 return gtk_window_mnemonic_activate(
2235 GTK_WINDOW(widget
), event
->keyval
,
2236 gtk_window_get_mnemonic_modifier(GTK_WINDOW(widget
)));
2239 return FALSE
; /* continue emission */
2243 gui_mch_dialog(int type
, /* type of dialog */
2244 char_u
*title
, /* title of dialog */
2245 char_u
*message
, /* message text */
2246 char_u
*buttons
, /* names of buttons */
2247 int def_but
, /* default button */
2248 char_u
*textfield
) /* text for textfield or NULL */
2251 GtkWidget
*entry
= NULL
;
2254 DialogInfo dialoginfo
;
2256 dialog
= create_message_dialog(type
, title
, message
);
2257 dialoginfo
.dialog
= GTK_DIALOG(dialog
);
2258 dialog_add_buttons(GTK_DIALOG(dialog
), buttons
);
2260 if (textfield
!= NULL
)
2262 GtkWidget
*alignment
;
2264 entry
= gtk_entry_new();
2265 gtk_widget_show(entry
);
2267 text
= CONVERT_TO_UTF8(textfield
);
2268 gtk_entry_set_text(GTK_ENTRY(entry
), (const char *)text
);
2269 CONVERT_TO_UTF8_FREE(text
);
2271 alignment
= gtk_alignment_new((float)0.5, (float)0.5,
2272 (float)1.0, (float)1.0);
2273 gtk_container_add(GTK_CONTAINER(alignment
), entry
);
2274 gtk_container_set_border_width(GTK_CONTAINER(alignment
), 5);
2275 gtk_widget_show(alignment
);
2277 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog
)->vbox
),
2278 alignment
, TRUE
, FALSE
, 0);
2279 dialoginfo
.noalt
= FALSE
;
2282 dialoginfo
.noalt
= TRUE
;
2284 /* Allow activation of mnemonic accelerators without pressing <Alt> when
2285 * there is no textfield. Handle pressing Esc. */
2286 g_signal_connect(G_OBJECT(dialog
), "key_press_event",
2287 G_CALLBACK(&dialog_key_press_event_cb
), &dialoginfo
);
2291 gtk_dialog_set_default_response(GTK_DIALOG(dialog
), def_but
);
2292 dialoginfo
.ignore_enter
= FALSE
;
2295 /* No default button, ignore pressing Enter. */
2296 dialoginfo
.ignore_enter
= TRUE
;
2298 /* Show the mouse pointer if it's currently hidden. */
2299 gui_mch_mousehide(FALSE
);
2301 response
= gtk_dialog_run(GTK_DIALOG(dialog
));
2303 /* GTK_RESPONSE_NONE means the dialog was programmatically destroyed. */
2304 if (response
!= GTK_RESPONSE_NONE
)
2306 if (response
== GTK_RESPONSE_ACCEPT
) /* Enter pressed */
2308 if (textfield
!= NULL
)
2310 text
= (char_u
*)gtk_entry_get_text(GTK_ENTRY(entry
));
2311 text
= CONVERT_FROM_UTF8(text
);
2313 vim_strncpy(textfield
, text
, IOSIZE
- 1);
2315 CONVERT_FROM_UTF8_FREE(text
);
2317 gtk_widget_destroy(dialog
);
2320 /* Terrible hack: When the text area still has focus when we remove the
2321 * dialog, somehow gvim loses window focus. This is with "point to type"
2322 * in the KDE 3.1 window manager. Warp the mouse pointer to outside the
2323 * window and back to avoid that. */
2328 gdk_window_get_pointer(gui
.drawarea
->window
, &x
, &y
, NULL
);
2329 gui_mch_setmouse(-100, -100);
2330 gui_mch_setmouse(x
, y
);
2333 return response
> 0 ? response
: 0;
2336 #endif /* FEAT_GUI_DIALOG && HAVE_GTK2 */
2339 #if defined(FEAT_MENU) || defined(PROTO)
2342 gui_mch_show_popupmenu(vimmenu_T
*menu
)
2344 # if defined(FEAT_XIM) && defined(HAVE_GTK2)
2346 * Append a submenu for selecting an input method. This is
2347 * currently the only way to switch input methods at runtime.
2349 if (xic
!= NULL
&& g_object_get_data(G_OBJECT(menu
->submenu_id
),
2350 "vim-has-im-menu") == NULL
)
2352 GtkWidget
*menuitem
;
2356 menuitem
= gtk_separator_menu_item_new();
2357 gtk_widget_show(menuitem
);
2358 gtk_menu_shell_append(GTK_MENU_SHELL(menu
->submenu_id
), menuitem
);
2360 name
= (char_u
*)_("Input _Methods");
2361 name
= CONVERT_TO_UTF8(name
);
2362 menuitem
= gtk_menu_item_new_with_mnemonic((const char *)name
);
2363 CONVERT_TO_UTF8_FREE(name
);
2364 gtk_widget_show(menuitem
);
2366 submenu
= gtk_menu_new();
2367 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem
), submenu
);
2368 gtk_menu_shell_append(GTK_MENU_SHELL(menu
->submenu_id
), menuitem
);
2370 gtk_im_multicontext_append_menuitems(GTK_IM_MULTICONTEXT(xic
),
2371 GTK_MENU_SHELL(submenu
));
2372 g_object_set_data(G_OBJECT(menu
->submenu_id
),
2373 "vim-has-im-menu", GINT_TO_POINTER(TRUE
));
2375 # endif /* FEAT_XIM && HAVE_GTK2 */
2377 gtk_menu_popup(GTK_MENU(menu
->submenu_id
),
2379 (GtkMenuPositionFunc
)NULL
, NULL
,
2380 3U, (guint32
)GDK_CURRENT_TIME
);
2383 /* Ugly global variable to pass "mouse_pos" flag from gui_make_popup() to
2384 * popup_menu_position_func(). */
2385 static int popup_mouse_pos
;
2388 * Menu position callback; used by gui_make_popup() to place the menu
2389 * at the current text cursor position.
2391 * Note: The push_in output argument seems to affect scrolling of huge
2392 * menus that don't fit on the screen. Leave it at the default for now.
2396 popup_menu_position_func(GtkMenu
*menu
,
2403 gdk_window_get_origin(gui
.drawarea
->window
, x
, y
);
2405 if (popup_mouse_pos
)
2409 gui_mch_getmouse(&mx
, &my
);
2413 else if (curwin
!= NULL
&& gui
.drawarea
!= NULL
&& gui
.drawarea
->window
!= NULL
)
2415 /* Find the cursor position in the current window */
2416 *x
+= FILL_X(W_WINCOL(curwin
) + curwin
->w_wcol
+ 1) + 1;
2417 *y
+= FILL_Y(W_WINROW(curwin
) + curwin
->w_wrow
+ 1) + 1;
2422 gui_make_popup(char_u
*path_name
, int mouse_pos
)
2426 popup_mouse_pos
= mouse_pos
;
2428 menu
= gui_find_menu(path_name
);
2430 if (menu
!= NULL
&& menu
->submenu_id
!= NULL
)
2432 gtk_menu_popup(GTK_MENU(menu
->submenu_id
),
2434 &popup_menu_position_func
, NULL
,
2435 0U, (guint32
)GDK_CURRENT_TIME
);
2439 #endif /* FEAT_MENU */
2443 * We don't create it twice.
2446 typedef struct _SharedFindReplace
2448 GtkWidget
*dialog
; /* the main dialog widget */
2449 GtkWidget
*wword
; /* 'Whole word only' check button */
2450 GtkWidget
*mcase
; /* 'Match case' check button */
2451 GtkWidget
*up
; /* search direction 'Up' radio button */
2452 GtkWidget
*down
; /* search direction 'Down' radio button */
2453 GtkWidget
*what
; /* 'Find what' entry text widget */
2454 GtkWidget
*with
; /* 'Replace with' entry text widget */
2455 GtkWidget
*find
; /* 'Find Next' action button */
2456 GtkWidget
*replace
; /* 'Replace With' action button */
2457 GtkWidget
*all
; /* 'Replace All' action button */
2458 } SharedFindReplace
;
2460 static SharedFindReplace find_widgets
= { NULL
, };
2461 static SharedFindReplace repl_widgets
= { NULL
, };
2465 find_key_press_event(
2468 SharedFindReplace
*frdp
)
2470 /* If the user is holding one of the key modifiers we will just bail out,
2471 * thus preserving the possibility of normal focus traversal.
2473 if (event
->state
& (GDK_CONTROL_MASK
| GDK_SHIFT_MASK
))
2476 /* the Escape key synthesizes a cancellation action */
2477 if (event
->keyval
== GDK_Escape
)
2479 gtk_widget_hide(frdp
->dialog
);
2484 * What the **** is this for? Disabled for GTK+ 2 because due to
2485 * gtk_signal_connect_after() it doesn't have any effect anyway.
2489 /* block traversal resulting from those keys */
2490 if (event
->keyval
== GDK_Left
2491 || event
->keyval
== GDK_Right
2492 || event
->keyval
== GDK_space
)
2496 /* It would be delightfull if it where possible to do search history
2497 * operations on the K_UP and K_DOWN keys here.
2505 create_image_button(const char *stock_id
, const char *label
)
2509 GtkWidget
*alignment
;
2512 text
= CONVERT_TO_UTF8((char_u
*)label
);
2514 box
= gtk_hbox_new(FALSE
, 3);
2515 gtk_box_pack_start(GTK_BOX(box
),
2516 gtk_image_new_from_stock(stock_id
, GTK_ICON_SIZE_BUTTON
),
2518 gtk_box_pack_start(GTK_BOX(box
),
2519 gtk_label_new((const char *)text
),
2522 CONVERT_TO_UTF8_FREE(text
);
2524 alignment
= gtk_alignment_new((float)0.5, (float)0.5,
2525 (float)0.0, (float)0.0);
2526 gtk_container_add(GTK_CONTAINER(alignment
), box
);
2527 gtk_widget_show_all(alignment
);
2529 button
= gtk_button_new();
2530 gtk_container_add(GTK_CONTAINER(button
), alignment
);
2536 * This is currently only used by find_replace_dialog_create(), and
2537 * I'd really like to keep it at that. In other words: don't spread
2538 * this nasty hack all over the code. Think twice.
2541 convert_localized_message(char_u
**buffer
, const char *message
)
2543 if (output_conv
.vc_type
== CONV_NONE
)
2547 *buffer
= string_convert(&output_conv
, (char_u
*)message
, NULL
);
2549 return (const char *)*buffer
;
2551 #endif /* HAVE_GTK2 */
2554 find_replace_dialog_create(char_u
*arg
, int do_replace
)
2559 GtkWidget
*hbox
; /* main top down box */
2560 GtkWidget
*actionarea
;
2565 SharedFindReplace
*frdp
;
2570 char_u
*conv_buffer
= NULL
;
2571 # define CONV(message) convert_localized_message(&conv_buffer, (message))
2573 # define CONV(message) (message)
2576 frdp
= (do_replace
) ? (&repl_widgets
) : (&find_widgets
);
2578 /* Get the search string to use. */
2579 entry_text
= get_find_dialog_text(arg
, &wword
, &mcase
);
2582 if (entry_text
!= NULL
&& output_conv
.vc_type
!= CONV_NONE
)
2584 char_u
*old_text
= entry_text
;
2585 entry_text
= string_convert(&output_conv
, entry_text
, NULL
);
2591 * If the dialog already exists, just raise it.
2596 /* always make the dialog appear where you want it even if the mainwin
2597 * has moved -- dbv */
2598 gui_gtk_position_in_parent(GTK_WIDGET(gui
.mainwin
),
2599 GTK_WIDGET(frdp
->dialog
), VW_POS_MOUSE
);
2600 gui_gtk_synch_fonts();
2602 if (!GTK_WIDGET_VISIBLE(frdp
->dialog
))
2604 gtk_widget_grab_focus(frdp
->what
);
2605 gtk_widget_show(frdp
->dialog
);
2608 if (entry_text
!= NULL
)
2610 gtk_entry_set_text(GTK_ENTRY(frdp
->what
), (char *)entry_text
);
2611 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp
->wword
),
2613 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp
->mcase
),
2617 gtk_window_present(GTK_WINDOW(frdp
->dialog
));
2619 gdk_window_raise(frdp
->dialog
->window
);
2621 vim_free(entry_text
);
2626 frdp
->dialog
= gtk_dialog_new();
2627 gtk_dialog_set_has_separator(GTK_DIALOG(frdp
->dialog
), FALSE
);
2628 gtk_window_set_transient_for(GTK_WINDOW(frdp
->dialog
), GTK_WINDOW(gui
.mainwin
));
2629 gtk_window_set_destroy_with_parent(GTK_WINDOW(frdp
->dialog
), TRUE
);
2631 frdp
->dialog
= gtk_window_new(GTK_WINDOW_DIALOG
);
2637 gtk_window_set_wmclass(GTK_WINDOW(frdp
->dialog
), "searchrepl", "gvim");
2639 gtk_window_set_title(GTK_WINDOW(frdp
->dialog
),
2640 CONV(_("VIM - Search and Replace...")));
2645 gtk_window_set_wmclass(GTK_WINDOW(frdp
->dialog
), "search", "gvim");
2647 gtk_window_set_title(GTK_WINDOW(frdp
->dialog
),
2648 CONV(_("VIM - Search...")));
2651 #ifndef HAVE_GTK2 /* Utter crack. Shudder. */
2652 gtk_widget_realize(frdp
->dialog
);
2653 gdk_window_set_decorations(frdp
->dialog
->window
,
2654 GDK_DECOR_TITLE
| GDK_DECOR_BORDER
| GDK_DECOR_RESIZEH
);
2655 gdk_window_set_functions(frdp
->dialog
->window
,
2656 GDK_FUNC_RESIZE
| GDK_FUNC_MOVE
);
2660 /* this makes it look better on Motif style window managers */
2661 frame
= gtk_frame_new(NULL
);
2662 gtk_container_add(GTK_CONTAINER(frdp
->dialog
), frame
);
2665 hbox
= gtk_hbox_new(FALSE
, 0);
2667 gtk_container_set_border_width(GTK_CONTAINER(hbox
), 10);
2668 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(frdp
->dialog
)->vbox
), hbox
);
2670 gtk_container_add(GTK_CONTAINER(frame
), hbox
);
2674 table
= gtk_table_new(1024, 4, FALSE
);
2676 table
= gtk_table_new(1024, 3, FALSE
);
2677 gtk_box_pack_start(GTK_BOX(hbox
), table
, TRUE
, TRUE
, 0);
2678 gtk_container_border_width(GTK_CONTAINER(table
), 4);
2680 tmp
= gtk_label_new(CONV(_("Find what:")));
2681 gtk_misc_set_alignment(GTK_MISC(tmp
), (gfloat
)0.0, (gfloat
)0.5);
2682 gtk_table_attach(GTK_TABLE(table
), tmp
, 0, 1, 0, 1,
2683 GTK_FILL
, GTK_EXPAND
, 2, 2);
2684 frdp
->what
= gtk_entry_new();
2685 sensitive
= (entry_text
!= NULL
&& entry_text
[0] != NUL
);
2686 if (entry_text
!= NULL
)
2687 gtk_entry_set_text(GTK_ENTRY(frdp
->what
), (char *)entry_text
);
2688 gtk_signal_connect(GTK_OBJECT(frdp
->what
), "changed",
2689 GTK_SIGNAL_FUNC(entry_changed_cb
), frdp
->dialog
);
2690 gtk_signal_connect_after(GTK_OBJECT(frdp
->what
), "key_press_event",
2691 GTK_SIGNAL_FUNC(find_key_press_event
),
2693 gtk_table_attach(GTK_TABLE(table
), frdp
->what
, 1, 1024, 0, 1,
2694 GTK_EXPAND
| GTK_FILL
, GTK_EXPAND
, 2, 2);
2698 tmp
= gtk_label_new(CONV(_("Replace with:")));
2699 gtk_misc_set_alignment(GTK_MISC(tmp
), (gfloat
)0.0, (gfloat
)0.5);
2700 gtk_table_attach(GTK_TABLE(table
), tmp
, 0, 1, 1, 2,
2701 GTK_FILL
, GTK_EXPAND
, 2, 2);
2702 frdp
->with
= gtk_entry_new();
2703 gtk_signal_connect(GTK_OBJECT(frdp
->with
), "activate",
2704 GTK_SIGNAL_FUNC(find_replace_cb
),
2705 GINT_TO_POINTER(FRD_R_FINDNEXT
));
2706 gtk_signal_connect_after(GTK_OBJECT(frdp
->with
), "key_press_event",
2707 GTK_SIGNAL_FUNC(find_key_press_event
),
2709 gtk_table_attach(GTK_TABLE(table
), frdp
->with
, 1, 1024, 1, 2,
2710 GTK_EXPAND
| GTK_FILL
, GTK_EXPAND
, 2, 2);
2713 * Make the entry activation only change the input focus onto the
2716 gtk_signal_connect(GTK_OBJECT(frdp
->what
), "activate",
2717 GTK_SIGNAL_FUNC(entry_activate_cb
), frdp
->with
);
2722 * Make the entry activation do the search.
2724 gtk_signal_connect(GTK_OBJECT(frdp
->what
), "activate",
2725 GTK_SIGNAL_FUNC(find_replace_cb
),
2726 GINT_TO_POINTER(FRD_FINDNEXT
));
2729 /* whole word only button */
2730 frdp
->wword
= gtk_check_button_new_with_label(CONV(_("Match whole word only")));
2731 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp
->wword
),
2734 gtk_table_attach(GTK_TABLE(table
), frdp
->wword
, 0, 1023, 2, 3,
2735 GTK_FILL
, GTK_EXPAND
, 2, 2);
2737 gtk_table_attach(GTK_TABLE(table
), frdp
->wword
, 0, 1023, 1, 2,
2738 GTK_FILL
, GTK_EXPAND
, 2, 2);
2740 /* match case button */
2741 frdp
->mcase
= gtk_check_button_new_with_label(CONV(_("Match case")));
2742 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp
->mcase
),
2745 gtk_table_attach(GTK_TABLE(table
), frdp
->mcase
, 0, 1023, 3, 4,
2746 GTK_FILL
, GTK_EXPAND
, 2, 2);
2748 gtk_table_attach(GTK_TABLE(table
), frdp
->mcase
, 0, 1023, 2, 3,
2749 GTK_FILL
, GTK_EXPAND
, 2, 2);
2751 tmp
= gtk_frame_new(CONV(_("Direction")));
2753 gtk_table_attach(GTK_TABLE(table
), tmp
, 1023, 1024, 2, 4,
2754 GTK_FILL
, GTK_FILL
, 2, 2);
2756 gtk_table_attach(GTK_TABLE(table
), tmp
, 1023, 1024, 1, 3,
2757 GTK_FILL
, GTK_FILL
, 2, 2);
2758 vbox
= gtk_vbox_new(FALSE
, 0);
2759 gtk_container_border_width(GTK_CONTAINER(vbox
), 0);
2760 gtk_container_add(GTK_CONTAINER(tmp
), vbox
);
2762 /* 'Up' and 'Down' buttons */
2763 frdp
->up
= gtk_radio_button_new_with_label(NULL
, CONV(_("Up")));
2764 gtk_box_pack_start(GTK_BOX(vbox
), frdp
->up
, TRUE
, TRUE
, 0);
2765 frdp
->down
= gtk_radio_button_new_with_label(
2766 gtk_radio_button_group(GTK_RADIO_BUTTON(frdp
->up
)),
2768 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp
->down
), TRUE
);
2770 gtk_container_set_border_width(GTK_CONTAINER(vbox
), 2);
2772 gtk_box_pack_start(GTK_BOX(vbox
), frdp
->down
, TRUE
, TRUE
, 0);
2774 /* vbox to hold the action buttons */
2775 actionarea
= gtk_vbutton_box_new();
2776 gtk_container_border_width(GTK_CONTAINER(actionarea
), 2);
2780 gtk_button_box_set_layout(GTK_BUTTON_BOX(actionarea
),
2782 gtk_button_box_set_spacing(GTK_BUTTON_BOX(actionarea
), 0);
2785 gtk_box_pack_end(GTK_BOX(hbox
), actionarea
, FALSE
, FALSE
, 0);
2787 /* 'Find Next' button */
2789 frdp
->find
= create_image_button(GTK_STOCK_FIND
, _("Find Next"));
2791 frdp
->find
= gtk_button_new_with_label(_("Find Next"));
2793 gtk_widget_set_sensitive(frdp
->find
, sensitive
);
2795 gtk_signal_connect(GTK_OBJECT(frdp
->find
), "clicked",
2796 GTK_SIGNAL_FUNC(find_replace_cb
),
2797 (do_replace
) ? GINT_TO_POINTER(FRD_R_FINDNEXT
)
2798 : GINT_TO_POINTER(FRD_FINDNEXT
));
2800 GTK_WIDGET_SET_FLAGS(frdp
->find
, GTK_CAN_DEFAULT
);
2801 gtk_box_pack_start(GTK_BOX(actionarea
), frdp
->find
, FALSE
, FALSE
, 0);
2802 gtk_widget_grab_default(frdp
->find
);
2806 /* 'Replace' button */
2808 frdp
->replace
= create_image_button(GTK_STOCK_CONVERT
, _("Replace"));
2810 frdp
->replace
= gtk_button_new_with_label(_("Replace"));
2812 gtk_widget_set_sensitive(frdp
->replace
, sensitive
);
2813 GTK_WIDGET_SET_FLAGS(frdp
->replace
, GTK_CAN_DEFAULT
);
2814 gtk_box_pack_start(GTK_BOX(actionarea
), frdp
->replace
, FALSE
, FALSE
, 0);
2815 gtk_signal_connect(GTK_OBJECT(frdp
->replace
), "clicked",
2816 GTK_SIGNAL_FUNC(find_replace_cb
),
2817 GINT_TO_POINTER(FRD_REPLACE
));
2819 /* 'Replace All' button */
2821 frdp
->all
= create_image_button(GTK_STOCK_CONVERT
, _("Replace All"));
2823 frdp
->all
= gtk_button_new_with_label(_("Replace All"));
2825 gtk_widget_set_sensitive(frdp
->all
, sensitive
);
2826 GTK_WIDGET_SET_FLAGS(frdp
->all
, GTK_CAN_DEFAULT
);
2827 gtk_box_pack_start(GTK_BOX(actionarea
), frdp
->all
, FALSE
, FALSE
, 0);
2828 gtk_signal_connect(GTK_OBJECT(frdp
->all
), "clicked",
2829 GTK_SIGNAL_FUNC(find_replace_cb
),
2830 GINT_TO_POINTER(FRD_REPLACEALL
));
2833 /* 'Cancel' button */
2835 tmp
= gtk_button_new_from_stock(GTK_STOCK_CLOSE
);
2837 tmp
= gtk_button_new_with_label(_("Cancel"));
2839 GTK_WIDGET_SET_FLAGS(tmp
, GTK_CAN_DEFAULT
);
2840 gtk_box_pack_end(GTK_BOX(actionarea
), tmp
, FALSE
, FALSE
, 0);
2841 gtk_signal_connect_object(GTK_OBJECT(tmp
),
2842 "clicked", GTK_SIGNAL_FUNC(gtk_widget_hide
),
2843 GTK_OBJECT(frdp
->dialog
));
2844 gtk_signal_connect_object(GTK_OBJECT(frdp
->dialog
),
2845 "delete_event", GTK_SIGNAL_FUNC(gtk_widget_hide_on_delete
),
2846 GTK_OBJECT(frdp
->dialog
));
2848 tmp
= gtk_vseparator_new();
2850 gtk_box_pack_end(GTK_BOX(hbox
), tmp
, FALSE
, FALSE
, 10);
2852 gtk_box_pack_end(GTK_BOX(hbox
), tmp
, FALSE
, TRUE
, 0);
2856 gtk_widget_grab_focus(frdp
->what
);
2858 /* show the frame and realize the frdp->dialog this gives us a window size
2859 * request that we'll use to position the window within the boundary of
2860 * the mainwin --dbv */
2861 gtk_widget_show_all(frame
);
2862 gui_gtk_position_in_parent(GTK_WIDGET(gui
.mainwin
),
2863 GTK_WIDGET(frdp
->dialog
), VW_POS_MOUSE
);
2864 gui_gtk_synch_fonts();
2865 gtk_widget_show_all(frdp
->dialog
);
2869 /* Suppress automatic show of the unused action area */
2870 gtk_widget_hide(GTK_DIALOG(frdp
->dialog
)->action_area
);
2871 gtk_widget_show_all(hbox
);
2872 gtk_widget_show(frdp
->dialog
);
2875 vim_free(entry_text
);
2877 vim_free(conv_buffer
);
2883 gui_mch_find_dialog(exarg_T
*eap
)
2886 find_replace_dialog_create(eap
->arg
, FALSE
);
2890 gui_mch_replace_dialog(exarg_T
*eap
)
2893 find_replace_dialog_create(eap
->arg
, TRUE
);
2897 #if !defined(HAVE_GTK2) || defined(PROTO)
2899 * Synchronize all gui elements, which are dependant upon the
2900 * main text font used. Those are in esp. the find/replace dialogs.
2901 * If you don't understand why this should be needed, please try to
2902 * search for "pięść" in iso8859-2.
2904 * (<danielk> I converted the comment above to UTF-8 to put
2905 * a stopper to the encoding mess. Forgive me :)
2907 * Obsolete with GTK2.
2910 gui_gtk_synch_fonts(void)
2912 SharedFindReplace
*frdp
;
2915 /* OK this loop is a bit tricky... */
2916 for (do_replace
= 0; do_replace
<= 1; ++do_replace
)
2918 frdp
= (do_replace
) ? (&repl_widgets
) : (&find_widgets
);
2923 /* synch the font with whats used by the text itself */
2924 style
= gtk_style_copy(gtk_widget_get_style(frdp
->what
));
2925 gdk_font_unref(style
->font
);
2926 # ifdef FEAT_XFONTSET
2927 if (gui
.fontset
!= NOFONTSET
)
2928 style
->font
= gui
.fontset
;
2931 style
->font
= gui
.norm_font
;
2932 gdk_font_ref(style
->font
);
2933 gtk_widget_set_style(frdp
->what
, style
);
2934 gtk_style_unref(style
);
2937 style
= gtk_style_copy(gtk_widget_get_style(frdp
->with
));
2938 gdk_font_unref(style
->font
);
2939 # ifdef FEAT_XFONTSET
2940 if (gui
.fontset
!= NOFONTSET
)
2941 style
->font
= gui
.fontset
;
2944 style
->font
= gui
.norm_font
;
2945 gdk_font_ref(style
->font
);
2946 gtk_widget_set_style(frdp
->with
, style
);
2947 gtk_style_unref(style
);
2952 #endif /* !HAVE_GTK2 */
2956 * Callback for actions of the find and replace dialogs
2960 find_replace_cb(GtkWidget
*widget
, gpointer data
)
2965 gboolean direction_down
;
2966 SharedFindReplace
*sfr
;
2969 flags
= (int)(long)data
; /* avoid a lint warning here */
2971 /* Get the search/replace strings from the dialog */
2972 if (flags
== FRD_FINDNEXT
)
2975 sfr
= &find_widgets
;
2979 repl_text
= (char_u
*)gtk_entry_get_text(GTK_ENTRY(repl_widgets
.with
));
2980 sfr
= &repl_widgets
;
2983 find_text
= (char_u
*)gtk_entry_get_text(GTK_ENTRY(sfr
->what
));
2984 direction_down
= GTK_TOGGLE_BUTTON(sfr
->down
)->active
;
2986 if (GTK_TOGGLE_BUTTON(sfr
->wword
)->active
)
2987 flags
|= FRD_WHOLE_WORD
;
2988 if (GTK_TOGGLE_BUTTON(sfr
->mcase
)->active
)
2989 flags
|= FRD_MATCH_CASE
;
2992 repl_text
= CONVERT_FROM_UTF8(repl_text
);
2993 find_text
= CONVERT_FROM_UTF8(find_text
);
2995 rc
= gui_do_findrepl(flags
, find_text
, repl_text
, direction_down
);
2997 CONVERT_FROM_UTF8_FREE(repl_text
);
2998 CONVERT_FROM_UTF8_FREE(find_text
);
3001 if (rc
&& gtk_main_level() > 0)
3002 gtk_main_quit(); /* make sure cmd will be handled immediately */
3005 /* our usual callback function */
3008 entry_activate_cb(GtkWidget
*widget
, gpointer data
)
3010 gtk_widget_grab_focus(GTK_WIDGET(data
));
3014 * Syncing the find/replace dialogs on the fly is utterly useless crack,
3015 * and causes nothing but problems. Please tell me a use case for which
3016 * you'd need both a find dialog and a find/replace one at the same time,
3017 * without being able to actually use them separately since they're syncing
3018 * all the time. I don't think it's worthwhile to fix this nonsense,
3019 * particularly evil incarnation of braindeadness, whatever; I'd much rather
3020 * see it extinguished from this planet. Thanks for listening. Sorry.
3023 entry_changed_cb(GtkWidget
* entry
, GtkWidget
* dialog
)
3025 const gchar
*entry_text
;
3028 entry_text
= gtk_entry_get_text(GTK_ENTRY(entry
));
3031 return; /* shouldn't happen */
3033 nonempty
= (entry_text
[0] != '\0');
3035 if (dialog
== find_widgets
.dialog
)
3037 gtk_widget_set_sensitive(find_widgets
.find
, nonempty
);
3040 if (dialog
== repl_widgets
.dialog
)
3042 gtk_widget_set_sensitive(repl_widgets
.find
, nonempty
);
3043 gtk_widget_set_sensitive(repl_widgets
.replace
, nonempty
);
3044 gtk_widget_set_sensitive(repl_widgets
.all
, nonempty
);
3056 /* This will fail when menus are not loaded. Well, it's only for
3057 * backwards compatibility anyway. */
3058 do_cmdline_cmd((char_u
*)"emenu ToolBar.FindHelp");
3061 #if !defined(HAVE_GTK2) || defined(PROTO) /* Crack crack crack. Brrrr. */
3063 /* gui_gtk_position_in_parent
3065 * this function causes a child window to be placed within the boundary of
3066 * the parent (mainwin) window.
3068 * you can specify where the window will be positioned by the third argument
3069 * (defined in gui.h):
3070 * VW_POS_CENTER at center of parent window
3071 * VW_POS_MOUSE center of child at mouse position
3072 * VW_POS_TOP_CENTER top of child at top of parent centered
3073 * horizontally about the mouse.
3075 * NOTE: for this function to act as desired the child window must have a
3076 * window size requested. this can be accomplished by packing/placing
3077 * child widgets onto a gtk_frame widget rather than the gtk_window
3083 gui_gtk_position_in_parent(
3086 gui_win_pos_T where
)
3088 GtkRequisition c_size
;
3090 gint xP
, yP
, wP
, hP
, pos_x
, pos_y
;
3092 /* make sure the child widget is set up then get its size. */
3093 gtk_widget_size_request(child
, &c_size
);
3095 /* get origin and size of parent window */
3096 gdk_window_get_origin((GdkWindow
*)(parent
->window
), &xP
, &yP
);
3097 gdk_window_get_size((GdkWindow
*)(parent
->window
), &wP
, &hP
);
3099 if (c_size
.width
> wP
|| c_size
.height
> hP
)
3101 /* doh! maybe the user should consider giving gVim a little more
3102 * screen real estate */
3103 gtk_widget_set_uposition(child
, xP
+ 2 , yP
+ 2);
3107 if (where
== VW_POS_MOUSE
)
3109 /* position window at mouse pointer */
3110 gtk_widget_get_pointer(parent
, &xPm
, &yPm
);
3111 pos_x
= xP
+ xPm
- (c_size
.width
) / 2;
3112 pos_y
= yP
+ yPm
- (c_size
.height
) / 2;
3116 /* set child x origin so it is in center of Vim window */
3117 pos_x
= xP
+ (wP
- c_size
.width
) / 2;
3119 if (where
== VW_POS_TOP_CENTER
)
3122 /* where == VW_POS_CENTER */
3123 pos_y
= yP
+ (hP
- c_size
.height
) / 2;
3126 /* now, make sure the window will be inside the Vim window... */
3131 if ((pos_x
+ c_size
.width
) > (wP
+ xP
))
3132 pos_x
= xP
+ wP
- c_size
.width
- 2;
3133 /* Assume 'guiheadroom' indicates the title bar height... */
3134 if ((pos_y
+ c_size
.height
+ p_ghr
/ 2) > (hP
+ yP
))
3136 gtk_widget_set_uposition(child
, pos_x
, pos_y
);
3139 #endif /* !HAVE_GTK2 */