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 # ifdef bind_textdomain_codeset
57 # undef bind_textdomain_codeset
59 # if defined(FEAT_GETTEXT) && !defined(ENABLE_NLS)
60 # define ENABLE_NLS /* so the texts in the dialog boxes are translated */
65 #if defined(FEAT_GUI_DIALOG) && !defined(HAVE_GTK2)
66 # include "../pixmaps/alert.xpm"
67 # include "../pixmaps/error.xpm"
68 # include "../pixmaps/generic.xpm"
69 # include "../pixmaps/info.xpm"
70 # include "../pixmaps/quest.xpm"
73 #if defined(FEAT_TOOLBAR) && !defined(HAVE_GTK2)
75 * Icons used by the toolbar code.
77 #include "../pixmaps/tb_new.xpm"
78 #include "../pixmaps/tb_open.xpm"
79 #include "../pixmaps/tb_close.xpm"
80 #include "../pixmaps/tb_save.xpm"
81 #include "../pixmaps/tb_print.xpm"
82 #include "../pixmaps/tb_cut.xpm"
83 #include "../pixmaps/tb_copy.xpm"
84 #include "../pixmaps/tb_paste.xpm"
85 #include "../pixmaps/tb_find.xpm"
86 #include "../pixmaps/tb_find_next.xpm"
87 #include "../pixmaps/tb_find_prev.xpm"
88 #include "../pixmaps/tb_find_help.xpm"
89 #include "../pixmaps/tb_exit.xpm"
90 #include "../pixmaps/tb_undo.xpm"
91 #include "../pixmaps/tb_redo.xpm"
92 #include "../pixmaps/tb_help.xpm"
93 #include "../pixmaps/tb_macro.xpm"
94 #include "../pixmaps/tb_make.xpm"
95 #include "../pixmaps/tb_save_all.xpm"
96 #include "../pixmaps/tb_jump.xpm"
97 #include "../pixmaps/tb_ctags.xpm"
98 #include "../pixmaps/tb_load_session.xpm"
99 #include "../pixmaps/tb_save_session.xpm"
100 #include "../pixmaps/tb_new_session.xpm"
101 #include "../pixmaps/tb_blank.xpm"
102 #include "../pixmaps/tb_maximize.xpm"
103 #include "../pixmaps/tb_split.xpm"
104 #include "../pixmaps/tb_minimize.xpm"
105 #include "../pixmaps/tb_shell.xpm"
106 #include "../pixmaps/tb_replace.xpm"
107 #include "../pixmaps/tb_vsplit.xpm"
108 #include "../pixmaps/tb_maxwidth.xpm"
109 #include "../pixmaps/tb_minwidth.xpm"
110 #endif /* FEAT_TOOLBAR && !HAVE_GTK2 */
113 # include <gdk/gdkkeysyms.h>
114 # include <gdk/gdk.h>
116 # include <gdk/gdkwin32.h>
118 # include <gdk/gdkx.h>
121 # include <gtk/gtk.h>
123 /* define these items to be able to generate prototypes without GTK */
124 typedef int GtkWidget
;
125 # define gpointer int
127 # define GdkPixmap int
128 # define GdkBitmap int
129 # define GtkIconFactory int
130 # define GtkToolbar int
131 # define GtkAdjustment int
132 # define gboolean int
133 # define GdkEventKey int
134 # define CancelData int
137 static void entry_activate_cb(GtkWidget
*widget
, gpointer data
);
138 static void entry_changed_cb(GtkWidget
*entry
, GtkWidget
*dialog
);
139 static void find_replace_cb(GtkWidget
*widget
, gpointer data
);
141 static void gui_gtk_position_in_parent(GtkWidget
*parent
, GtkWidget
*child
, gui_win_pos_T where
);
144 #if defined(FEAT_TOOLBAR) && defined(HAVE_GTK2)
146 * Table from BuiltIn## icon indices to GTK+ stock IDs. Order must exactly
147 * match toolbar_names[] in menu.c! All stock icons including the "vim-*"
148 * ones can be overridden in your gtkrc file.
150 static const char * const menu_stock_ids
[] =
152 /* 00 */ GTK_STOCK_NEW
,
153 /* 01 */ GTK_STOCK_OPEN
,
154 /* 02 */ GTK_STOCK_SAVE
,
155 /* 03 */ GTK_STOCK_UNDO
,
156 /* 04 */ GTK_STOCK_REDO
,
157 /* 05 */ GTK_STOCK_CUT
,
158 /* 06 */ GTK_STOCK_COPY
,
159 /* 07 */ GTK_STOCK_PASTE
,
160 /* 08 */ GTK_STOCK_PRINT
,
161 /* 09 */ GTK_STOCK_HELP
,
162 /* 10 */ GTK_STOCK_FIND
,
163 /* 11 */ "vim-save-all",
164 /* 12 */ "vim-session-save",
165 /* 13 */ "vim-session-new",
166 /* 14 */ "vim-session-load",
167 /* 15 */ GTK_STOCK_EXECUTE
,
168 /* 16 */ GTK_STOCK_FIND_AND_REPLACE
,
169 /* 17 */ GTK_STOCK_CLOSE
, /* FIXME: fuzzy */
170 /* 18 */ "vim-window-maximize",
171 /* 19 */ "vim-window-minimize",
172 /* 20 */ "vim-window-split",
173 /* 21 */ "vim-shell",
174 /* 22 */ GTK_STOCK_GO_BACK
,
175 /* 23 */ GTK_STOCK_GO_FORWARD
,
176 /* 24 */ "vim-find-help",
177 /* 25 */ GTK_STOCK_CONVERT
,
178 /* 26 */ GTK_STOCK_JUMP_TO
,
179 /* 27 */ "vim-build-tags",
180 /* 28 */ "vim-window-split-vertical",
181 /* 29 */ "vim-window-maximize-width",
182 /* 30 */ "vim-window-minimize-width",
183 /* 31 */ GTK_STOCK_QUIT
187 add_stock_icon(GtkIconFactory
*factory
,
188 const char *stock_id
,
189 const guint8
*inline_data
,
193 GtkIconSet
*icon_set
;
195 pixbuf
= gdk_pixbuf_new_from_inline(data_length
, inline_data
, FALSE
, NULL
);
196 icon_set
= gtk_icon_set_new_from_pixbuf(pixbuf
);
198 gtk_icon_factory_add(factory
, stock_id
, icon_set
);
200 gtk_icon_set_unref(icon_set
);
201 g_object_unref(pixbuf
);
205 lookup_menu_iconfile(char_u
*iconfile
, char_u
*dest
)
207 expand_env(iconfile
, dest
, MAXPATHL
);
209 if (mch_isFullName(dest
))
211 return vim_fexists(dest
);
215 static const char suffixes
[][4] = {"png", "xpm", "bmp"};
216 char_u buf
[MAXPATHL
];
219 for (i
= 0; i
< G_N_ELEMENTS(suffixes
); ++i
)
220 if (gui_find_bitmap(dest
, buf
, (char *)suffixes
[i
]) == OK
)
231 load_menu_iconfile(char_u
*name
, GtkIconSize icon_size
)
233 GtkWidget
*image
= NULL
;
234 GtkIconSet
*icon_set
;
235 GtkIconSource
*icon_source
;
238 * Rather than loading the icon directly into a GtkImage, create
239 * a new GtkIconSet and put it in there. This way we can easily
240 * scale the toolbar icons on the fly when needed.
242 icon_set
= gtk_icon_set_new();
243 icon_source
= gtk_icon_source_new();
245 gtk_icon_source_set_filename(icon_source
, (const char *)name
);
246 gtk_icon_set_add_source(icon_set
, icon_source
);
248 image
= gtk_image_new_from_icon_set(icon_set
, icon_size
);
250 gtk_icon_source_free(icon_source
);
251 gtk_icon_set_unref(icon_set
);
257 create_menu_icon(vimmenu_T
*menu
, GtkIconSize icon_size
)
259 GtkWidget
*image
= NULL
;
260 char_u buf
[MAXPATHL
];
262 /* First use a specified "icon=" argument. */
263 if (menu
->iconfile
!= NULL
&& lookup_menu_iconfile(menu
->iconfile
, buf
))
264 image
= load_menu_iconfile(buf
, icon_size
);
266 /* If not found and not builtin specified try using the menu name. */
267 if (image
== NULL
&& !menu
->icon_builtin
268 && lookup_menu_iconfile(menu
->name
, buf
))
269 image
= load_menu_iconfile(buf
, icon_size
);
271 /* Still not found? Then use a builtin icon, a blank one as fallback. */
274 const char *stock_id
;
275 const int n_ids
= G_N_ELEMENTS(menu_stock_ids
);
277 if (menu
->iconidx
>= 0 && menu
->iconidx
< n_ids
)
278 stock_id
= menu_stock_ids
[menu
->iconidx
];
280 stock_id
= GTK_STOCK_MISSING_IMAGE
;
282 image
= gtk_image_new_from_stock(stock_id
, icon_size
);
290 toolbar_button_focus_in_event(GtkWidget
*widget
, GdkEventFocus
*event
, gpointer data
)
292 /* When we're in a GtkPlug, we don't have window focus events, only widget focus.
293 * To emulate stand-alone gvim, if a button gets focus (e.g., <Tab> into GtkPlug)
294 * immediately pass it to mainwin.
296 if (gtk_socket_id
!= 0)
297 gtk_widget_grab_focus(gui
.drawarea
);
301 #endif /* FEAT_TOOLBAR && HAVE_GTK2 */
303 #if (defined(FEAT_TOOLBAR) && defined(HAVE_GTK2)) || defined(PROTO)
306 gui_gtk_register_stock_icons(void)
308 # include "../pixmaps/stock_icons.h"
309 GtkIconFactory
*factory
;
311 factory
= gtk_icon_factory_new();
312 # define ADD_ICON(Name, Data) add_stock_icon(factory, Name, Data, (int)sizeof(Data))
314 ADD_ICON("vim-build-tags", stock_vim_build_tags
);
315 ADD_ICON("vim-find-help", stock_vim_find_help
);
316 ADD_ICON("vim-save-all", stock_vim_save_all
);
317 ADD_ICON("vim-session-load", stock_vim_session_load
);
318 ADD_ICON("vim-session-new", stock_vim_session_new
);
319 ADD_ICON("vim-session-save", stock_vim_session_save
);
320 ADD_ICON("vim-shell", stock_vim_shell
);
321 ADD_ICON("vim-window-maximize", stock_vim_window_maximize
);
322 ADD_ICON("vim-window-maximize-width", stock_vim_window_maximize_width
);
323 ADD_ICON("vim-window-minimize", stock_vim_window_minimize
);
324 ADD_ICON("vim-window-minimize-width", stock_vim_window_minimize_width
);
325 ADD_ICON("vim-window-split", stock_vim_window_split
);
326 ADD_ICON("vim-window-split-vertical", stock_vim_window_split_vertical
);
329 gtk_icon_factory_add_default(factory
);
330 g_object_unref(factory
);
333 #endif /* FEAT_TOOLBAR && HAVE_GTK2 */
337 * Only use accelerators when gtk_menu_ensure_uline_accel_group() is
338 * available, which is in version 1.2.1. That was the first version where
339 * accelerators properly worked (according to the change log).
341 #ifdef GTK_CHECK_VERSION
342 # if GTK_CHECK_VERSION(1, 2, 1)
343 # define GTK_USE_ACCEL
347 #if defined(FEAT_MENU) || defined(PROTO)
350 * Translate Vim's mnemonic tagging to GTK+ style and convert to UTF-8
351 * if necessary. The caller must vim_free() the returned string.
356 * & _ stripped if use_mnemonic == FALSE
357 * <Tab> end of menu label text
360 translate_mnemonic_tag(char_u
*name
, int use_mnemonic
)
365 int n_underscores
= 0;
368 name
= CONVERT_TO_UTF8(name
);
373 for (psrc
= name
; *psrc
!= NUL
&& *psrc
!= TAB
; ++psrc
)
377 buf
= alloc((unsigned)(psrc
- name
+ n_underscores
+ 1));
381 for (psrc
= name
; *psrc
!= NUL
&& *psrc
!= TAB
; ++psrc
)
388 else if (*psrc
!= '&')
392 else if (*(psrc
+ 1) == '&')
396 else if (use_mnemonic
)
405 CONVERT_TO_UTF8_FREE(name
);
413 menu_item_new(vimmenu_T
*menu
, GtkWidget
*parent_widget
)
419 /* It would be neat to have image menu items, but that would require major
420 * changes to Vim's menu system. Not to mention that all the translations
421 * had to be updated. */
422 menu
->id
= gtk_menu_item_new();
423 box
= gtk_hbox_new(FALSE
, 20);
425 use_mnemonic
= (p_wak
[0] != 'n' || !GTK_IS_MENU_BAR(parent_widget
));
426 text
= translate_mnemonic_tag(menu
->name
, use_mnemonic
);
428 menu
->label
= gtk_label_new_with_mnemonic((const char *)text
);
431 gtk_box_pack_start(GTK_BOX(box
), menu
->label
, FALSE
, FALSE
, 0);
433 if (menu
->actext
!= NULL
&& menu
->actext
[0] != NUL
)
435 text
= CONVERT_TO_UTF8(menu
->actext
);
437 gtk_box_pack_end(GTK_BOX(box
),
438 gtk_label_new((const char *)text
),
441 CONVERT_TO_UTF8_FREE(text
);
444 gtk_container_add(GTK_CONTAINER(menu
->id
), box
);
445 gtk_widget_show_all(menu
->id
);
448 # else /* !HAVE_GTK2 */
451 * Create a highly customized menu item by hand instead of by using:
453 * gtk_menu_item_new_with_label(menu->dname);
455 * This is necessary, since there is no other way in GTK+ 1 to get the
456 * not automatically parsed accelerator stuff right.
459 menu_item_new(vimmenu_T
*menu
, GtkWidget
*parent_widget
)
467 widget
= gtk_widget_new(GTK_TYPE_MENU_ITEM
,
468 "GtkWidget::visible", TRUE
,
469 "GtkWidget::sensitive", TRUE
,
470 /* "GtkWidget::parent", parent->submenu_id, */
472 bin
= gtk_widget_new(GTK_TYPE_HBOX
,
473 "GtkWidget::visible", TRUE
,
474 "GtkWidget::parent", widget
,
475 "GtkBox::spacing", 16,
477 label
= gtk_widget_new(GTK_TYPE_ACCEL_LABEL
,
478 "GtkWidget::visible", TRUE
,
479 "GtkWidget::parent", bin
,
480 "GtkAccelLabel::accel_widget", widget
,
481 "GtkMisc::xalign", 0.0,
486 gtk_widget_new(GTK_TYPE_LABEL
,
487 "GtkWidget::visible", TRUE
,
488 "GtkWidget::parent", bin
,
489 "GtkLabel::label", menu
->actext
,
490 "GtkMisc::xalign", 1.0,
494 * Translate VIM accelerator tagging into GTK+'s. Note that since GTK uses
495 * underscores as the accelerator key, we need to add an additional under-
496 * score for each understore that appears in the menu name.
498 # ifdef GTK_USE_ACCEL
499 name
= translate_mnemonic_tag(menu
->name
,
500 (p_wak
[0] != 'n' || !GTK_IS_MENU_BAR(parent_widget
)));
502 name
= translate_mnemonic_tag(menu
->name
, FALSE
);
505 /* let GTK do its thing */
506 accel_key
= gtk_label_parse_uline(GTK_LABEL(label
), (const char *)name
);
509 # ifdef GTK_USE_ACCEL
510 /* Don't add accelator if 'winaltkeys' is "no". */
511 if (accel_key
!= GDK_VoidSymbol
)
513 if (GTK_IS_MENU_BAR(parent_widget
))
516 gtk_widget_add_accelerator(widget
,
519 accel_key
, GDK_MOD1_MASK
,
524 gtk_widget_add_accelerator(widget
,
526 gtk_menu_ensure_uline_accel_group(GTK_MENU(parent_widget
)),
531 # endif /* GTK_USE_ACCEL */
536 # endif /* !HAVE_GTK2 */
539 gui_mch_add_menu(vimmenu_T
*menu
, int idx
)
542 GtkWidget
*parent_widget
;
544 if (menu
->name
[0] == ']' || menu_is_popup(menu
->name
))
546 menu
->submenu_id
= gtk_menu_new();
550 parent
= menu
->parent
;
552 if ((parent
!= NULL
&& parent
->submenu_id
== NULL
)
553 || !menu_is_menubar(menu
->name
))
556 parent_widget
= (parent
!= NULL
) ? parent
->submenu_id
: gui
.menubar
;
557 menu_item_new(menu
, parent_widget
);
559 /* since the tearoff should always appear first, increment idx */
560 if (parent
!= NULL
&& !menu_is_popup(parent
->name
))
563 gtk_menu_shell_insert(GTK_MENU_SHELL(parent_widget
), menu
->id
, idx
);
567 * The "Help" menu is a special case, and should be placed at the far
568 * right hand side of the menu-bar. It's detected by its high priority.
570 * Right-aligning "Help" is considered bad UI design nowadays.
571 * Thus lets disable this for GTK+ 2 to match the environment.
573 if (parent
== NULL
&& menu
->priority
>= 9999)
574 gtk_menu_item_right_justify(GTK_MENU_ITEM(menu
->id
));
577 menu
->submenu_id
= gtk_menu_new();
579 gtk_menu_set_accel_group(GTK_MENU(menu
->submenu_id
), gui
.accel_group
);
580 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu
->id
), menu
->submenu_id
);
582 menu
->tearoff_handle
= gtk_tearoff_menu_item_new();
583 if (vim_strchr(p_go
, GO_TEAROFF
) != NULL
)
584 gtk_widget_show(menu
->tearoff_handle
);
585 gtk_menu_prepend(GTK_MENU(menu
->submenu_id
), menu
->tearoff_handle
);
590 menu_item_activate(GtkWidget
*widget
, gpointer data
)
592 gui_menu_cb((vimmenu_T
*)data
);
595 /* Work around a bug in GTK+ 1: we don't seem to get a focus-in
596 * event after clicking a menu item shown via :popup. */
598 gui_focus_change(TRUE
);
601 /* make sure the menu action is taken immediately */
602 if (gtk_main_level() > 0)
606 # if defined(FEAT_TOOLBAR) && !defined(HAVE_GTK2)
608 * These are the pixmaps used for the default buttons.
609 * Order must exactly match toolbar_names[] in menu.c!
611 static char **(built_in_pixmaps
[]) =
648 * creates a blank pixmap using tb_blank
651 pixmap_create_from_xpm(char **xpm
, GdkPixmap
**pixmap
, GdkBitmap
**mask
)
653 *pixmap
= gdk_pixmap_colormap_create_from_xpm_d(
655 gtk_widget_get_colormap(gui
.mainwin
),
662 * creates a pixmap by using a built-in number
665 pixmap_create_by_num(int pixmap_num
, GdkPixmap
**pixmap
, GdkBitmap
**mask
)
667 if (pixmap_num
>= 0 && pixmap_num
< (sizeof(built_in_pixmaps
)
668 / sizeof(built_in_pixmaps
[0])))
669 pixmap_create_from_xpm(built_in_pixmaps
[pixmap_num
], pixmap
, mask
);
673 * Creates a pixmap by using the pixmap "name" found in 'runtimepath'/bitmaps/
676 pixmap_create_by_dir(char_u
*name
, GdkPixmap
**pixmap
, GdkBitmap
**mask
)
678 char_u full_pathname
[MAXPATHL
+ 1];
680 if (gui_find_bitmap(name
, full_pathname
, "xpm") == OK
)
681 *pixmap
= gdk_pixmap_colormap_create_from_xpm(
683 gtk_widget_get_colormap(gui
.mainwin
),
685 &gui
.mainwin
->style
->bg
[GTK_STATE_NORMAL
],
686 (const char *)full_pathname
);
690 * Creates a pixmap by using the pixmap "fname".
693 pixmap_create_from_file(char_u
*fname
, GdkPixmap
**pixmap
, GdkBitmap
**mask
)
695 *pixmap
= gdk_pixmap_colormap_create_from_xpm(
697 gtk_widget_get_colormap(gui
.mainwin
),
699 &gui
.mainwin
->style
->bg
[GTK_STATE_NORMAL
],
700 (const char *)fname
);
703 # endif /* FEAT_TOOLBAR && !HAVE_GTK2 */
706 gui_mch_add_menu_item(vimmenu_T
*menu
, int idx
)
710 parent
= menu
->parent
;
713 if (menu_is_toolbar(parent
->name
))
717 toolbar
= GTK_TOOLBAR(gui
.toolbar
);
718 menu
->submenu_id
= NULL
;
720 if (menu_is_separator(menu
->name
))
722 gtk_toolbar_insert_space(toolbar
, idx
);
731 text
= CONVERT_TO_UTF8(menu
->dname
);
732 tooltip
= CONVERT_TO_UTF8(menu
->strings
[MENU_INDEX_TIP
]);
733 if (tooltip
!= NULL
&& !utf_valid_string(tooltip
, NULL
))
734 /* Invalid text, can happen when 'encoding' is changed. Avoid
735 * a nasty GTK error message, skip the tooltip. */
736 CONVERT_TO_UTF8_FREE(tooltip
);
738 menu
->id
= gtk_toolbar_insert_item(
741 (const char *)tooltip
,
743 create_menu_icon(menu
, gtk_toolbar_get_icon_size(toolbar
)),
744 G_CALLBACK(&menu_item_activate
),
748 if (gtk_socket_id
!= 0)
749 gtk_signal_connect(GTK_OBJECT(menu
->id
), "focus_in_event",
750 GTK_SIGNAL_FUNC(toolbar_button_focus_in_event
), NULL
);
752 CONVERT_TO_UTF8_FREE(text
);
753 CONVERT_TO_UTF8_FREE(tooltip
);
755 # else /* !HAVE_GTK2 */
757 GdkPixmap
*pixmap
= NULL
;
758 GdkBitmap
*mask
= NULL
;
760 /* First try user specified bitmap, then builtin, the a blank. */
761 if (menu
->iconfile
!= NULL
)
763 char_u buf
[MAXPATHL
+ 1];
765 gui_find_iconfile(menu
->iconfile
, buf
, "xpm");
766 pixmap_create_from_file(buf
, &pixmap
, &mask
);
768 if (pixmap
== NULL
&& !menu
->icon_builtin
)
769 pixmap_create_by_dir(menu
->name
, &pixmap
, &mask
);
770 if (pixmap
== NULL
&& menu
->iconidx
>= 0)
771 pixmap_create_by_num(menu
->iconidx
, &pixmap
, &mask
);
773 pixmap_create_from_xpm(tb_blank_xpm
, &pixmap
, &mask
);
775 return; /* should at least have blank pixmap, but if not... */
777 menu
->id
= gtk_toolbar_insert_item(
779 (char *)(menu
->dname
),
780 (char *)(menu
->strings
[MENU_INDEX_TIP
]),
781 (char *)(menu
->dname
),
782 gtk_pixmap_new(pixmap
, mask
),
783 GTK_SIGNAL_FUNC(menu_item_activate
),
786 # endif /* !HAVE_GTK2 */
790 # endif /* FEAT_TOOLBAR */
792 /* No parent, must be a non-menubar menu */
793 if (parent
== NULL
|| parent
->submenu_id
== NULL
)
796 /* Make place for the possible tearoff handle item. Not in the popup
797 * menu, it doesn't have a tearoff item. */
798 if (!menu_is_popup(parent
->name
))
801 if (menu_is_separator(menu
->name
))
803 /* Separator: Just add it */
804 menu
->id
= gtk_menu_item_new();
805 gtk_widget_set_sensitive(menu
->id
, FALSE
);
806 gtk_widget_show(menu
->id
);
807 gtk_menu_insert(GTK_MENU(parent
->submenu_id
), menu
->id
, idx
);
812 /* Add textual menu item. */
813 menu_item_new(menu
, parent
->submenu_id
);
814 gtk_widget_show(menu
->id
);
815 gtk_menu_insert(GTK_MENU(parent
->submenu_id
), menu
->id
, idx
);
817 if (menu
->id
!= NULL
)
818 gtk_signal_connect(GTK_OBJECT(menu
->id
), "activate",
819 GTK_SIGNAL_FUNC(menu_item_activate
), menu
);
822 #endif /* FEAT_MENU */
826 gui_mch_set_text_area_pos(int x
, int y
, int w
, int h
)
828 gtk_form_move_resize(GTK_FORM(gui
.formwin
), gui
.drawarea
, x
, y
, w
, h
);
832 #if defined(FEAT_MENU) || defined(PROTO)
834 * Enable or disable accelerators for the toplevel menus.
837 gui_gtk_set_mnemonics(int enable
)
841 # if !defined(HAVE_GTK2) && defined(GTK_USE_ACCEL)
845 for (menu
= root_menu
; menu
!= NULL
; menu
= menu
->next
)
847 if (menu
->id
== NULL
)
850 # if defined(HAVE_GTK2)
851 name
= translate_mnemonic_tag(menu
->name
, enable
);
852 gtk_label_set_text_with_mnemonic(GTK_LABEL(menu
->label
),
856 # if defined(GTK_USE_ACCEL)
857 name
= translate_mnemonic_tag(menu
->name
, TRUE
);
860 accel_key
= gtk_label_parse_uline(GTK_LABEL(menu
->label
),
862 if (accel_key
!= GDK_VoidSymbol
)
863 gtk_widget_remove_accelerator(menu
->id
, gui
.accel_group
,
864 accel_key
, GDK_MOD1_MASK
);
865 if (enable
&& accel_key
!= GDK_VoidSymbol
)
866 gtk_widget_add_accelerator(menu
->id
, "activate_item",
868 accel_key
, GDK_MOD1_MASK
,
874 name
= translate_mnemonic_tag(menu
->name
, FALSE
);
875 gtk_label_parse_uline(GTK_LABEL(menu
->label
), (const char *)name
);
884 recurse_tearoffs(vimmenu_T
*menu
, int val
)
886 for (; menu
!= NULL
; menu
= menu
->next
)
888 if (menu
->submenu_id
!= NULL
&& menu
->tearoff_handle
!= NULL
889 && menu
->name
[0] != ']' && !menu_is_popup(menu
->name
))
892 gtk_widget_show(menu
->tearoff_handle
);
894 gtk_widget_hide(menu
->tearoff_handle
);
896 recurse_tearoffs(menu
->children
, val
);
901 gui_mch_toggle_tearoffs(int enable
)
903 recurse_tearoffs(root_menu
, enable
);
905 #endif /* FEAT_MENU */
908 #if defined(FEAT_TOOLBAR) && !defined(HAVE_GTK2)
910 * Seems like there's a hole in the GTK Toolbar API: there's no provision for
911 * removing an item from the toolbar. Therefore I need to resort to going
912 * really deeply into the internal widget structures.
914 * <danielk> I'm not sure the statement above is true -- at least with
915 * GTK+ 2 one can just call gtk_widget_destroy() and be done with it.
916 * It is true though that you couldn't remove space items before GTK+ 2
917 * (without digging into the internals that is). But the code below
918 * doesn't seem to handle those either. Well, it's obsolete anyway.
921 toolbar_remove_item_by_text(GtkToolbar
*tb
, const char *text
)
923 GtkContainer
*container
;
925 GtkToolbarChild
*gtbc
;
927 g_return_if_fail(tb
!= NULL
);
928 g_return_if_fail(GTK_IS_TOOLBAR(tb
));
929 container
= GTK_CONTAINER(&tb
->container
);
931 for (childl
= tb
->children
; childl
; childl
= childl
->next
)
933 gtbc
= (GtkToolbarChild
*)childl
->data
;
935 if (gtbc
->type
!= GTK_TOOLBAR_CHILD_SPACE
936 && strcmp(GTK_LABEL(gtbc
->label
)->label
, text
) == 0)
938 gboolean was_visible
;
940 was_visible
= GTK_WIDGET_VISIBLE(gtbc
->widget
);
941 gtk_widget_unparent(gtbc
->widget
);
943 tb
->children
= g_list_remove_link(tb
->children
, childl
);
948 if (was_visible
&& GTK_WIDGET_VISIBLE(container
))
949 gtk_widget_queue_resize(GTK_WIDGET(container
));
955 #endif /* FEAT_TOOLBAR && !HAVE_GTK2 */
958 #if defined(FEAT_TOOLBAR) && defined(HAVE_GTK2)
960 get_menu_position(vimmenu_T
*menu
)
965 for (node
= menu
->parent
->children
; node
!= menu
; node
= node
->next
)
967 g_return_val_if_fail(node
!= NULL
, -1);
973 #endif /* FEAT_TOOLBAR && HAVE_GTK2 */
976 #if defined(FEAT_TOOLBAR) || defined(PROTO)
978 gui_mch_menu_set_tip(vimmenu_T
*menu
)
980 if (menu
->id
!= NULL
&& menu
->parent
!= NULL
981 && gui
.toolbar
!= NULL
&& menu_is_toolbar(menu
->parent
->name
))
986 tooltip
= CONVERT_TO_UTF8(menu
->strings
[MENU_INDEX_TIP
]);
987 if (tooltip
== NULL
|| utf_valid_string(tooltip
, NULL
))
988 /* Only set the tooltip when it's valid utf-8. */
990 tooltip
= menu
->strings
[MENU_INDEX_TIP
];
992 gtk_tooltips_set_tip(GTK_TOOLBAR(gui
.toolbar
)->tooltips
,
993 menu
->id
, (const char *)tooltip
, NULL
);
995 CONVERT_TO_UTF8_FREE(tooltip
);
999 #endif /* FEAT_TOOLBAR */
1002 #if defined(FEAT_MENU) || defined(PROTO)
1004 * Destroy the machine specific menu widget.
1007 gui_mch_destroy_menu(vimmenu_T
*menu
)
1009 # ifdef FEAT_TOOLBAR
1010 if (menu
->parent
!= NULL
&& menu_is_toolbar(menu
->parent
->name
))
1013 if (menu_is_separator(menu
->name
))
1014 gtk_toolbar_remove_space(GTK_TOOLBAR(gui
.toolbar
),
1015 get_menu_position(menu
));
1016 else if (menu
->id
!= NULL
)
1017 gtk_widget_destroy(menu
->id
);
1019 toolbar_remove_item_by_text(GTK_TOOLBAR(gui
.toolbar
),
1020 (const char *)menu
->dname
);
1024 # endif /* FEAT_TOOLBAR */
1026 if (menu
->submenu_id
!= NULL
)
1027 gtk_widget_destroy(menu
->submenu_id
);
1029 if (menu
->id
!= NULL
)
1030 gtk_widget_destroy(menu
->id
);
1033 menu
->submenu_id
= NULL
;
1036 #endif /* FEAT_MENU */
1043 gui_mch_set_scrollbar_thumb(scrollbar_T
*sb
, long val
, long size
, long max
)
1047 GtkAdjustment
*adjustment
;
1049 adjustment
= gtk_range_get_adjustment(GTK_RANGE(sb
->id
));
1051 adjustment
->lower
= 0.0;
1052 adjustment
->value
= val
;
1053 adjustment
->upper
= max
+ 1;
1054 adjustment
->page_size
= size
;
1055 adjustment
->page_increment
= size
< 3L ? 1L : size
- 2L;
1056 adjustment
->step_increment
= 1.0;
1059 g_signal_handler_block(GTK_OBJECT(adjustment
),
1060 (gulong
)sb
->handler_id
);
1062 gtk_signal_handler_block(GTK_OBJECT(adjustment
),
1063 (guint
)sb
->handler_id
);
1065 gtk_adjustment_changed(adjustment
);
1067 g_signal_handler_unblock(GTK_OBJECT(adjustment
),
1068 (gulong
)sb
->handler_id
);
1070 gtk_signal_handler_unblock(GTK_OBJECT(adjustment
),
1071 (guint
)sb
->handler_id
);
1077 gui_mch_set_scrollbar_pos(scrollbar_T
*sb
, int x
, int y
, int w
, int h
)
1080 gtk_form_move_resize(GTK_FORM(gui
.formwin
), sb
->id
, x
, y
, w
, h
);
1084 * Take action upon scrollbar dragging.
1087 adjustment_value_changed(GtkAdjustment
*adjustment
, gpointer data
)
1091 int dragging
= FALSE
;
1094 /* cancel any preediting */
1095 if (im_is_preediting())
1099 sb
= gui_find_scrollbar((long)data
);
1100 value
= (long)adjustment
->value
;
1102 * The dragging argument must be right for the scrollbar to work with
1103 * closed folds. This isn't documented, hopefully this will keep on
1104 * working in later GTK versions.
1106 * FIXME: Well, it doesn't work in GTK2. :)
1107 * HACK: Get the mouse pointer position, if it appears to be on an arrow
1108 * button set "dragging" to FALSE. This assumes square buttons!
1119 GdkModifierType state
;
1123 /* vertical scrollbar: need to set "dragging" properly in case
1124 * there are closed folds. */
1125 gdk_window_get_pointer(sb
->id
->window
, &x
, &y
, &state
);
1126 gdk_window_get_size(sb
->id
->window
, &width
, &height
);
1127 if (x
>= 0 && x
< width
&& y
>= 0 && y
< height
)
1131 /* up arrow: move one (closed fold) line up */
1133 value
= sb
->wp
->w_topline
- 2;
1135 else if (y
> height
- width
)
1137 /* down arrow: move one (closed fold) line down */
1139 value
= sb
->wp
->w_topline
;
1144 dragging
= (GTK_RANGE(sb
->id
)->scroll_type
== GTK_SCROLL_NONE
);
1148 gui_drag_scrollbar(sb
, value
, dragging
);
1150 if (gtk_main_level() > 0)
1154 /* SBAR_VERT or SBAR_HORIZ */
1156 gui_mch_create_scrollbar(scrollbar_T
*sb
, int orient
)
1158 if (orient
== SBAR_HORIZ
)
1159 sb
->id
= gtk_hscrollbar_new(NULL
);
1160 else if (orient
== SBAR_VERT
)
1161 sb
->id
= gtk_vscrollbar_new(NULL
);
1165 GtkAdjustment
*adjustment
;
1167 GTK_WIDGET_UNSET_FLAGS(sb
->id
, GTK_CAN_FOCUS
);
1168 gtk_form_put(GTK_FORM(gui
.formwin
), sb
->id
, 0, 0);
1170 adjustment
= gtk_range_get_adjustment(GTK_RANGE(sb
->id
));
1172 sb
->handler_id
= gtk_signal_connect(
1173 GTK_OBJECT(adjustment
), "value_changed",
1174 GTK_SIGNAL_FUNC(adjustment_value_changed
),
1175 GINT_TO_POINTER(sb
->ident
));
1180 #if defined(FEAT_WINDOWS) || defined(PROTO)
1182 gui_mch_destroy_scrollbar(scrollbar_T
*sb
)
1186 gtk_widget_destroy(sb
->id
);
1193 #if defined(FEAT_BROWSE) || defined(PROTO)
1195 * Implementation of the file selector related stuff
1197 #if defined(HAVE_GTK2) && GTK_CHECK_VERSION(2,4,0)
1198 # define USE_FILE_CHOOSER
1201 #ifndef USE_FILE_CHOOSER
1204 browse_ok_cb(GtkWidget
*widget
, gpointer cbdata
)
1206 gui_T
*vw
= (gui_T
*)cbdata
;
1208 if (vw
->browse_fname
!= NULL
)
1209 g_free(vw
->browse_fname
);
1211 vw
->browse_fname
= (char_u
*)g_strdup(gtk_file_selection_get_filename(
1212 GTK_FILE_SELECTION(vw
->filedlg
)));
1213 gtk_widget_hide(vw
->filedlg
);
1214 if (gtk_main_level() > 0)
1220 browse_cancel_cb(GtkWidget
*widget
, gpointer cbdata
)
1222 gui_T
*vw
= (gui_T
*)cbdata
;
1224 if (vw
->browse_fname
!= NULL
)
1226 g_free(vw
->browse_fname
);
1227 vw
->browse_fname
= NULL
;
1229 gtk_widget_hide(vw
->filedlg
);
1230 if (gtk_main_level() > 0)
1236 browse_destroy_cb(GtkWidget
* widget
)
1238 if (gui
.browse_fname
!= NULL
)
1240 g_free(gui
.browse_fname
);
1241 gui
.browse_fname
= NULL
;
1245 if (gtk_main_level() > 0)
1253 * Put up a file requester.
1254 * Returns the selected name in allocated memory, or NULL for Cancel.
1255 * saving, select file to write
1256 * title title for the window
1258 * ext not used (extension added)
1259 * initdir initial directory, NULL for current dir
1260 * filter not used (file name filter)
1264 gui_mch_browse(int saving
,
1271 #ifdef USE_FILE_CHOOSER
1274 char_u dirbuf
[MAXPATHL
];
1277 title
= CONVERT_TO_UTF8(title
);
1280 /* GTK has a bug, it only works with an absolute path. */
1281 if (initdir
== NULL
|| *initdir
== NUL
)
1282 mch_dirname(dirbuf
, MAXPATHL
);
1283 else if (vim_FullName(initdir
, dirbuf
, MAXPATHL
- 2, FALSE
) == FAIL
)
1285 /* Always need a trailing slash for a directory. */
1286 add_pathsep(dirbuf
);
1288 /* If our pointer is currently hidden, then we should show it. */
1289 gui_mch_mousehide(FALSE
);
1291 #ifdef USE_FILE_CHOOSER
1292 /* We create the dialog each time, so that the button text can be "Open"
1293 * or "Save" according to the action. */
1294 fc
= gtk_file_chooser_dialog_new((const gchar
*)title
,
1295 GTK_WINDOW(gui
.mainwin
),
1296 saving
? GTK_FILE_CHOOSER_ACTION_SAVE
1297 : GTK_FILE_CHOOSER_ACTION_OPEN
,
1298 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1299 saving
? GTK_STOCK_SAVE
: GTK_STOCK_OPEN
, GTK_RESPONSE_ACCEPT
,
1301 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc
),
1302 (const gchar
*)dirbuf
);
1304 gui
.browse_fname
= NULL
;
1305 if (gtk_dialog_run(GTK_DIALOG(fc
)) == GTK_RESPONSE_ACCEPT
)
1309 filename
= gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fc
));
1310 gui
.browse_fname
= (char_u
*)g_strdup(filename
);
1313 gtk_widget_destroy(GTK_WIDGET(fc
));
1317 if (gui
.filedlg
== NULL
)
1319 GtkFileSelection
*fs
; /* shortcut */
1321 gui
.filedlg
= gtk_file_selection_new((const gchar
*)title
);
1322 gtk_window_set_modal(GTK_WINDOW(gui
.filedlg
), TRUE
);
1323 gtk_window_set_transient_for(GTK_WINDOW(gui
.filedlg
),
1324 GTK_WINDOW(gui
.mainwin
));
1325 fs
= GTK_FILE_SELECTION(gui
.filedlg
);
1327 gtk_container_border_width(GTK_CONTAINER(fs
), 4);
1329 gtk_signal_connect(GTK_OBJECT(fs
->ok_button
),
1330 "clicked", GTK_SIGNAL_FUNC(browse_ok_cb
), &gui
);
1331 gtk_signal_connect(GTK_OBJECT(fs
->cancel_button
),
1332 "clicked", GTK_SIGNAL_FUNC(browse_cancel_cb
), &gui
);
1333 /* gtk_signal_connect() doesn't work for destroy, it causes a hang */
1334 gtk_signal_connect_object(GTK_OBJECT(gui
.filedlg
),
1335 "destroy", GTK_SIGNAL_FUNC(browse_destroy_cb
),
1336 GTK_OBJECT(gui
.filedlg
));
1339 gtk_window_set_title(GTK_WINDOW(gui
.filedlg
), (const gchar
*)title
);
1341 /* Concatenate "initdir" and "dflt". */
1342 if (dflt
!= NULL
&& *dflt
!= NUL
1343 && STRLEN(dirbuf
) + 2 + STRLEN(dflt
) < MAXPATHL
)
1344 STRCAT(dirbuf
, dflt
);
1346 gtk_file_selection_set_filename(GTK_FILE_SELECTION(gui
.filedlg
),
1347 (const gchar
*)dirbuf
);
1349 gui_gtk_position_in_parent(GTK_WIDGET(gui
.mainwin
),
1350 GTK_WIDGET(gui
.filedlg
), VW_POS_MOUSE
);
1353 gtk_widget_show(gui
.filedlg
);
1354 while (gui
.filedlg
&& GTK_WIDGET_DRAWABLE(gui
.filedlg
))
1355 gtk_main_iteration_do(TRUE
);
1359 CONVERT_TO_UTF8_FREE(title
);
1361 if (gui
.browse_fname
== NULL
)
1364 /* shorten the file name if possible */
1365 return vim_strsave(shorten_fname1(gui
.browse_fname
));
1368 #if defined(HAVE_GTK2) || defined(PROTO)
1371 * Put up a directory selector
1372 * Returns the selected name in allocated memory, or NULL for Cancel.
1373 * title title for the window
1375 * initdir initial directory, NULL for current dir
1383 # if defined(GTK_FILE_CHOOSER) /* Only in GTK 2.4 and later. */
1384 char_u dirbuf
[MAXPATHL
];
1386 GtkWidget
*dirdlg
; /* file selection dialog */
1387 char_u
*dirname
= NULL
;
1389 title
= CONVERT_TO_UTF8(title
);
1391 dirdlg
= gtk_file_chooser_dialog_new(
1392 (const gchar
*)title
,
1393 GTK_WINDOW(gui
.mainwin
),
1394 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
,
1395 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1396 GTK_STOCK_OK
, GTK_RESPONSE_ACCEPT
,
1399 CONVERT_TO_UTF8_FREE(title
);
1401 /* if our pointer is currently hidden, then we should show it. */
1402 gui_mch_mousehide(FALSE
);
1404 /* GTK appears to insist on an absolute path. */
1405 if (initdir
== NULL
|| *initdir
== NUL
1406 || vim_FullName(initdir
, dirbuf
, MAXPATHL
- 10, FALSE
) == FAIL
)
1407 mch_dirname(dirbuf
, MAXPATHL
- 10);
1409 /* Always need a trailing slash for a directory.
1410 * Also add a dummy file name, so that we get to the directory. */
1411 add_pathsep(dirbuf
);
1412 STRCAT(dirbuf
, "@zd(*&1|");
1413 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dirdlg
),
1414 (const gchar
*)dirbuf
);
1416 /* Run the dialog. */
1417 if (gtk_dialog_run(GTK_DIALOG(dirdlg
)) == GTK_RESPONSE_ACCEPT
)
1418 dirname
= (char_u
*)gtk_file_chooser_get_filename(
1419 GTK_FILE_CHOOSER(dirdlg
));
1420 gtk_widget_destroy(dirdlg
);
1421 if (dirname
== NULL
)
1424 /* shorten the file name if possible */
1425 p
= vim_strsave(shorten_fname1(dirname
));
1430 /* For GTK 2.2 and earlier: fall back to ordinary file selector. */
1431 return gui_mch_browse(0, title
, NULL
, NULL
, initdir
, NULL
);
1437 #endif /* FEAT_BROWSE */
1439 #if defined(FEAT_GUI_DIALOG) && !defined(HAVE_GTK2)
1441 static char_u
*dialog_textfield
= NULL
;
1442 static GtkWidget
*dialog_textentry
;
1445 dlg_destroy(GtkWidget
*dlg
)
1447 if (dialog_textfield
!= NULL
)
1451 text
= gtk_entry_get_text(GTK_ENTRY(dialog_textentry
));
1452 vim_strncpy(dialog_textfield
, (char_u
*)text
, IOSIZE
- 1);
1455 /* Destroy the dialog, will break the waiting loop. */
1456 gtk_widget_destroy(dlg
);
1459 # ifdef FEAT_GUI_GNOME
1462 gui_gnome_dialog( int type
,
1471 char_u
*buttons_copy
, *p
, *next
;
1472 char **buttons_list
;
1475 /* make a copy, so that we can insert NULs */
1476 if ((buttons_copy
= vim_strsave(buttons
)) == NULL
)
1479 /* determine exact number of buttons and allocate array to hold them */
1480 for (butcount
= 0, p
= buttons
; *p
; p
++)
1486 buttons_list
= g_new0(char *, butcount
+ 1);
1492 gdtype
= GNOME_MESSAGE_BOX_ERROR
;
1495 gdtype
= GNOME_MESSAGE_BOX_WARNING
;
1498 gdtype
= GNOME_MESSAGE_BOX_INFO
;
1501 gdtype
= GNOME_MESSAGE_BOX_QUESTION
;
1504 gdtype
= GNOME_MESSAGE_BOX_GENERIC
;
1508 for (cur
= 0; cur
< butcount
; ++cur
)
1510 for (next
= p
; *next
; ++next
)
1512 if (*next
== DLG_HOTKEY_CHAR
)
1513 mch_memmove(next
, next
+ 1, STRLEN(next
));
1514 if (*next
== DLG_BUTTON_SEP
)
1521 /* this should probably go into a table, but oh well */
1522 if (g_strcasecmp((char *)p
, "Ok") == 0)
1523 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_OK
);
1524 else if (g_strcasecmp((char *)p
, "Cancel") == 0)
1525 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_CANCEL
);
1526 else if (g_strcasecmp((char *)p
, "Yes") == 0)
1527 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_YES
);
1528 else if (g_strcasecmp((char *)p
, "No") == 0)
1529 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_NO
);
1530 else if (g_strcasecmp((char *)p
, "Close") == 0)
1531 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_CLOSE
);
1532 else if (g_strcasecmp((char *)p
, "Help") == 0)
1533 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_HELP
);
1534 else if (g_strcasecmp((char *)p
, "Apply") == 0)
1535 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_APPLY
);
1538 * these aren't really used that often anyway, but are listed here as
1539 * placeholders in case we need them.
1541 else if (g_strcasecmp((char *)p
, "Next") == 0)
1542 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_NEXT
);
1543 else if (g_strcasecmp((char *)p
, "Prev") == 0)
1544 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_PREV
);
1545 else if (g_strcasecmp((char *)p
, "Up") == 0)
1546 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_UP
);
1547 else if (g_strcasecmp((char *)p
, "Down") == 0)
1548 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_DOWN
);
1549 else if (g_strcasecmp((char *)p
, "Font") == 0)
1550 buttons_list
[cur
] = g_strdup(GNOME_STOCK_BUTTON_FONT
);
1553 buttons_list
[cur
] = g_strdup((char *)p
);
1560 vim_free(buttons_copy
);
1562 dlg
= gnome_message_box_newv((const char *)message
,
1563 (const char *)gdtype
,
1564 (const char **)buttons_list
);
1565 for (cur
= 0; cur
< butcount
; ++cur
)
1566 g_free(buttons_list
[cur
]);
1567 g_free(buttons_list
);
1569 dialog_textfield
= textfield
;
1570 if (textfield
!= NULL
)
1572 /* Add text entry field */
1573 dialog_textentry
= gtk_entry_new();
1574 gtk_box_pack_start(GTK_BOX(GNOME_DIALOG(dlg
)->vbox
), dialog_textentry
,
1576 gtk_entry_set_text(GTK_ENTRY(dialog_textentry
),
1577 (const gchar
*)textfield
);
1578 gtk_entry_select_region(GTK_ENTRY(dialog_textentry
), 0,
1580 gtk_entry_set_max_length(GTK_ENTRY(dialog_textentry
), IOSIZE
- 1);
1581 gtk_entry_set_position(GTK_ENTRY(dialog_textentry
), STRLEN(textfield
));
1582 gtk_widget_show(dialog_textentry
);
1583 gtk_window_set_focus(GTK_WINDOW(dlg
), dialog_textentry
);
1586 gtk_signal_connect_object(GTK_OBJECT(dlg
), "destroy",
1587 GTK_SIGNAL_FUNC(dlg_destroy
), GTK_OBJECT(dlg
));
1588 gnome_dialog_set_default(GNOME_DIALOG(dlg
), dfltbutton
+ 1);
1589 gui_gtk_position_in_parent(GTK_WIDGET(gui
.mainwin
),
1590 GTK_WIDGET(dlg
), VW_POS_MOUSE
);
1592 return (1 + gnome_dialog_run_and_close(GNOME_DIALOG(dlg
)));
1595 # endif /* FEAT_GUI_GNOME */
1597 typedef struct _ButtonData
1604 typedef struct _CancelData
1613 dlg_button_clicked(GtkWidget
* widget
, ButtonData
*data
)
1615 *(data
->status
) = data
->index
+ 1;
1616 dlg_destroy(data
->dialog
);
1620 * This makes the Escape key equivalent to the cancel button.
1624 dlg_key_press_event(GtkWidget
*widget
, GdkEventKey
*event
, CancelData
*data
)
1626 /* Ignore hitting Enter (or Space) when there is no default button. */
1627 if (data
->ignore_enter
&& (event
->keyval
== GDK_Return
1628 || event
->keyval
== ' '))
1630 else /* A different key was pressed, return to normal behavior */
1631 data
->ignore_enter
= FALSE
;
1633 if (event
->keyval
!= GDK_Escape
&& event
->keyval
!= GDK_Return
)
1636 /* The result value of 0 from a dialog is signaling cancelation.
1638 *(data
->status
) = (event
->keyval
== GDK_Return
);
1639 dlg_destroy(data
->dialog
);
1645 * Callback function for when the dialog was destroyed by a window manager.
1648 dlg_destroy_cb(int *p
)
1650 *p
= TRUE
; /* set dialog_destroyed to break out of the loop */
1651 if (gtk_main_level() > 0)
1657 gui_mch_dialog( int type
, /* type of dialog */
1658 char_u
*title
, /* title of dialog */
1659 char_u
*message
, /* message text */
1660 char_u
*buttons
, /* names of buttons */
1661 int def_but
, /* default button */
1662 char_u
*textfield
) /* text for textfield or NULL */
1668 int dialog_status
= -1;
1669 int dialog_destroyed
= FALSE
;
1676 GtkWidget
*dialogmessage
;
1677 GtkWidget
*action_area
;
1678 GtkWidget
*sub_area
;
1679 GtkWidget
*separator
;
1680 GtkAccelGroup
*accel_group
;
1682 GdkPixmap
*icon
= NULL
;
1683 GdkBitmap
*mask
= NULL
;
1684 char **icon_data
= NULL
;
1688 CancelData cancel_data
;
1690 /* if our pointer is currently hidden, then we should show it. */
1691 gui_mch_mousehide(FALSE
);
1693 # ifdef FEAT_GUI_GNOME
1694 /* If Gnome is available, use it for the dialog. */
1695 if (gtk_socket_id
== 0)
1696 return gui_gnome_dialog(type
, title
, message
, buttons
, def_but
,
1701 title
= (char_u
*)_("Vim dialog...");
1703 if ((type
< 0) || (type
> VIM_LAST_TYPE
))
1706 /* Check 'v' flag in 'guioptions': vertical button placement. */
1707 vertical
= (vim_strchr(p_go
, GO_VERTICAL
) != NULL
);
1709 dialog
= gtk_window_new(GTK_WINDOW_DIALOG
);
1710 gtk_window_set_title(GTK_WINDOW(dialog
), (const gchar
*)title
);
1711 gtk_window_set_transient_for(GTK_WINDOW(dialog
), GTK_WINDOW(gui
.mainwin
));
1712 gtk_widget_realize(dialog
);
1713 gdk_window_set_decorations(dialog
->window
, GDK_DECOR_BORDER
);
1714 gdk_window_set_functions(dialog
->window
, GDK_FUNC_MOVE
);
1716 cancel_data
.status
= &dialog_status
;
1717 cancel_data
.dialog
= dialog
;
1718 gtk_signal_connect_after(GTK_OBJECT(dialog
), "key_press_event",
1719 GTK_SIGNAL_FUNC(dlg_key_press_event
),
1720 (gpointer
) &cancel_data
);
1721 /* Catch the destroy signal, otherwise we don't notice a window manager
1722 * destroying the dialog window. */
1723 gtk_signal_connect_object(GTK_OBJECT(dialog
), "destroy",
1724 GTK_SIGNAL_FUNC(dlg_destroy_cb
),
1725 (gpointer
)&dialog_destroyed
);
1727 gtk_grab_add(dialog
);
1729 /* this makes it look beter on Motif style window managers */
1730 frame
= gtk_frame_new(NULL
);
1731 gtk_container_add(GTK_CONTAINER(dialog
), frame
);
1732 gtk_widget_show(frame
);
1734 vbox
= gtk_vbox_new(FALSE
, 0);
1735 gtk_container_add(GTK_CONTAINER(frame
), vbox
);
1736 gtk_widget_show(vbox
);
1738 table
= gtk_table_new(1, 3, FALSE
);
1739 gtk_table_set_row_spacings(GTK_TABLE(table
), 4);
1740 gtk_table_set_col_spacings(GTK_TABLE(table
), 8);
1741 gtk_container_border_width(GTK_CONTAINER(table
), 4);
1742 gtk_box_pack_start(GTK_BOX(vbox
), table
, 4, 4, 0);
1743 gtk_widget_show(table
);
1749 icon_data
= generic_xpm
;
1752 icon_data
= error_xpm
;
1755 icon_data
= alert_xpm
;
1758 icon_data
= info_xpm
;
1761 icon_data
= quest_xpm
;
1764 icon_data
= generic_xpm
;
1766 icon
= gdk_pixmap_colormap_create_from_xpm_d(NULL
,
1767 gtk_widget_get_colormap(dialog
),
1768 &mask
, NULL
, icon_data
);
1771 pixmap
= gtk_pixmap_new(icon
, mask
);
1772 /* gtk_misc_set_alignment(GTK_MISC(pixmap), 0.5, 0.5); */
1773 gtk_table_attach_defaults(GTK_TABLE(table
), pixmap
, 0, 1, 0, 1);
1774 gtk_widget_show(pixmap
);
1778 dialogmessage
= gtk_label_new((const gchar
*)message
);
1779 gtk_table_attach_defaults(GTK_TABLE(table
), dialogmessage
, 1, 2, 0, 1);
1780 gtk_widget_show(dialogmessage
);
1782 dialog_textfield
= textfield
;
1783 if (textfield
!= NULL
)
1785 /* Add text entry field */
1786 dialog_textentry
= gtk_entry_new();
1787 gtk_widget_set_usize(dialog_textentry
, 400, -2);
1788 gtk_box_pack_start(GTK_BOX(vbox
), dialog_textentry
, TRUE
, TRUE
, 0);
1789 gtk_entry_set_text(GTK_ENTRY(dialog_textentry
),
1790 (const gchar
*)textfield
);
1791 gtk_entry_select_region(GTK_ENTRY(dialog_textentry
), 0,
1793 gtk_entry_set_max_length(GTK_ENTRY(dialog_textentry
), IOSIZE
- 1);
1794 gtk_entry_set_position(GTK_ENTRY(dialog_textentry
), STRLEN(textfield
));
1795 gtk_widget_show(dialog_textentry
);
1798 /* Add box for buttons */
1799 action_area
= gtk_hbox_new(FALSE
, 0);
1800 gtk_container_border_width(GTK_CONTAINER(action_area
), 4);
1801 gtk_box_pack_end(GTK_BOX(vbox
), action_area
, FALSE
, TRUE
, 0);
1802 gtk_widget_show(action_area
);
1804 /* Add a [vh]box in the hbox to center the buttons in the dialog. */
1806 sub_area
= gtk_vbox_new(FALSE
, 0);
1808 sub_area
= gtk_hbox_new(FALSE
, 0);
1809 gtk_container_set_border_width(GTK_CONTAINER(sub_area
), 0);
1810 gtk_box_pack_start(GTK_BOX(action_area
), sub_area
, TRUE
, FALSE
, 0);
1811 gtk_widget_show(sub_area
);
1814 * Create the buttons.
1818 * Translate the Vim accelerator character into an underscore for GTK+.
1819 * Double underscores to keep them in the label.
1821 /* count the number of underscores */
1823 for (p
= buttons
; *p
; ++p
)
1827 /* make a copy of "buttons" with the translated characters */
1828 names
= alloc(STRLEN(buttons
) + i
);
1833 for (i
= 0; buttons
[i
]; ++i
)
1835 if (buttons
[i
] == DLG_HOTKEY_CHAR
)
1839 if (buttons
[i
] == '_')
1846 /* Count the number of buttons and allocate button[] and data[]. */
1848 for (p
= names
; *p
; ++p
)
1849 if (*p
== DLG_BUTTON_SEP
)
1851 button
= (GtkWidget
**)alloc((unsigned)(butcount
* sizeof(GtkWidget
*)));
1852 data
= (ButtonData
*)alloc((unsigned)(butcount
* sizeof(ButtonData
)));
1853 if (button
== NULL
|| data
== NULL
)
1861 /* Attach the new accelerator group to the window. */
1862 accel_group
= gtk_accel_group_new();
1863 gtk_accel_group_attach(accel_group
, GTK_OBJECT(dialog
));
1866 for (butcount
= 0; *p
; ++butcount
)
1870 # ifdef GTK_USE_ACCEL
1874 /* Chunk out this single button. */
1875 for (next
= p
; *next
; ++next
)
1877 if (*next
== DLG_BUTTON_SEP
)
1884 button
[butcount
] = gtk_button_new();
1885 GTK_WIDGET_SET_FLAGS(button
[butcount
], GTK_CAN_DEFAULT
);
1887 label
= gtk_accel_label_new("");
1888 gtk_accel_label_set_accel_widget(GTK_ACCEL_LABEL(label
), dialog
);
1890 # ifdef GTK_USE_ACCEL
1891 accel_key
= gtk_label_parse_uline(GTK_LABEL(label
), (const gchar
*)p
);
1892 /* Don't add accelator if 'winaltkeys' is "no". */
1893 if (accel_key
!= GDK_VoidSymbol
)
1895 gtk_widget_add_accelerator(button
[butcount
],
1902 (void)gtk_label_parse_uline(GTK_LABEL(label
), (const gchar
*)p
);
1905 gtk_container_add(GTK_CONTAINER(button
[butcount
]), label
);
1906 gtk_widget_show_all(button
[butcount
]);
1908 data
[butcount
].status
= &dialog_status
;
1909 data
[butcount
].index
= butcount
;
1910 data
[butcount
].dialog
= dialog
;
1911 gtk_signal_connect(GTK_OBJECT(button
[butcount
]),
1912 (const char *)"clicked",
1913 GTK_SIGNAL_FUNC(dlg_button_clicked
),
1914 (gpointer
) &data
[butcount
]);
1916 gtk_box_pack_start(GTK_BOX(sub_area
), button
[butcount
],
1923 cancel_data
.ignore_enter
= FALSE
;
1926 --def_but
; /* 1 is first button */
1927 if (def_but
>= butcount
)
1931 gtk_widget_grab_focus(button
[def_but
]);
1932 gtk_widget_grab_default(button
[def_but
]);
1935 /* No default, ignore hitting Enter. */
1936 cancel_data
.ignore_enter
= TRUE
;
1939 if (textfield
!= NULL
)
1940 gtk_window_set_focus(GTK_WINDOW(dialog
), dialog_textentry
);
1942 separator
= gtk_hseparator_new();
1943 gtk_box_pack_end(GTK_BOX(vbox
), separator
, FALSE
, TRUE
, 0);
1944 gtk_widget_show(separator
);
1948 gui_gtk_position_in_parent(GTK_WIDGET(gui
.mainwin
),
1949 GTK_WIDGET(dialog
), VW_POS_MOUSE
);
1951 gtk_widget_show(dialog
);
1953 /* loop here until the dialog goes away */
1954 while (dialog_status
== -1 && !dialog_destroyed
1955 && GTK_WIDGET_DRAWABLE(dialog
))
1956 gtk_main_iteration_do(TRUE
);
1958 if (dialog_status
< 0)
1960 if (dialog_status
!= 1 && textfield
!= NULL
)
1961 *textfield
= NUL
; /* dialog was cancelled */
1963 /* let the garbage collector know that we don't need it any longer */
1964 gtk_accel_group_unref(accel_group
);
1969 return dialog_status
;
1972 #endif /* FEAT_GUI_DIALOG && !HAVE_GTK2 */
1975 #if (defined(FEAT_GUI_DIALOG) && defined(HAVE_GTK2)) || defined(PROTO)
1978 create_message_dialog(int type
, char_u
*title
, char_u
*message
)
1981 GtkMessageType message_type
;
1985 case VIM_ERROR
: message_type
= GTK_MESSAGE_ERROR
; break;
1986 case VIM_WARNING
: message_type
= GTK_MESSAGE_WARNING
; break;
1987 case VIM_QUESTION
: message_type
= GTK_MESSAGE_QUESTION
; break;
1988 default: message_type
= GTK_MESSAGE_INFO
; break;
1991 message
= CONVERT_TO_UTF8(message
);
1992 dialog
= gtk_message_dialog_new(GTK_WINDOW(gui
.mainwin
),
1993 GTK_DIALOG_DESTROY_WITH_PARENT
,
1996 "%s", (const char *)message
);
1997 CONVERT_TO_UTF8_FREE(message
);
2001 title
= CONVERT_TO_UTF8(title
);
2002 gtk_window_set_title(GTK_WINDOW(dialog
), (const char *)title
);
2003 CONVERT_TO_UTF8_FREE(title
);
2005 else if (type
== VIM_GENERIC
)
2007 gtk_window_set_title(GTK_WINDOW(dialog
), "VIM");
2014 * Split up button_string into individual button labels by inserting
2015 * NUL bytes. Also replace the Vim-style mnemonic accelerator prefix
2016 * '&' with '_'. button_string must point to allocated memory!
2017 * Return an allocated array of pointers into button_string.
2020 split_button_string(char_u
*button_string
, int *n_buttons
)
2024 unsigned int count
= 1;
2026 for (p
= button_string
; *p
!= NUL
; ++p
)
2027 if (*p
== DLG_BUTTON_SEP
)
2030 array
= (char **)alloc((count
+ 1) * sizeof(char *));
2035 array
[count
++] = (char *)button_string
;
2036 for (p
= button_string
; *p
!= NUL
; )
2038 if (*p
== DLG_BUTTON_SEP
)
2041 array
[count
++] = (char *)p
;
2043 else if (*p
== DLG_HOTKEY_CHAR
)
2048 array
[count
] = NULL
; /* currently not relied upon, but doesn't hurt */
2056 split_button_translation(const char *message
)
2058 char **buttons
= NULL
;
2063 for (str
= (char_u
*)message
; *str
!= NUL
; ++str
)
2064 if (*str
== DLG_BUTTON_SEP
)
2067 str
= (char_u
*)_(message
);
2070 if (output_conv
.vc_type
!= CONV_NONE
)
2071 str
= string_convert(&output_conv
, str
, NULL
);
2073 str
= vim_strsave(str
);
2076 buttons
= split_button_string(str
, &n_buttons
);
2079 * Uh-oh... this should never ever happen. But we don't wanna crash
2080 * if the translation is broken, thus fall back to the untranslated
2081 * buttons string in case of emergency.
2083 if (buttons
== NULL
|| n_buttons
!= n_expected
)
2088 str
= vim_strsave((char_u
*)message
);
2091 buttons
= split_button_string(str
, &n_buttons
);
2092 if (buttons
== NULL
)
2100 button_equal(const char *a
, const char *b
)
2102 while (*a
!= '\0' && *b
!= '\0')
2104 if (*a
== '_' && *++a
== '\0')
2106 if (*b
== '_' && *++b
== '\0')
2109 if (g_unichar_tolower(g_utf8_get_char(a
))
2110 != g_unichar_tolower(g_utf8_get_char(b
)))
2113 a
= g_utf8_next_char(a
);
2114 b
= g_utf8_next_char(b
);
2117 return (*a
== '\0' && *b
== '\0');
2121 dialog_add_buttons(GtkDialog
*dialog
, char_u
*button_string
)
2124 char **ync
; /* "yes no cancel" */
2129 button_string
= vim_strsave(button_string
); /* must be writable */
2130 if (button_string
== NULL
)
2133 /* Check 'v' flag in 'guioptions': vertical button placement. */
2134 if (vim_strchr(p_go
, GO_VERTICAL
) != NULL
)
2136 GtkWidget
*vbutton_box
;
2138 vbutton_box
= gtk_vbutton_box_new();
2139 gtk_widget_show(vbutton_box
);
2140 gtk_box_pack_end(GTK_BOX(GTK_DIALOG(dialog
)->vbox
),
2141 vbutton_box
, TRUE
, FALSE
, 0);
2142 /* Overrule the "action_area" value, hopefully this works... */
2143 GTK_DIALOG(dialog
)->action_area
= vbutton_box
;
2147 * Yes this is ugly, I don't particularly like it either. But doing it
2148 * this way has the compelling advantage that translations need not to
2149 * be touched at all. See below what 'ok' and 'ync' are used for.
2151 ok
= split_button_translation(N_("&Ok"));
2152 ync
= split_button_translation(N_("&Yes\n&No\n&Cancel"));
2153 buttons
= split_button_string(button_string
, &n_buttons
);
2156 * Yes, the buttons are in reversed order to match the GNOME 2 desktop
2157 * environment. Don't hit me -- it's all about consistency.
2158 * Well, apparently somebody changed his mind: with GTK 2.2.4 it works the
2159 * other way around...
2161 for (idx
= 1; idx
<= n_buttons
; ++idx
)
2166 label
= buttons
[idx
- 1];
2168 * Perform some guesswork to find appropriate stock items for the
2169 * buttons. We have to compare with a sample of the translated
2170 * button string to get things right. Yes, this is hackish :/
2172 * But even the common button labels aren't necessarily translated,
2173 * since anyone can create their own dialogs using Vim functions.
2174 * Thus we have to check for those too.
2176 if (ok
!= NULL
&& ync
!= NULL
) /* almost impossible to fail */
2178 if (button_equal(label
, ok
[0])) label
= GTK_STOCK_OK
;
2179 else if (button_equal(label
, ync
[0])) label
= GTK_STOCK_YES
;
2180 else if (button_equal(label
, ync
[1])) label
= GTK_STOCK_NO
;
2181 else if (button_equal(label
, ync
[2])) label
= GTK_STOCK_CANCEL
;
2182 else if (button_equal(label
, "Ok")) label
= GTK_STOCK_OK
;
2183 else if (button_equal(label
, "Yes")) label
= GTK_STOCK_YES
;
2184 else if (button_equal(label
, "No")) label
= GTK_STOCK_NO
;
2185 else if (button_equal(label
, "Cancel")) label
= GTK_STOCK_CANCEL
;
2187 label8
= CONVERT_TO_UTF8((char_u
*)label
);
2188 gtk_dialog_add_button(dialog
, (const gchar
*)label8
, idx
);
2189 CONVERT_TO_UTF8_FREE(label8
);
2199 vim_free(button_string
);
2203 * Allow mnemonic accelerators to be activated without pressing <Alt>.
2204 * I'm not sure if it's a wise idea to do this. However, the old GTK+ 1.2
2205 * GUI used to work this way, and I consider the impact on UI consistency
2206 * low enough to justify implementing this as a special Vim feature.
2208 typedef struct _DialogInfo
2210 int ignore_enter
; /* no default button, ignore "Enter" */
2211 int noalt
; /* accept accelerators without Alt */
2212 GtkDialog
*dialog
; /* Widget of the dialog */
2217 dialog_key_press_event_cb(GtkWidget
*widget
, GdkEventKey
*event
, gpointer data
)
2219 DialogInfo
*di
= (DialogInfo
*)data
;
2221 /* Ignore hitting Enter (or Space) when there is no default button. */
2222 if (di
->ignore_enter
&& (event
->keyval
== GDK_Return
2223 || event
->keyval
== ' '))
2225 else /* A different key was pressed, return to normal behavior */
2226 di
->ignore_enter
= FALSE
;
2228 /* Close the dialog when hitting "Esc". */
2229 if (event
->keyval
== GDK_Escape
)
2231 gtk_dialog_response(di
->dialog
, GTK_RESPONSE_REJECT
);
2236 && (event
->state
& gtk_accelerator_get_default_mod_mask()) == 0)
2238 return gtk_window_mnemonic_activate(
2239 GTK_WINDOW(widget
), event
->keyval
,
2240 gtk_window_get_mnemonic_modifier(GTK_WINDOW(widget
)));
2243 return FALSE
; /* continue emission */
2247 gui_mch_dialog(int type
, /* type of dialog */
2248 char_u
*title
, /* title of dialog */
2249 char_u
*message
, /* message text */
2250 char_u
*buttons
, /* names of buttons */
2251 int def_but
, /* default button */
2252 char_u
*textfield
) /* text for textfield or NULL */
2255 GtkWidget
*entry
= NULL
;
2258 DialogInfo dialoginfo
;
2260 dialog
= create_message_dialog(type
, title
, message
);
2261 dialoginfo
.dialog
= GTK_DIALOG(dialog
);
2262 dialog_add_buttons(GTK_DIALOG(dialog
), buttons
);
2264 if (textfield
!= NULL
)
2266 GtkWidget
*alignment
;
2268 entry
= gtk_entry_new();
2269 gtk_widget_show(entry
);
2271 text
= CONVERT_TO_UTF8(textfield
);
2272 gtk_entry_set_text(GTK_ENTRY(entry
), (const char *)text
);
2273 CONVERT_TO_UTF8_FREE(text
);
2275 alignment
= gtk_alignment_new((float)0.5, (float)0.5,
2276 (float)1.0, (float)1.0);
2277 gtk_container_add(GTK_CONTAINER(alignment
), entry
);
2278 gtk_container_set_border_width(GTK_CONTAINER(alignment
), 5);
2279 gtk_widget_show(alignment
);
2281 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog
)->vbox
),
2282 alignment
, TRUE
, FALSE
, 0);
2283 dialoginfo
.noalt
= FALSE
;
2286 dialoginfo
.noalt
= TRUE
;
2288 /* Allow activation of mnemonic accelerators without pressing <Alt> when
2289 * there is no textfield. Handle pressing Esc. */
2290 g_signal_connect(G_OBJECT(dialog
), "key_press_event",
2291 G_CALLBACK(&dialog_key_press_event_cb
), &dialoginfo
);
2295 gtk_dialog_set_default_response(GTK_DIALOG(dialog
), def_but
);
2296 dialoginfo
.ignore_enter
= FALSE
;
2299 /* No default button, ignore pressing Enter. */
2300 dialoginfo
.ignore_enter
= TRUE
;
2302 /* Show the mouse pointer if it's currently hidden. */
2303 gui_mch_mousehide(FALSE
);
2305 response
= gtk_dialog_run(GTK_DIALOG(dialog
));
2307 /* GTK_RESPONSE_NONE means the dialog was programmatically destroyed. */
2308 if (response
!= GTK_RESPONSE_NONE
)
2310 if (response
== GTK_RESPONSE_ACCEPT
) /* Enter pressed */
2312 if (textfield
!= NULL
)
2314 text
= (char_u
*)gtk_entry_get_text(GTK_ENTRY(entry
));
2315 text
= CONVERT_FROM_UTF8(text
);
2317 vim_strncpy(textfield
, text
, IOSIZE
- 1);
2319 CONVERT_FROM_UTF8_FREE(text
);
2321 gtk_widget_destroy(dialog
);
2324 /* Terrible hack: When the text area still has focus when we remove the
2325 * dialog, somehow gvim loses window focus. This is with "point to type"
2326 * in the KDE 3.1 window manager. Warp the mouse pointer to outside the
2327 * window and back to avoid that. */
2332 gdk_window_get_pointer(gui
.drawarea
->window
, &x
, &y
, NULL
);
2333 gui_mch_setmouse(-100, -100);
2334 gui_mch_setmouse(x
, y
);
2337 return response
> 0 ? response
: 0;
2340 #endif /* FEAT_GUI_DIALOG && HAVE_GTK2 */
2343 #if defined(FEAT_MENU) || defined(PROTO)
2346 gui_mch_show_popupmenu(vimmenu_T
*menu
)
2348 # if defined(FEAT_XIM) && defined(HAVE_GTK2)
2350 * Append a submenu for selecting an input method. This is
2351 * currently the only way to switch input methods at runtime.
2353 if (xic
!= NULL
&& g_object_get_data(G_OBJECT(menu
->submenu_id
),
2354 "vim-has-im-menu") == NULL
)
2356 GtkWidget
*menuitem
;
2360 menuitem
= gtk_separator_menu_item_new();
2361 gtk_widget_show(menuitem
);
2362 gtk_menu_shell_append(GTK_MENU_SHELL(menu
->submenu_id
), menuitem
);
2364 name
= (char_u
*)_("Input _Methods");
2365 name
= CONVERT_TO_UTF8(name
);
2366 menuitem
= gtk_menu_item_new_with_mnemonic((const char *)name
);
2367 CONVERT_TO_UTF8_FREE(name
);
2368 gtk_widget_show(menuitem
);
2370 submenu
= gtk_menu_new();
2371 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem
), submenu
);
2372 gtk_menu_shell_append(GTK_MENU_SHELL(menu
->submenu_id
), menuitem
);
2374 gtk_im_multicontext_append_menuitems(GTK_IM_MULTICONTEXT(xic
),
2375 GTK_MENU_SHELL(submenu
));
2376 g_object_set_data(G_OBJECT(menu
->submenu_id
),
2377 "vim-has-im-menu", GINT_TO_POINTER(TRUE
));
2379 # endif /* FEAT_XIM && HAVE_GTK2 */
2381 gtk_menu_popup(GTK_MENU(menu
->submenu_id
),
2383 (GtkMenuPositionFunc
)NULL
, NULL
,
2384 3U, (guint32
)GDK_CURRENT_TIME
);
2387 /* Ugly global variable to pass "mouse_pos" flag from gui_make_popup() to
2388 * popup_menu_position_func(). */
2389 static int popup_mouse_pos
;
2392 * Menu position callback; used by gui_make_popup() to place the menu
2393 * at the current text cursor position.
2395 * Note: The push_in output argument seems to affect scrolling of huge
2396 * menus that don't fit on the screen. Leave it at the default for now.
2400 popup_menu_position_func(GtkMenu
*menu
,
2407 gdk_window_get_origin(gui
.drawarea
->window
, x
, y
);
2409 if (popup_mouse_pos
)
2413 gui_mch_getmouse(&mx
, &my
);
2417 else if (curwin
!= NULL
&& gui
.drawarea
!= NULL
&& gui
.drawarea
->window
!= NULL
)
2419 /* Find the cursor position in the current window */
2420 *x
+= FILL_X(W_WINCOL(curwin
) + curwin
->w_wcol
+ 1) + 1;
2421 *y
+= FILL_Y(W_WINROW(curwin
) + curwin
->w_wrow
+ 1) + 1;
2426 gui_make_popup(char_u
*path_name
, int mouse_pos
)
2430 popup_mouse_pos
= mouse_pos
;
2432 menu
= gui_find_menu(path_name
);
2434 if (menu
!= NULL
&& menu
->submenu_id
!= NULL
)
2436 gtk_menu_popup(GTK_MENU(menu
->submenu_id
),
2438 &popup_menu_position_func
, NULL
,
2439 0U, (guint32
)GDK_CURRENT_TIME
);
2443 #endif /* FEAT_MENU */
2447 * We don't create it twice.
2450 typedef struct _SharedFindReplace
2452 GtkWidget
*dialog
; /* the main dialog widget */
2453 GtkWidget
*wword
; /* 'Whole word only' check button */
2454 GtkWidget
*mcase
; /* 'Match case' check button */
2455 GtkWidget
*up
; /* search direction 'Up' radio button */
2456 GtkWidget
*down
; /* search direction 'Down' radio button */
2457 GtkWidget
*what
; /* 'Find what' entry text widget */
2458 GtkWidget
*with
; /* 'Replace with' entry text widget */
2459 GtkWidget
*find
; /* 'Find Next' action button */
2460 GtkWidget
*replace
; /* 'Replace With' action button */
2461 GtkWidget
*all
; /* 'Replace All' action button */
2462 } SharedFindReplace
;
2464 static SharedFindReplace find_widgets
= { NULL
, };
2465 static SharedFindReplace repl_widgets
= { NULL
, };
2469 find_key_press_event(
2472 SharedFindReplace
*frdp
)
2474 /* If the user is holding one of the key modifiers we will just bail out,
2475 * thus preserving the possibility of normal focus traversal.
2477 if (event
->state
& (GDK_CONTROL_MASK
| GDK_SHIFT_MASK
))
2480 /* the Escape key synthesizes a cancellation action */
2481 if (event
->keyval
== GDK_Escape
)
2483 gtk_widget_hide(frdp
->dialog
);
2488 * What the **** is this for? Disabled for GTK+ 2 because due to
2489 * gtk_signal_connect_after() it doesn't have any effect anyway.
2493 /* block traversal resulting from those keys */
2494 if (event
->keyval
== GDK_Left
2495 || event
->keyval
== GDK_Right
2496 || event
->keyval
== GDK_space
)
2500 /* It would be delightful if it where possible to do search history
2501 * operations on the K_UP and K_DOWN keys here.
2509 create_image_button(const char *stock_id
, const char *label
)
2513 GtkWidget
*alignment
;
2516 text
= CONVERT_TO_UTF8((char_u
*)label
);
2518 box
= gtk_hbox_new(FALSE
, 3);
2519 gtk_box_pack_start(GTK_BOX(box
),
2520 gtk_image_new_from_stock(stock_id
, GTK_ICON_SIZE_BUTTON
),
2522 gtk_box_pack_start(GTK_BOX(box
),
2523 gtk_label_new((const char *)text
),
2526 CONVERT_TO_UTF8_FREE(text
);
2528 alignment
= gtk_alignment_new((float)0.5, (float)0.5,
2529 (float)0.0, (float)0.0);
2530 gtk_container_add(GTK_CONTAINER(alignment
), box
);
2531 gtk_widget_show_all(alignment
);
2533 button
= gtk_button_new();
2534 gtk_container_add(GTK_CONTAINER(button
), alignment
);
2540 * This is currently only used by find_replace_dialog_create(), and
2541 * I'd really like to keep it at that. In other words: don't spread
2542 * this nasty hack all over the code. Think twice.
2545 convert_localized_message(char_u
**buffer
, const char *message
)
2547 if (output_conv
.vc_type
== CONV_NONE
)
2551 *buffer
= string_convert(&output_conv
, (char_u
*)message
, NULL
);
2553 return (const char *)*buffer
;
2555 #endif /* HAVE_GTK2 */
2558 find_replace_dialog_create(char_u
*arg
, int do_replace
)
2563 GtkWidget
*hbox
; /* main top down box */
2564 GtkWidget
*actionarea
;
2569 SharedFindReplace
*frdp
;
2574 char_u
*conv_buffer
= NULL
;
2575 # define CONV(message) convert_localized_message(&conv_buffer, (message))
2577 # define CONV(message) (message)
2580 frdp
= (do_replace
) ? (&repl_widgets
) : (&find_widgets
);
2582 /* Get the search string to use. */
2583 entry_text
= get_find_dialog_text(arg
, &wword
, &mcase
);
2586 if (entry_text
!= NULL
&& output_conv
.vc_type
!= CONV_NONE
)
2588 char_u
*old_text
= entry_text
;
2589 entry_text
= string_convert(&output_conv
, entry_text
, NULL
);
2595 * If the dialog already exists, just raise it.
2600 /* always make the dialog appear where you want it even if the mainwin
2601 * has moved -- dbv */
2602 gui_gtk_position_in_parent(GTK_WIDGET(gui
.mainwin
),
2603 GTK_WIDGET(frdp
->dialog
), VW_POS_MOUSE
);
2604 gui_gtk_synch_fonts();
2606 if (!GTK_WIDGET_VISIBLE(frdp
->dialog
))
2608 gtk_widget_grab_focus(frdp
->what
);
2609 gtk_widget_show(frdp
->dialog
);
2612 if (entry_text
!= NULL
)
2614 gtk_entry_set_text(GTK_ENTRY(frdp
->what
), (char *)entry_text
);
2615 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp
->wword
),
2617 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp
->mcase
),
2621 gtk_window_present(GTK_WINDOW(frdp
->dialog
));
2623 gdk_window_raise(frdp
->dialog
->window
);
2625 vim_free(entry_text
);
2630 frdp
->dialog
= gtk_dialog_new();
2631 gtk_dialog_set_has_separator(GTK_DIALOG(frdp
->dialog
), FALSE
);
2632 gtk_window_set_transient_for(GTK_WINDOW(frdp
->dialog
), GTK_WINDOW(gui
.mainwin
));
2633 gtk_window_set_destroy_with_parent(GTK_WINDOW(frdp
->dialog
), TRUE
);
2635 frdp
->dialog
= gtk_window_new(GTK_WINDOW_DIALOG
);
2641 gtk_window_set_wmclass(GTK_WINDOW(frdp
->dialog
), "searchrepl", "gvim");
2643 gtk_window_set_title(GTK_WINDOW(frdp
->dialog
),
2644 CONV(_("VIM - Search and Replace...")));
2649 gtk_window_set_wmclass(GTK_WINDOW(frdp
->dialog
), "search", "gvim");
2651 gtk_window_set_title(GTK_WINDOW(frdp
->dialog
),
2652 CONV(_("VIM - Search...")));
2655 #ifndef HAVE_GTK2 /* Utter crack. Shudder. */
2656 gtk_widget_realize(frdp
->dialog
);
2657 gdk_window_set_decorations(frdp
->dialog
->window
,
2658 GDK_DECOR_TITLE
| GDK_DECOR_BORDER
| GDK_DECOR_RESIZEH
);
2659 gdk_window_set_functions(frdp
->dialog
->window
,
2660 GDK_FUNC_RESIZE
| GDK_FUNC_MOVE
);
2664 /* this makes it look better on Motif style window managers */
2665 frame
= gtk_frame_new(NULL
);
2666 gtk_container_add(GTK_CONTAINER(frdp
->dialog
), frame
);
2669 hbox
= gtk_hbox_new(FALSE
, 0);
2671 gtk_container_set_border_width(GTK_CONTAINER(hbox
), 10);
2672 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(frdp
->dialog
)->vbox
), hbox
);
2674 gtk_container_add(GTK_CONTAINER(frame
), hbox
);
2678 table
= gtk_table_new(1024, 4, FALSE
);
2680 table
= gtk_table_new(1024, 3, FALSE
);
2681 gtk_box_pack_start(GTK_BOX(hbox
), table
, TRUE
, TRUE
, 0);
2682 gtk_container_border_width(GTK_CONTAINER(table
), 4);
2684 tmp
= gtk_label_new(CONV(_("Find what:")));
2685 gtk_misc_set_alignment(GTK_MISC(tmp
), (gfloat
)0.0, (gfloat
)0.5);
2686 gtk_table_attach(GTK_TABLE(table
), tmp
, 0, 1, 0, 1,
2687 GTK_FILL
, GTK_EXPAND
, 2, 2);
2688 frdp
->what
= gtk_entry_new();
2689 sensitive
= (entry_text
!= NULL
&& entry_text
[0] != NUL
);
2690 if (entry_text
!= NULL
)
2691 gtk_entry_set_text(GTK_ENTRY(frdp
->what
), (char *)entry_text
);
2692 gtk_signal_connect(GTK_OBJECT(frdp
->what
), "changed",
2693 GTK_SIGNAL_FUNC(entry_changed_cb
), frdp
->dialog
);
2694 gtk_signal_connect_after(GTK_OBJECT(frdp
->what
), "key_press_event",
2695 GTK_SIGNAL_FUNC(find_key_press_event
),
2697 gtk_table_attach(GTK_TABLE(table
), frdp
->what
, 1, 1024, 0, 1,
2698 GTK_EXPAND
| GTK_FILL
, GTK_EXPAND
, 2, 2);
2702 tmp
= gtk_label_new(CONV(_("Replace with:")));
2703 gtk_misc_set_alignment(GTK_MISC(tmp
), (gfloat
)0.0, (gfloat
)0.5);
2704 gtk_table_attach(GTK_TABLE(table
), tmp
, 0, 1, 1, 2,
2705 GTK_FILL
, GTK_EXPAND
, 2, 2);
2706 frdp
->with
= gtk_entry_new();
2707 gtk_signal_connect(GTK_OBJECT(frdp
->with
), "activate",
2708 GTK_SIGNAL_FUNC(find_replace_cb
),
2709 GINT_TO_POINTER(FRD_R_FINDNEXT
));
2710 gtk_signal_connect_after(GTK_OBJECT(frdp
->with
), "key_press_event",
2711 GTK_SIGNAL_FUNC(find_key_press_event
),
2713 gtk_table_attach(GTK_TABLE(table
), frdp
->with
, 1, 1024, 1, 2,
2714 GTK_EXPAND
| GTK_FILL
, GTK_EXPAND
, 2, 2);
2717 * Make the entry activation only change the input focus onto the
2720 gtk_signal_connect(GTK_OBJECT(frdp
->what
), "activate",
2721 GTK_SIGNAL_FUNC(entry_activate_cb
), frdp
->with
);
2726 * Make the entry activation do the search.
2728 gtk_signal_connect(GTK_OBJECT(frdp
->what
), "activate",
2729 GTK_SIGNAL_FUNC(find_replace_cb
),
2730 GINT_TO_POINTER(FRD_FINDNEXT
));
2733 /* whole word only button */
2734 frdp
->wword
= gtk_check_button_new_with_label(CONV(_("Match whole word only")));
2735 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp
->wword
),
2738 gtk_table_attach(GTK_TABLE(table
), frdp
->wword
, 0, 1023, 2, 3,
2739 GTK_FILL
, GTK_EXPAND
, 2, 2);
2741 gtk_table_attach(GTK_TABLE(table
), frdp
->wword
, 0, 1023, 1, 2,
2742 GTK_FILL
, GTK_EXPAND
, 2, 2);
2744 /* match case button */
2745 frdp
->mcase
= gtk_check_button_new_with_label(CONV(_("Match case")));
2746 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp
->mcase
),
2749 gtk_table_attach(GTK_TABLE(table
), frdp
->mcase
, 0, 1023, 3, 4,
2750 GTK_FILL
, GTK_EXPAND
, 2, 2);
2752 gtk_table_attach(GTK_TABLE(table
), frdp
->mcase
, 0, 1023, 2, 3,
2753 GTK_FILL
, GTK_EXPAND
, 2, 2);
2755 tmp
= gtk_frame_new(CONV(_("Direction")));
2757 gtk_table_attach(GTK_TABLE(table
), tmp
, 1023, 1024, 2, 4,
2758 GTK_FILL
, GTK_FILL
, 2, 2);
2760 gtk_table_attach(GTK_TABLE(table
), tmp
, 1023, 1024, 1, 3,
2761 GTK_FILL
, GTK_FILL
, 2, 2);
2762 vbox
= gtk_vbox_new(FALSE
, 0);
2763 gtk_container_border_width(GTK_CONTAINER(vbox
), 0);
2764 gtk_container_add(GTK_CONTAINER(tmp
), vbox
);
2766 /* 'Up' and 'Down' buttons */
2767 frdp
->up
= gtk_radio_button_new_with_label(NULL
, CONV(_("Up")));
2768 gtk_box_pack_start(GTK_BOX(vbox
), frdp
->up
, TRUE
, TRUE
, 0);
2769 frdp
->down
= gtk_radio_button_new_with_label(
2770 gtk_radio_button_group(GTK_RADIO_BUTTON(frdp
->up
)),
2772 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp
->down
), TRUE
);
2774 gtk_container_set_border_width(GTK_CONTAINER(vbox
), 2);
2776 gtk_box_pack_start(GTK_BOX(vbox
), frdp
->down
, TRUE
, TRUE
, 0);
2778 /* vbox to hold the action buttons */
2779 actionarea
= gtk_vbutton_box_new();
2780 gtk_container_border_width(GTK_CONTAINER(actionarea
), 2);
2784 gtk_button_box_set_layout(GTK_BUTTON_BOX(actionarea
),
2786 gtk_button_box_set_spacing(GTK_BUTTON_BOX(actionarea
), 0);
2789 gtk_box_pack_end(GTK_BOX(hbox
), actionarea
, FALSE
, FALSE
, 0);
2791 /* 'Find Next' button */
2793 frdp
->find
= create_image_button(GTK_STOCK_FIND
, _("Find Next"));
2795 frdp
->find
= gtk_button_new_with_label(_("Find Next"));
2797 gtk_widget_set_sensitive(frdp
->find
, sensitive
);
2799 gtk_signal_connect(GTK_OBJECT(frdp
->find
), "clicked",
2800 GTK_SIGNAL_FUNC(find_replace_cb
),
2801 (do_replace
) ? GINT_TO_POINTER(FRD_R_FINDNEXT
)
2802 : GINT_TO_POINTER(FRD_FINDNEXT
));
2804 GTK_WIDGET_SET_FLAGS(frdp
->find
, GTK_CAN_DEFAULT
);
2805 gtk_box_pack_start(GTK_BOX(actionarea
), frdp
->find
, FALSE
, FALSE
, 0);
2806 gtk_widget_grab_default(frdp
->find
);
2810 /* 'Replace' button */
2812 frdp
->replace
= create_image_button(GTK_STOCK_CONVERT
, _("Replace"));
2814 frdp
->replace
= gtk_button_new_with_label(_("Replace"));
2816 gtk_widget_set_sensitive(frdp
->replace
, sensitive
);
2817 GTK_WIDGET_SET_FLAGS(frdp
->replace
, GTK_CAN_DEFAULT
);
2818 gtk_box_pack_start(GTK_BOX(actionarea
), frdp
->replace
, FALSE
, FALSE
, 0);
2819 gtk_signal_connect(GTK_OBJECT(frdp
->replace
), "clicked",
2820 GTK_SIGNAL_FUNC(find_replace_cb
),
2821 GINT_TO_POINTER(FRD_REPLACE
));
2823 /* 'Replace All' button */
2825 frdp
->all
= create_image_button(GTK_STOCK_CONVERT
, _("Replace All"));
2827 frdp
->all
= gtk_button_new_with_label(_("Replace All"));
2829 gtk_widget_set_sensitive(frdp
->all
, sensitive
);
2830 GTK_WIDGET_SET_FLAGS(frdp
->all
, GTK_CAN_DEFAULT
);
2831 gtk_box_pack_start(GTK_BOX(actionarea
), frdp
->all
, FALSE
, FALSE
, 0);
2832 gtk_signal_connect(GTK_OBJECT(frdp
->all
), "clicked",
2833 GTK_SIGNAL_FUNC(find_replace_cb
),
2834 GINT_TO_POINTER(FRD_REPLACEALL
));
2837 /* 'Cancel' button */
2839 tmp
= gtk_button_new_from_stock(GTK_STOCK_CLOSE
);
2841 tmp
= gtk_button_new_with_label(_("Cancel"));
2843 GTK_WIDGET_SET_FLAGS(tmp
, GTK_CAN_DEFAULT
);
2844 gtk_box_pack_end(GTK_BOX(actionarea
), tmp
, FALSE
, FALSE
, 0);
2845 gtk_signal_connect_object(GTK_OBJECT(tmp
),
2846 "clicked", GTK_SIGNAL_FUNC(gtk_widget_hide
),
2847 GTK_OBJECT(frdp
->dialog
));
2848 gtk_signal_connect_object(GTK_OBJECT(frdp
->dialog
),
2849 "delete_event", GTK_SIGNAL_FUNC(gtk_widget_hide_on_delete
),
2850 GTK_OBJECT(frdp
->dialog
));
2852 tmp
= gtk_vseparator_new();
2854 gtk_box_pack_end(GTK_BOX(hbox
), tmp
, FALSE
, FALSE
, 10);
2856 gtk_box_pack_end(GTK_BOX(hbox
), tmp
, FALSE
, TRUE
, 0);
2860 gtk_widget_grab_focus(frdp
->what
);
2862 /* show the frame and realize the frdp->dialog this gives us a window size
2863 * request that we'll use to position the window within the boundary of
2864 * the mainwin --dbv */
2865 gtk_widget_show_all(frame
);
2866 gui_gtk_position_in_parent(GTK_WIDGET(gui
.mainwin
),
2867 GTK_WIDGET(frdp
->dialog
), VW_POS_MOUSE
);
2868 gui_gtk_synch_fonts();
2869 gtk_widget_show_all(frdp
->dialog
);
2873 /* Suppress automatic show of the unused action area */
2874 gtk_widget_hide(GTK_DIALOG(frdp
->dialog
)->action_area
);
2875 gtk_widget_show_all(hbox
);
2876 gtk_widget_show(frdp
->dialog
);
2879 vim_free(entry_text
);
2881 vim_free(conv_buffer
);
2887 gui_mch_find_dialog(exarg_T
*eap
)
2890 find_replace_dialog_create(eap
->arg
, FALSE
);
2894 gui_mch_replace_dialog(exarg_T
*eap
)
2897 find_replace_dialog_create(eap
->arg
, TRUE
);
2901 #if !defined(HAVE_GTK2) || defined(PROTO)
2903 * Synchronize all gui elements, which are dependant upon the
2904 * main text font used. Those are in esp. the find/replace dialogs.
2905 * If you don't understand why this should be needed, please try to
2906 * search for "pięść" in iso8859-2.
2908 * (<danielk> I converted the comment above to UTF-8 to put
2909 * a stopper to the encoding mess. Forgive me :)
2911 * Obsolete with GTK2.
2914 gui_gtk_synch_fonts(void)
2916 SharedFindReplace
*frdp
;
2919 /* OK this loop is a bit tricky... */
2920 for (do_replace
= 0; do_replace
<= 1; ++do_replace
)
2922 frdp
= (do_replace
) ? (&repl_widgets
) : (&find_widgets
);
2927 /* synch the font with whats used by the text itself */
2928 style
= gtk_style_copy(gtk_widget_get_style(frdp
->what
));
2929 gdk_font_unref(style
->font
);
2930 # ifdef FEAT_XFONTSET
2931 if (gui
.fontset
!= NOFONTSET
)
2932 style
->font
= gui
.fontset
;
2935 style
->font
= gui
.norm_font
;
2936 gdk_font_ref(style
->font
);
2937 gtk_widget_set_style(frdp
->what
, style
);
2938 gtk_style_unref(style
);
2941 style
= gtk_style_copy(gtk_widget_get_style(frdp
->with
));
2942 gdk_font_unref(style
->font
);
2943 # ifdef FEAT_XFONTSET
2944 if (gui
.fontset
!= NOFONTSET
)
2945 style
->font
= gui
.fontset
;
2948 style
->font
= gui
.norm_font
;
2949 gdk_font_ref(style
->font
);
2950 gtk_widget_set_style(frdp
->with
, style
);
2951 gtk_style_unref(style
);
2956 #endif /* !HAVE_GTK2 */
2960 * Callback for actions of the find and replace dialogs
2964 find_replace_cb(GtkWidget
*widget
, gpointer data
)
2969 gboolean direction_down
;
2970 SharedFindReplace
*sfr
;
2973 flags
= (int)(long)data
; /* avoid a lint warning here */
2975 /* Get the search/replace strings from the dialog */
2976 if (flags
== FRD_FINDNEXT
)
2979 sfr
= &find_widgets
;
2983 repl_text
= (char_u
*)gtk_entry_get_text(GTK_ENTRY(repl_widgets
.with
));
2984 sfr
= &repl_widgets
;
2987 find_text
= (char_u
*)gtk_entry_get_text(GTK_ENTRY(sfr
->what
));
2988 direction_down
= GTK_TOGGLE_BUTTON(sfr
->down
)->active
;
2990 if (GTK_TOGGLE_BUTTON(sfr
->wword
)->active
)
2991 flags
|= FRD_WHOLE_WORD
;
2992 if (GTK_TOGGLE_BUTTON(sfr
->mcase
)->active
)
2993 flags
|= FRD_MATCH_CASE
;
2996 repl_text
= CONVERT_FROM_UTF8(repl_text
);
2997 find_text
= CONVERT_FROM_UTF8(find_text
);
2999 rc
= gui_do_findrepl(flags
, find_text
, repl_text
, direction_down
);
3001 CONVERT_FROM_UTF8_FREE(repl_text
);
3002 CONVERT_FROM_UTF8_FREE(find_text
);
3005 if (rc
&& gtk_main_level() > 0)
3006 gtk_main_quit(); /* make sure cmd will be handled immediately */
3009 /* our usual callback function */
3012 entry_activate_cb(GtkWidget
*widget
, gpointer data
)
3014 gtk_widget_grab_focus(GTK_WIDGET(data
));
3018 * Syncing the find/replace dialogs on the fly is utterly useless crack,
3019 * and causes nothing but problems. Please tell me a use case for which
3020 * you'd need both a find dialog and a find/replace one at the same time,
3021 * without being able to actually use them separately since they're syncing
3022 * all the time. I don't think it's worthwhile to fix this nonsense,
3023 * particularly evil incarnation of braindeadness, whatever; I'd much rather
3024 * see it extinguished from this planet. Thanks for listening. Sorry.
3027 entry_changed_cb(GtkWidget
* entry
, GtkWidget
* dialog
)
3029 const gchar
*entry_text
;
3032 entry_text
= gtk_entry_get_text(GTK_ENTRY(entry
));
3035 return; /* shouldn't happen */
3037 nonempty
= (entry_text
[0] != '\0');
3039 if (dialog
== find_widgets
.dialog
)
3041 gtk_widget_set_sensitive(find_widgets
.find
, nonempty
);
3044 if (dialog
== repl_widgets
.dialog
)
3046 gtk_widget_set_sensitive(repl_widgets
.find
, nonempty
);
3047 gtk_widget_set_sensitive(repl_widgets
.replace
, nonempty
);
3048 gtk_widget_set_sensitive(repl_widgets
.all
, nonempty
);
3060 /* This will fail when menus are not loaded. Well, it's only for
3061 * backwards compatibility anyway. */
3062 do_cmdline_cmd((char_u
*)"emenu ToolBar.FindHelp");
3065 #if !defined(HAVE_GTK2) || defined(PROTO) /* Crack crack crack. Brrrr. */
3067 /* gui_gtk_position_in_parent
3069 * this function causes a child window to be placed within the boundary of
3070 * the parent (mainwin) window.
3072 * you can specify where the window will be positioned by the third argument
3073 * (defined in gui.h):
3074 * VW_POS_CENTER at center of parent window
3075 * VW_POS_MOUSE center of child at mouse position
3076 * VW_POS_TOP_CENTER top of child at top of parent centered
3077 * horizontally about the mouse.
3079 * NOTE: for this function to act as desired the child window must have a
3080 * window size requested. this can be accomplished by packing/placing
3081 * child widgets onto a gtk_frame widget rather than the gtk_window
3087 gui_gtk_position_in_parent(
3090 gui_win_pos_T where
)
3092 GtkRequisition c_size
;
3094 gint xP
, yP
, wP
, hP
, pos_x
, pos_y
;
3096 /* make sure the child widget is set up then get its size. */
3097 gtk_widget_size_request(child
, &c_size
);
3099 /* get origin and size of parent window */
3100 gdk_window_get_origin((GdkWindow
*)(parent
->window
), &xP
, &yP
);
3101 gdk_window_get_size((GdkWindow
*)(parent
->window
), &wP
, &hP
);
3103 if (c_size
.width
> wP
|| c_size
.height
> hP
)
3105 /* doh! maybe the user should consider giving gVim a little more
3106 * screen real estate */
3107 gtk_widget_set_uposition(child
, xP
+ 2 , yP
+ 2);
3111 if (where
== VW_POS_MOUSE
)
3113 /* position window at mouse pointer */
3114 gtk_widget_get_pointer(parent
, &xPm
, &yPm
);
3115 pos_x
= xP
+ xPm
- (c_size
.width
) / 2;
3116 pos_y
= yP
+ yPm
- (c_size
.height
) / 2;
3120 /* set child x origin so it is in center of Vim window */
3121 pos_x
= xP
+ (wP
- c_size
.width
) / 2;
3123 if (where
== VW_POS_TOP_CENTER
)
3126 /* where == VW_POS_CENTER */
3127 pos_y
= yP
+ (hP
- c_size
.height
) / 2;
3130 /* now, make sure the window will be inside the Vim window... */
3135 if ((pos_x
+ c_size
.width
) > (wP
+ xP
))
3136 pos_x
= xP
+ wP
- c_size
.width
- 2;
3137 /* Assume 'guiheadroom' indicates the title bar height... */
3138 if ((pos_y
+ c_size
.height
+ p_ghr
/ 2) > (hP
+ yP
))
3140 gtk_widget_set_uposition(child
, pos_x
, pos_y
);
3143 #endif /* !HAVE_GTK2 */