blob: ba2d23d1e9fcb8729ca613c29e99b81b6cc95ebd [file] [log] [blame]
Bram Moolenaar071d4272004-06-13 20:20:40 +00001/* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
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.
8 */
9
10/*
11 * Porting to GTK+ was done by:
12 *
Bram Moolenaarfca34d62005-01-04 21:38:36 +000013 * (C) 1998,1999,2000 by Marcin Dalecki <martin@dalecki.de>
Bram Moolenaar071d4272004-06-13 20:20:40 +000014 *
15 * With GREAT support and continuous encouragements by Andy Kahn and of
16 * course Bram Moolenaar!
17 *
18 * Support for GTK+ 2 was added by:
19 *
20 * (C) 2002,2003 Jason Hildebrand <jason@peaceworks.ca>
21 * Daniel Elstner <daniel.elstner@gmx.net>
22 *
23 * Best supporting actor (He helped somewhat, aesthetically speaking):
24 * Maxime Romano <verbophobe@hotmail.com>
25 */
26
27#ifdef FEAT_GUI_GTK
28# include "gui_gtk_f.h"
29#endif
30
31/* GTK defines MAX and MIN, but some system header files as well. Undefine
32 * them and don't use them. */
33#ifdef MIN
34# undef MIN
35#endif
36#ifdef MAX
37# undef MAX
38#endif
39
40#include "vim.h"
41
42#ifdef FEAT_GUI_GNOME
43/* Gnome redefines _() and N_(). Grrr... */
44# ifdef _
45# undef _
46# endif
47# ifdef N_
48# undef N_
49# endif
50# ifdef textdomain
51# undef textdomain
52# endif
53# ifdef bindtextdomain
54# undef bindtextdomain
55# endif
Bram Moolenaara2dd9002007-05-14 17:38:30 +000056# ifdef bind_textdomain_codeset
57# undef bind_textdomain_codeset
Bram Moolenaar79166c42007-05-10 18:29:51 +000058# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +000059# if defined(FEAT_GETTEXT) && !defined(ENABLE_NLS)
60# define ENABLE_NLS /* so the texts in the dialog boxes are translated */
61# endif
62# include <gnome.h>
63#endif
64
Bram Moolenaar071d4272004-06-13 20:20:40 +000065#ifdef FEAT_GUI_GTK
66# include <gdk/gdkkeysyms.h>
67# include <gdk/gdk.h>
68# ifdef WIN3264
69# include <gdk/gdkwin32.h>
70# else
71# include <gdk/gdkx.h>
72# endif
73
74# include <gtk/gtk.h>
75#else
76/* define these items to be able to generate prototypes without GTK */
77typedef int GtkWidget;
78# define gpointer int
79# define guint8 int
80# define GdkPixmap int
81# define GdkBitmap int
82# define GtkIconFactory int
83# define GtkToolbar int
84# define GtkAdjustment int
85# define gboolean int
86# define GdkEventKey int
87# define CancelData int
88#endif
89
Bram Moolenaar071d4272004-06-13 20:20:40 +000090static void entry_activate_cb(GtkWidget *widget, gpointer data);
91static void entry_changed_cb(GtkWidget *entry, GtkWidget *dialog);
92static void find_replace_cb(GtkWidget *widget, gpointer data);
Bram Moolenaar08bc2742012-06-06 16:14:40 +020093#if defined(FEAT_BROWSE) || defined(PROTO)
Bram Moolenaar68fb5dc2012-04-25 17:10:16 +020094static void recent_func_log_func(
95 const gchar *log_domain,
96 GLogLevelFlags log_level,
97 const gchar *message,
98 gpointer user_data);
Bram Moolenaar08bc2742012-06-06 16:14:40 +020099#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000100
Bram Moolenaar182c5be2010-06-25 05:37:59 +0200101#if defined(FEAT_TOOLBAR)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000102/*
103 * Table from BuiltIn## icon indices to GTK+ stock IDs. Order must exactly
104 * match toolbar_names[] in menu.c! All stock icons including the "vim-*"
105 * ones can be overridden in your gtkrc file.
106 */
107static const char * const menu_stock_ids[] =
108{
109 /* 00 */ GTK_STOCK_NEW,
110 /* 01 */ GTK_STOCK_OPEN,
111 /* 02 */ GTK_STOCK_SAVE,
112 /* 03 */ GTK_STOCK_UNDO,
113 /* 04 */ GTK_STOCK_REDO,
114 /* 05 */ GTK_STOCK_CUT,
115 /* 06 */ GTK_STOCK_COPY,
116 /* 07 */ GTK_STOCK_PASTE,
117 /* 08 */ GTK_STOCK_PRINT,
118 /* 09 */ GTK_STOCK_HELP,
119 /* 10 */ GTK_STOCK_FIND,
120 /* 11 */ "vim-save-all",
121 /* 12 */ "vim-session-save",
122 /* 13 */ "vim-session-new",
123 /* 14 */ "vim-session-load",
124 /* 15 */ GTK_STOCK_EXECUTE,
125 /* 16 */ GTK_STOCK_FIND_AND_REPLACE,
126 /* 17 */ GTK_STOCK_CLOSE, /* FIXME: fuzzy */
127 /* 18 */ "vim-window-maximize",
128 /* 19 */ "vim-window-minimize",
129 /* 20 */ "vim-window-split",
130 /* 21 */ "vim-shell",
131 /* 22 */ GTK_STOCK_GO_BACK,
132 /* 23 */ GTK_STOCK_GO_FORWARD,
133 /* 24 */ "vim-find-help",
134 /* 25 */ GTK_STOCK_CONVERT,
135 /* 26 */ GTK_STOCK_JUMP_TO,
136 /* 27 */ "vim-build-tags",
137 /* 28 */ "vim-window-split-vertical",
138 /* 29 */ "vim-window-maximize-width",
139 /* 30 */ "vim-window-minimize-width",
140 /* 31 */ GTK_STOCK_QUIT
141};
142
143 static void
144add_stock_icon(GtkIconFactory *factory,
145 const char *stock_id,
146 const guint8 *inline_data,
147 int data_length)
148{
149 GdkPixbuf *pixbuf;
150 GtkIconSet *icon_set;
151
152 pixbuf = gdk_pixbuf_new_from_inline(data_length, inline_data, FALSE, NULL);
153 icon_set = gtk_icon_set_new_from_pixbuf(pixbuf);
154
155 gtk_icon_factory_add(factory, stock_id, icon_set);
156
157 gtk_icon_set_unref(icon_set);
158 g_object_unref(pixbuf);
159}
160
161 static int
162lookup_menu_iconfile(char_u *iconfile, char_u *dest)
163{
164 expand_env(iconfile, dest, MAXPATHL);
165
166 if (mch_isFullName(dest))
167 {
168 return vim_fexists(dest);
169 }
170 else
171 {
172 static const char suffixes[][4] = {"png", "xpm", "bmp"};
173 char_u buf[MAXPATHL];
174 unsigned int i;
175
176 for (i = 0; i < G_N_ELEMENTS(suffixes); ++i)
177 if (gui_find_bitmap(dest, buf, (char *)suffixes[i]) == OK)
178 {
179 STRCPY(dest, buf);
180 return TRUE;
181 }
182
183 return FALSE;
184 }
185}
186
187 static GtkWidget *
188load_menu_iconfile(char_u *name, GtkIconSize icon_size)
189{
190 GtkWidget *image = NULL;
191 GtkIconSet *icon_set;
192 GtkIconSource *icon_source;
193
194 /*
195 * Rather than loading the icon directly into a GtkImage, create
196 * a new GtkIconSet and put it in there. This way we can easily
197 * scale the toolbar icons on the fly when needed.
198 */
199 icon_set = gtk_icon_set_new();
200 icon_source = gtk_icon_source_new();
201
202 gtk_icon_source_set_filename(icon_source, (const char *)name);
203 gtk_icon_set_add_source(icon_set, icon_source);
204
205 image = gtk_image_new_from_icon_set(icon_set, icon_size);
206
207 gtk_icon_source_free(icon_source);
208 gtk_icon_set_unref(icon_set);
209
210 return image;
211}
212
213 static GtkWidget *
214create_menu_icon(vimmenu_T *menu, GtkIconSize icon_size)
215{
216 GtkWidget *image = NULL;
217 char_u buf[MAXPATHL];
218
219 /* First use a specified "icon=" argument. */
220 if (menu->iconfile != NULL && lookup_menu_iconfile(menu->iconfile, buf))
221 image = load_menu_iconfile(buf, icon_size);
222
223 /* If not found and not builtin specified try using the menu name. */
224 if (image == NULL && !menu->icon_builtin
225 && lookup_menu_iconfile(menu->name, buf))
226 image = load_menu_iconfile(buf, icon_size);
227
228 /* Still not found? Then use a builtin icon, a blank one as fallback. */
229 if (image == NULL)
230 {
231 const char *stock_id;
232 const int n_ids = G_N_ELEMENTS(menu_stock_ids);
233
234 if (menu->iconidx >= 0 && menu->iconidx < n_ids)
235 stock_id = menu_stock_ids[menu->iconidx];
236 else
237 stock_id = GTK_STOCK_MISSING_IMAGE;
238
239 image = gtk_image_new_from_stock(stock_id, icon_size);
240 }
241
242 return image;
243}
244
Bram Moolenaar9b2200a2006-03-20 21:55:45 +0000245 static gint
Bram Moolenaarb85cb212009-05-17 14:24:23 +0000246toolbar_button_focus_in_event(GtkWidget *widget UNUSED,
247 GdkEventFocus *event UNUSED,
248 gpointer data UNUSED)
Bram Moolenaar9b2200a2006-03-20 21:55:45 +0000249{
Bram Moolenaarb85cb212009-05-17 14:24:23 +0000250 /* When we're in a GtkPlug, we don't have window focus events, only widget
251 * focus. To emulate stand-alone gvim, if a button gets focus (e.g.,
252 * <Tab> into GtkPlug) immediately pass it to mainwin. */
Bram Moolenaar9b2200a2006-03-20 21:55:45 +0000253 if (gtk_socket_id != 0)
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000254 gtk_widget_grab_focus(gui.drawarea);
Bram Moolenaar9b2200a2006-03-20 21:55:45 +0000255
256 return TRUE;
257}
Bram Moolenaar182c5be2010-06-25 05:37:59 +0200258#endif /* FEAT_TOOLBAR */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000259
Bram Moolenaar182c5be2010-06-25 05:37:59 +0200260#if defined(FEAT_TOOLBAR) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000261
262 void
263gui_gtk_register_stock_icons(void)
264{
265# include "../pixmaps/stock_icons.h"
266 GtkIconFactory *factory;
267
268 factory = gtk_icon_factory_new();
269# define ADD_ICON(Name, Data) add_stock_icon(factory, Name, Data, (int)sizeof(Data))
270
271 ADD_ICON("vim-build-tags", stock_vim_build_tags);
272 ADD_ICON("vim-find-help", stock_vim_find_help);
273 ADD_ICON("vim-save-all", stock_vim_save_all);
274 ADD_ICON("vim-session-load", stock_vim_session_load);
275 ADD_ICON("vim-session-new", stock_vim_session_new);
276 ADD_ICON("vim-session-save", stock_vim_session_save);
277 ADD_ICON("vim-shell", stock_vim_shell);
278 ADD_ICON("vim-window-maximize", stock_vim_window_maximize);
279 ADD_ICON("vim-window-maximize-width", stock_vim_window_maximize_width);
280 ADD_ICON("vim-window-minimize", stock_vim_window_minimize);
281 ADD_ICON("vim-window-minimize-width", stock_vim_window_minimize_width);
282 ADD_ICON("vim-window-split", stock_vim_window_split);
283 ADD_ICON("vim-window-split-vertical", stock_vim_window_split_vertical);
284
285# undef ADD_ICON
286 gtk_icon_factory_add_default(factory);
287 g_object_unref(factory);
288}
289
Bram Moolenaar182c5be2010-06-25 05:37:59 +0200290#endif /* FEAT_TOOLBAR */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000291
292
Bram Moolenaar071d4272004-06-13 20:20:40 +0000293#if defined(FEAT_MENU) || defined(PROTO)
294
295/*
296 * Translate Vim's mnemonic tagging to GTK+ style and convert to UTF-8
297 * if necessary. The caller must vim_free() the returned string.
298 *
299 * Input Output
300 * _ __
301 * && &
302 * & _ stripped if use_mnemonic == FALSE
303 * <Tab> end of menu label text
304 */
305 static char_u *
306translate_mnemonic_tag(char_u *name, int use_mnemonic)
307{
308 char_u *buf;
309 char_u *psrc;
310 char_u *pdest;
311 int n_underscores = 0;
312
Bram Moolenaar071d4272004-06-13 20:20:40 +0000313 name = CONVERT_TO_UTF8(name);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000314 if (name == NULL)
315 return NULL;
316
317 for (psrc = name; *psrc != NUL && *psrc != TAB; ++psrc)
318 if (*psrc == '_')
319 ++n_underscores;
320
321 buf = alloc((unsigned)(psrc - name + n_underscores + 1));
322 if (buf != NULL)
323 {
324 pdest = buf;
325 for (psrc = name; *psrc != NUL && *psrc != TAB; ++psrc)
326 {
327 if (*psrc == '_')
328 {
329 *pdest++ = '_';
330 *pdest++ = '_';
331 }
332 else if (*psrc != '&')
333 {
334 *pdest++ = *psrc;
335 }
336 else if (*(psrc + 1) == '&')
337 {
338 *pdest++ = *psrc++;
339 }
340 else if (use_mnemonic)
341 {
342 *pdest++ = '_';
343 }
344 }
345 *pdest = NUL;
346 }
347
Bram Moolenaar071d4272004-06-13 20:20:40 +0000348 CONVERT_TO_UTF8_FREE(name);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000349 return buf;
350}
351
Bram Moolenaar071d4272004-06-13 20:20:40 +0000352 static void
353menu_item_new(vimmenu_T *menu, GtkWidget *parent_widget)
354{
355 GtkWidget *box;
356 char_u *text;
357 int use_mnemonic;
358
359 /* It would be neat to have image menu items, but that would require major
360 * changes to Vim's menu system. Not to mention that all the translations
361 * had to be updated. */
362 menu->id = gtk_menu_item_new();
363 box = gtk_hbox_new(FALSE, 20);
364
365 use_mnemonic = (p_wak[0] != 'n' || !GTK_IS_MENU_BAR(parent_widget));
366 text = translate_mnemonic_tag(menu->name, use_mnemonic);
367
368 menu->label = gtk_label_new_with_mnemonic((const char *)text);
369 vim_free(text);
370
371 gtk_box_pack_start(GTK_BOX(box), menu->label, FALSE, FALSE, 0);
372
373 if (menu->actext != NULL && menu->actext[0] != NUL)
374 {
375 text = CONVERT_TO_UTF8(menu->actext);
376
377 gtk_box_pack_end(GTK_BOX(box),
378 gtk_label_new((const char *)text),
379 FALSE, FALSE, 0);
380
381 CONVERT_TO_UTF8_FREE(text);
382 }
383
384 gtk_container_add(GTK_CONTAINER(menu->id), box);
385 gtk_widget_show_all(menu->id);
386}
387
Bram Moolenaar071d4272004-06-13 20:20:40 +0000388 void
389gui_mch_add_menu(vimmenu_T *menu, int idx)
390{
391 vimmenu_T *parent;
392 GtkWidget *parent_widget;
393
394 if (menu->name[0] == ']' || menu_is_popup(menu->name))
395 {
396 menu->submenu_id = gtk_menu_new();
397 return;
398 }
399
400 parent = menu->parent;
401
402 if ((parent != NULL && parent->submenu_id == NULL)
403 || !menu_is_menubar(menu->name))
404 return;
405
406 parent_widget = (parent != NULL) ? parent->submenu_id : gui.menubar;
407 menu_item_new(menu, parent_widget);
408
409 /* since the tearoff should always appear first, increment idx */
410 if (parent != NULL && !menu_is_popup(parent->name))
411 ++idx;
412
413 gtk_menu_shell_insert(GTK_MENU_SHELL(parent_widget), menu->id, idx);
414
Bram Moolenaar071d4272004-06-13 20:20:40 +0000415 menu->submenu_id = gtk_menu_new();
416
417 gtk_menu_set_accel_group(GTK_MENU(menu->submenu_id), gui.accel_group);
418 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu->id), menu->submenu_id);
419
420 menu->tearoff_handle = gtk_tearoff_menu_item_new();
421 if (vim_strchr(p_go, GO_TEAROFF) != NULL)
422 gtk_widget_show(menu->tearoff_handle);
423 gtk_menu_prepend(GTK_MENU(menu->submenu_id), menu->tearoff_handle);
424}
425
Bram Moolenaar071d4272004-06-13 20:20:40 +0000426 static void
Bram Moolenaarb85cb212009-05-17 14:24:23 +0000427menu_item_activate(GtkWidget *widget UNUSED, gpointer data)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000428{
429 gui_menu_cb((vimmenu_T *)data);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000430}
431
Bram Moolenaar071d4272004-06-13 20:20:40 +0000432 void
433gui_mch_add_menu_item(vimmenu_T *menu, int idx)
434{
435 vimmenu_T *parent;
436
437 parent = menu->parent;
438
439# ifdef FEAT_TOOLBAR
440 if (menu_is_toolbar(parent->name))
441 {
442 GtkToolbar *toolbar;
443
444 toolbar = GTK_TOOLBAR(gui.toolbar);
445 menu->submenu_id = NULL;
446
447 if (menu_is_separator(menu->name))
448 {
449 gtk_toolbar_insert_space(toolbar, idx);
450 menu->id = NULL;
451 }
452 else
453 {
Bram Moolenaar071d4272004-06-13 20:20:40 +0000454 char_u *text;
455 char_u *tooltip;
456
457 text = CONVERT_TO_UTF8(menu->dname);
458 tooltip = CONVERT_TO_UTF8(menu->strings[MENU_INDEX_TIP]);
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +0000459 if (tooltip != NULL && !utf_valid_string(tooltip, NULL))
460 /* Invalid text, can happen when 'encoding' is changed. Avoid
461 * a nasty GTK error message, skip the tooltip. */
462 CONVERT_TO_UTF8_FREE(tooltip);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000463
464 menu->id = gtk_toolbar_insert_item(
465 toolbar,
466 (const char *)text,
467 (const char *)tooltip,
468 NULL,
469 create_menu_icon(menu, gtk_toolbar_get_icon_size(toolbar)),
470 G_CALLBACK(&menu_item_activate),
471 menu,
472 idx);
473
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000474 if (gtk_socket_id != 0)
475 gtk_signal_connect(GTK_OBJECT(menu->id), "focus_in_event",
476 GTK_SIGNAL_FUNC(toolbar_button_focus_in_event), NULL);
Bram Moolenaar9b2200a2006-03-20 21:55:45 +0000477
Bram Moolenaar071d4272004-06-13 20:20:40 +0000478 CONVERT_TO_UTF8_FREE(text);
479 CONVERT_TO_UTF8_FREE(tooltip);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000480 }
481 }
482 else
483# endif /* FEAT_TOOLBAR */
484 {
485 /* No parent, must be a non-menubar menu */
Bram Moolenaareb3593b2006-04-22 22:33:57 +0000486 if (parent == NULL || parent->submenu_id == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000487 return;
488
489 /* Make place for the possible tearoff handle item. Not in the popup
490 * menu, it doesn't have a tearoff item. */
Bram Moolenaareb3593b2006-04-22 22:33:57 +0000491 if (!menu_is_popup(parent->name))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000492 ++idx;
493
494 if (menu_is_separator(menu->name))
495 {
496 /* Separator: Just add it */
497 menu->id = gtk_menu_item_new();
498 gtk_widget_set_sensitive(menu->id, FALSE);
499 gtk_widget_show(menu->id);
500 gtk_menu_insert(GTK_MENU(parent->submenu_id), menu->id, idx);
501
502 return;
503 }
504
505 /* Add textual menu item. */
506 menu_item_new(menu, parent->submenu_id);
507 gtk_widget_show(menu->id);
508 gtk_menu_insert(GTK_MENU(parent->submenu_id), menu->id, idx);
509
510 if (menu->id != NULL)
511 gtk_signal_connect(GTK_OBJECT(menu->id), "activate",
512 GTK_SIGNAL_FUNC(menu_item_activate), menu);
513 }
514}
515#endif /* FEAT_MENU */
516
517
518 void
519gui_mch_set_text_area_pos(int x, int y, int w, int h)
520{
521 gtk_form_move_resize(GTK_FORM(gui.formwin), gui.drawarea, x, y, w, h);
522}
523
524
525#if defined(FEAT_MENU) || defined(PROTO)
526/*
Bram Moolenaar79166c42007-05-10 18:29:51 +0000527 * Enable or disable accelerators for the toplevel menus.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000528 */
529 void
530gui_gtk_set_mnemonics(int enable)
531{
532 vimmenu_T *menu;
533 char_u *name;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000534
535 for (menu = root_menu; menu != NULL; menu = menu->next)
536 {
537 if (menu->id == NULL)
538 continue;
539
Bram Moolenaar071d4272004-06-13 20:20:40 +0000540 name = translate_mnemonic_tag(menu->name, enable);
541 gtk_label_set_text_with_mnemonic(GTK_LABEL(menu->label),
542 (const char *)name);
543 vim_free(name);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000544 }
545}
546
547 static void
548recurse_tearoffs(vimmenu_T *menu, int val)
549{
550 for (; menu != NULL; menu = menu->next)
551 {
552 if (menu->submenu_id != NULL && menu->tearoff_handle != NULL
553 && menu->name[0] != ']' && !menu_is_popup(menu->name))
554 {
555 if (val)
556 gtk_widget_show(menu->tearoff_handle);
557 else
558 gtk_widget_hide(menu->tearoff_handle);
559 }
560 recurse_tearoffs(menu->children, val);
561 }
562}
563
564 void
565gui_mch_toggle_tearoffs(int enable)
566{
567 recurse_tearoffs(root_menu, enable);
568}
569#endif /* FEAT_MENU */
570
Bram Moolenaar182c5be2010-06-25 05:37:59 +0200571#if defined(FEAT_TOOLBAR)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000572 static int
573get_menu_position(vimmenu_T *menu)
574{
575 vimmenu_T *node;
Bram Moolenaar89d40322006-08-29 15:30:07 +0000576 int idx = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000577
578 for (node = menu->parent->children; node != menu; node = node->next)
579 {
580 g_return_val_if_fail(node != NULL, -1);
Bram Moolenaar89d40322006-08-29 15:30:07 +0000581 ++idx;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000582 }
583
Bram Moolenaar89d40322006-08-29 15:30:07 +0000584 return idx;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000585}
Bram Moolenaar182c5be2010-06-25 05:37:59 +0200586#endif /* FEAT_TOOLBAR */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000587
588
589#if defined(FEAT_TOOLBAR) || defined(PROTO)
590 void
591gui_mch_menu_set_tip(vimmenu_T *menu)
592{
593 if (menu->id != NULL && menu->parent != NULL
594 && gui.toolbar != NULL && menu_is_toolbar(menu->parent->name))
595 {
596 char_u *tooltip;
597
Bram Moolenaar071d4272004-06-13 20:20:40 +0000598 tooltip = CONVERT_TO_UTF8(menu->strings[MENU_INDEX_TIP]);
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +0000599 if (tooltip == NULL || utf_valid_string(tooltip, NULL))
600 /* Only set the tooltip when it's valid utf-8. */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000601 gtk_tooltips_set_tip(GTK_TOOLBAR(gui.toolbar)->tooltips,
602 menu->id, (const char *)tooltip, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000603 CONVERT_TO_UTF8_FREE(tooltip);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000604 }
605}
606#endif /* FEAT_TOOLBAR */
607
608
609#if defined(FEAT_MENU) || defined(PROTO)
610/*
611 * Destroy the machine specific menu widget.
612 */
613 void
614gui_mch_destroy_menu(vimmenu_T *menu)
615{
616# ifdef FEAT_TOOLBAR
617 if (menu->parent != NULL && menu_is_toolbar(menu->parent->name))
618 {
Bram Moolenaar071d4272004-06-13 20:20:40 +0000619 if (menu_is_separator(menu->name))
620 gtk_toolbar_remove_space(GTK_TOOLBAR(gui.toolbar),
621 get_menu_position(menu));
622 else if (menu->id != NULL)
623 gtk_widget_destroy(menu->id);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000624 }
625 else
626# endif /* FEAT_TOOLBAR */
627 {
628 if (menu->submenu_id != NULL)
629 gtk_widget_destroy(menu->submenu_id);
630
631 if (menu->id != NULL)
632 gtk_widget_destroy(menu->id);
633 }
634
635 menu->submenu_id = NULL;
636 menu->id = NULL;
637}
638#endif /* FEAT_MENU */
639
640
641/*
642 * Scrollbar stuff.
643 */
644 void
645gui_mch_set_scrollbar_thumb(scrollbar_T *sb, long val, long size, long max)
646{
647 if (sb->id != NULL)
648 {
649 GtkAdjustment *adjustment;
650
651 adjustment = gtk_range_get_adjustment(GTK_RANGE(sb->id));
652
653 adjustment->lower = 0.0;
654 adjustment->value = val;
655 adjustment->upper = max + 1;
656 adjustment->page_size = size;
657 adjustment->page_increment = size < 3L ? 1L : size - 2L;
658 adjustment->step_increment = 1.0;
659
Bram Moolenaar071d4272004-06-13 20:20:40 +0000660 g_signal_handler_block(GTK_OBJECT(adjustment),
661 (gulong)sb->handler_id);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000662 gtk_adjustment_changed(adjustment);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000663 g_signal_handler_unblock(GTK_OBJECT(adjustment),
664 (gulong)sb->handler_id);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000665 }
666}
667
668 void
669gui_mch_set_scrollbar_pos(scrollbar_T *sb, int x, int y, int w, int h)
670{
671 if (sb->id != NULL)
672 gtk_form_move_resize(GTK_FORM(gui.formwin), sb->id, x, y, w, h);
673}
674
675/*
676 * Take action upon scrollbar dragging.
677 */
678 static void
679adjustment_value_changed(GtkAdjustment *adjustment, gpointer data)
680{
681 scrollbar_T *sb;
682 long value;
683 int dragging = FALSE;
684
685#ifdef FEAT_XIM
686 /* cancel any preediting */
687 if (im_is_preediting())
688 xim_reset();
689#endif
690
691 sb = gui_find_scrollbar((long)data);
692 value = (long)adjustment->value;
693 /*
694 * The dragging argument must be right for the scrollbar to work with
695 * closed folds. This isn't documented, hopefully this will keep on
696 * working in later GTK versions.
697 *
698 * FIXME: Well, it doesn't work in GTK2. :)
699 * HACK: Get the mouse pointer position, if it appears to be on an arrow
700 * button set "dragging" to FALSE. This assumes square buttons!
701 */
702 if (sb != NULL)
703 {
Bram Moolenaar071d4272004-06-13 20:20:40 +0000704 dragging = TRUE;
705
706 if (sb->wp != NULL)
707 {
708 int x;
709 int y;
710 GdkModifierType state;
711 int width;
712 int height;
713
714 /* vertical scrollbar: need to set "dragging" properly in case
715 * there are closed folds. */
716 gdk_window_get_pointer(sb->id->window, &x, &y, &state);
717 gdk_window_get_size(sb->id->window, &width, &height);
718 if (x >= 0 && x < width && y >= 0 && y < height)
719 {
720 if (y < width)
721 {
722 /* up arrow: move one (closed fold) line up */
723 dragging = FALSE;
724 value = sb->wp->w_topline - 2;
725 }
726 else if (y > height - width)
727 {
728 /* down arrow: move one (closed fold) line down */
729 dragging = FALSE;
730 value = sb->wp->w_topline;
731 }
732 }
733 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000734 }
735
736 gui_drag_scrollbar(sb, value, dragging);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000737}
738
739/* SBAR_VERT or SBAR_HORIZ */
740 void
741gui_mch_create_scrollbar(scrollbar_T *sb, int orient)
742{
743 if (orient == SBAR_HORIZ)
744 sb->id = gtk_hscrollbar_new(NULL);
745 else if (orient == SBAR_VERT)
746 sb->id = gtk_vscrollbar_new(NULL);
747
748 if (sb->id != NULL)
749 {
750 GtkAdjustment *adjustment;
751
752 GTK_WIDGET_UNSET_FLAGS(sb->id, GTK_CAN_FOCUS);
753 gtk_form_put(GTK_FORM(gui.formwin), sb->id, 0, 0);
754
755 adjustment = gtk_range_get_adjustment(GTK_RANGE(sb->id));
756
757 sb->handler_id = gtk_signal_connect(
758 GTK_OBJECT(adjustment), "value_changed",
759 GTK_SIGNAL_FUNC(adjustment_value_changed),
760 GINT_TO_POINTER(sb->ident));
761 gui_mch_update();
762 }
763}
764
765#if defined(FEAT_WINDOWS) || defined(PROTO)
766 void
767gui_mch_destroy_scrollbar(scrollbar_T *sb)
768{
769 if (sb->id != NULL)
770 {
771 gtk_widget_destroy(sb->id);
772 sb->id = NULL;
773 }
774 gui_mch_update();
775}
776#endif
777
778#if defined(FEAT_BROWSE) || defined(PROTO)
779/*
780 * Implementation of the file selector related stuff
781 */
782
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000783#ifndef USE_FILE_CHOOSER
Bram Moolenaar071d4272004-06-13 20:20:40 +0000784 static void
Bram Moolenaarb85cb212009-05-17 14:24:23 +0000785browse_ok_cb(GtkWidget *widget UNUSED, gpointer cbdata)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000786{
787 gui_T *vw = (gui_T *)cbdata;
788
789 if (vw->browse_fname != NULL)
790 g_free(vw->browse_fname);
791
792 vw->browse_fname = (char_u *)g_strdup(gtk_file_selection_get_filename(
793 GTK_FILE_SELECTION(vw->filedlg)));
794 gtk_widget_hide(vw->filedlg);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000795}
796
Bram Moolenaar071d4272004-06-13 20:20:40 +0000797 static void
Bram Moolenaarb85cb212009-05-17 14:24:23 +0000798browse_cancel_cb(GtkWidget *widget UNUSED, gpointer cbdata)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000799{
800 gui_T *vw = (gui_T *)cbdata;
801
802 if (vw->browse_fname != NULL)
803 {
804 g_free(vw->browse_fname);
805 vw->browse_fname = NULL;
806 }
807 gtk_widget_hide(vw->filedlg);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000808}
809
Bram Moolenaar071d4272004-06-13 20:20:40 +0000810 static gboolean
Bram Moolenaarb85cb212009-05-17 14:24:23 +0000811browse_destroy_cb(GtkWidget *widget UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000812{
813 if (gui.browse_fname != NULL)
814 {
815 g_free(gui.browse_fname);
816 gui.browse_fname = NULL;
817 }
818 gui.filedlg = NULL;
Bram Moolenaara3f41662010-07-11 19:01:06 +0200819 gtk_main_quit();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000820 return FALSE;
821}
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000822#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000823
824/*
825 * Put up a file requester.
826 * Returns the selected name in allocated memory, or NULL for Cancel.
827 * saving, select file to write
828 * title title for the window
829 * dflt default name
830 * ext not used (extension added)
831 * initdir initial directory, NULL for current dir
832 * filter not used (file name filter)
833 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000834 char_u *
Bram Moolenaarb85cb212009-05-17 14:24:23 +0000835gui_mch_browse(int saving UNUSED,
Bram Moolenaar071d4272004-06-13 20:20:40 +0000836 char_u *title,
837 char_u *dflt,
Bram Moolenaarb85cb212009-05-17 14:24:23 +0000838 char_u *ext UNUSED,
Bram Moolenaar071d4272004-06-13 20:20:40 +0000839 char_u *initdir,
Bram Moolenaar6c4b6462012-07-10 13:12:51 +0200840 char_u *filter)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000841{
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000842#ifdef USE_FILE_CHOOSER
843 GtkWidget *fc;
844#endif
Bram Moolenaar7b0294c2004-10-11 10:16:09 +0000845 char_u dirbuf[MAXPATHL];
Bram Moolenaar68fb5dc2012-04-25 17:10:16 +0200846 guint log_handler;
847 const gchar *domain = "Gtk";
Bram Moolenaar071d4272004-06-13 20:20:40 +0000848
Bram Moolenaar071d4272004-06-13 20:20:40 +0000849 title = CONVERT_TO_UTF8(title);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000850
Bram Moolenaar57ac3a22006-10-10 16:28:30 +0000851 /* GTK has a bug, it only works with an absolute path. */
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000852 if (initdir == NULL || *initdir == NUL)
853 mch_dirname(dirbuf, MAXPATHL);
Bram Moolenaar57ac3a22006-10-10 16:28:30 +0000854 else if (vim_FullName(initdir, dirbuf, MAXPATHL - 2, FALSE) == FAIL)
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000855 dirbuf[0] = NUL;
856 /* Always need a trailing slash for a directory. */
857 add_pathsep(dirbuf);
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000858
859 /* If our pointer is currently hidden, then we should show it. */
860 gui_mch_mousehide(FALSE);
861
Bram Moolenaar68fb5dc2012-04-25 17:10:16 +0200862 /* Hack: The GTK file dialog warns when it can't access a new file, this
863 * makes it shut up. http://bugzilla.gnome.org/show_bug.cgi?id=664587 */
864 log_handler = g_log_set_handler(domain, G_LOG_LEVEL_WARNING,
865 recent_func_log_func, NULL);
866
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000867#ifdef USE_FILE_CHOOSER
868 /* We create the dialog each time, so that the button text can be "Open"
869 * or "Save" according to the action. */
870 fc = gtk_file_chooser_dialog_new((const gchar *)title,
871 GTK_WINDOW(gui.mainwin),
872 saving ? GTK_FILE_CHOOSER_ACTION_SAVE
873 : GTK_FILE_CHOOSER_ACTION_OPEN,
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000874 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
Bram Moolenaard1350622006-10-24 20:01:06 +0000875 saving ? GTK_STOCK_SAVE : GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000876 NULL);
877 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc),
878 (const gchar *)dirbuf);
Bram Moolenaar6c4b6462012-07-10 13:12:51 +0200879
880 if (filter != NULL && *filter != NUL)
881 {
882 int i = 0;
883 char_u *patt;
884 char_u *p = filter;
Bram Moolenaar205f9f52012-10-18 05:18:32 +0200885 GtkFileFilter *gfilter;
Bram Moolenaar6c4b6462012-07-10 13:12:51 +0200886
887 gfilter = gtk_file_filter_new();
888 patt = alloc(STRLEN(filter));
889 while (p != NULL && *p != NUL)
890 {
891 if (*p == '\n' || *p == ';' || *p == '\t')
892 {
893 STRNCPY(patt, filter, i);
894 patt[i] = '\0';
895 if (*p == '\t')
896 gtk_file_filter_set_name(gfilter, (gchar *)patt);
897 else
898 {
899 gtk_file_filter_add_pattern(gfilter, (gchar *)patt);
900 if (*p == '\n')
901 {
902 gtk_file_chooser_add_filter((GtkFileChooser *)fc,
903 gfilter);
904 if (*(p + 1) != NUL)
905 gfilter = gtk_file_filter_new();
906 }
907 }
908 filter = ++p;
909 i = 0;
910 }
911 else
912 {
913 p++;
914 i++;
915 }
916 }
917 vim_free(patt);
918 }
Bram Moolenaara3f41662010-07-11 19:01:06 +0200919 if (saving && dflt != NULL && *dflt != NUL)
920 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(fc), (char *)dflt);
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000921
922 gui.browse_fname = NULL;
923 if (gtk_dialog_run(GTK_DIALOG(fc)) == GTK_RESPONSE_ACCEPT)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000924 {
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000925 char *filename;
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000926
Bram Moolenaarc9b4b052006-04-30 18:54:39 +0000927 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fc));
928 gui.browse_fname = (char_u *)g_strdup(filename);
929 g_free(filename);
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000930 }
931 gtk_widget_destroy(GTK_WIDGET(fc));
932
933#else
934
935 if (gui.filedlg == NULL)
936 {
937 GtkFileSelection *fs; /* shortcut */
938
Bram Moolenaar071d4272004-06-13 20:20:40 +0000939 gui.filedlg = gtk_file_selection_new((const gchar *)title);
940 gtk_window_set_modal(GTK_WINDOW(gui.filedlg), TRUE);
941 gtk_window_set_transient_for(GTK_WINDOW(gui.filedlg),
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000942 GTK_WINDOW(gui.mainwin));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000943 fs = GTK_FILE_SELECTION(gui.filedlg);
944
945 gtk_container_border_width(GTK_CONTAINER(fs), 4);
946
947 gtk_signal_connect(GTK_OBJECT(fs->ok_button),
948 "clicked", GTK_SIGNAL_FUNC(browse_ok_cb), &gui);
949 gtk_signal_connect(GTK_OBJECT(fs->cancel_button),
950 "clicked", GTK_SIGNAL_FUNC(browse_cancel_cb), &gui);
951 /* gtk_signal_connect() doesn't work for destroy, it causes a hang */
952 gtk_signal_connect_object(GTK_OBJECT(gui.filedlg),
953 "destroy", GTK_SIGNAL_FUNC(browse_destroy_cb),
954 GTK_OBJECT(gui.filedlg));
955 }
956 else
957 gtk_window_set_title(GTK_WINDOW(gui.filedlg), (const gchar *)title);
958
Bram Moolenaar57ac3a22006-10-10 16:28:30 +0000959 /* Concatenate "initdir" and "dflt". */
960 if (dflt != NULL && *dflt != NUL
961 && STRLEN(dirbuf) + 2 + STRLEN(dflt) < MAXPATHL)
962 STRCAT(dirbuf, dflt);
963
Bram Moolenaar071d4272004-06-13 20:20:40 +0000964 gtk_file_selection_set_filename(GTK_FILE_SELECTION(gui.filedlg),
965 (const gchar *)dirbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000966
967 gtk_widget_show(gui.filedlg);
Bram Moolenaara3f41662010-07-11 19:01:06 +0200968 gtk_main();
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000969#endif
Bram Moolenaar68fb5dc2012-04-25 17:10:16 +0200970 g_log_remove_handler(domain, log_handler);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000971
Bram Moolenaara7fc0102005-05-18 22:17:12 +0000972 CONVERT_TO_UTF8_FREE(title);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000973 if (gui.browse_fname == NULL)
974 return NULL;
975
976 /* shorten the file name if possible */
Bram Moolenaard089d9b2007-09-30 12:02:55 +0000977 return vim_strsave(shorten_fname1(gui.browse_fname));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000978}
979
Bram Moolenaar7b0294c2004-10-11 10:16:09 +0000980/*
981 * Put up a directory selector
982 * Returns the selected name in allocated memory, or NULL for Cancel.
983 * title title for the window
984 * dflt default name
985 * initdir initial directory, NULL for current dir
986 */
Bram Moolenaar7b0294c2004-10-11 10:16:09 +0000987 char_u *
988gui_mch_browsedir(
989 char_u *title,
990 char_u *initdir)
991{
992# if defined(GTK_FILE_CHOOSER) /* Only in GTK 2.4 and later. */
993 char_u dirbuf[MAXPATHL];
994 char_u *p;
995 GtkWidget *dirdlg; /* file selection dialog */
996 char_u *dirname = NULL;
997
998 title = CONVERT_TO_UTF8(title);
999
1000 dirdlg = gtk_file_chooser_dialog_new(
1001 (const gchar *)title,
1002 GTK_WINDOW(gui.mainwin),
1003 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
1004 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1005 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1006 NULL);
1007
1008 CONVERT_TO_UTF8_FREE(title);
1009
1010 /* if our pointer is currently hidden, then we should show it. */
1011 gui_mch_mousehide(FALSE);
1012
1013 /* GTK appears to insist on an absolute path. */
1014 if (initdir == NULL || *initdir == NUL
1015 || vim_FullName(initdir, dirbuf, MAXPATHL - 10, FALSE) == FAIL)
1016 mch_dirname(dirbuf, MAXPATHL - 10);
1017
1018 /* Always need a trailing slash for a directory.
1019 * Also add a dummy file name, so that we get to the directory. */
1020 add_pathsep(dirbuf);
1021 STRCAT(dirbuf, "@zd(*&1|");
1022 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dirdlg),
1023 (const gchar *)dirbuf);
1024
1025 /* Run the dialog. */
1026 if (gtk_dialog_run(GTK_DIALOG(dirdlg)) == GTK_RESPONSE_ACCEPT)
1027 dirname = (char_u *)gtk_file_chooser_get_filename(
1028 GTK_FILE_CHOOSER(dirdlg));
1029 gtk_widget_destroy(dirdlg);
1030 if (dirname == NULL)
1031 return NULL;
1032
1033 /* shorten the file name if possible */
Bram Moolenaard089d9b2007-09-30 12:02:55 +00001034 p = vim_strsave(shorten_fname1(dirname));
Bram Moolenaar7b0294c2004-10-11 10:16:09 +00001035 g_free(dirname);
1036 return p;
1037
1038# else
1039 /* For GTK 2.2 and earlier: fall back to ordinary file selector. */
1040 return gui_mch_browse(0, title, NULL, NULL, initdir, NULL);
1041# endif
1042}
1043
Bram Moolenaara7fc0102005-05-18 22:17:12 +00001044
Bram Moolenaar071d4272004-06-13 20:20:40 +00001045#endif /* FEAT_BROWSE */
1046
Bram Moolenaar182c5be2010-06-25 05:37:59 +02001047#if defined(FEAT_GUI_DIALOG) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001048
1049 static GtkWidget *
1050create_message_dialog(int type, char_u *title, char_u *message)
1051{
1052 GtkWidget *dialog;
1053 GtkMessageType message_type;
1054
1055 switch (type)
1056 {
1057 case VIM_ERROR: message_type = GTK_MESSAGE_ERROR; break;
1058 case VIM_WARNING: message_type = GTK_MESSAGE_WARNING; break;
1059 case VIM_QUESTION: message_type = GTK_MESSAGE_QUESTION; break;
1060 default: message_type = GTK_MESSAGE_INFO; break;
1061 }
1062
1063 message = CONVERT_TO_UTF8(message);
1064 dialog = gtk_message_dialog_new(GTK_WINDOW(gui.mainwin),
1065 GTK_DIALOG_DESTROY_WITH_PARENT,
1066 message_type,
1067 GTK_BUTTONS_NONE,
1068 "%s", (const char *)message);
1069 CONVERT_TO_UTF8_FREE(message);
1070
1071 if (title != NULL)
1072 {
1073 title = CONVERT_TO_UTF8(title);
1074 gtk_window_set_title(GTK_WINDOW(dialog), (const char *)title);
1075 CONVERT_TO_UTF8_FREE(title);
1076 }
1077 else if (type == VIM_GENERIC)
1078 {
1079 gtk_window_set_title(GTK_WINDOW(dialog), "VIM");
1080 }
1081
1082 return dialog;
1083}
1084
1085/*
1086 * Split up button_string into individual button labels by inserting
1087 * NUL bytes. Also replace the Vim-style mnemonic accelerator prefix
1088 * '&' with '_'. button_string must point to allocated memory!
1089 * Return an allocated array of pointers into button_string.
1090 */
1091 static char **
1092split_button_string(char_u *button_string, int *n_buttons)
1093{
1094 char **array;
1095 char_u *p;
1096 unsigned int count = 1;
1097
1098 for (p = button_string; *p != NUL; ++p)
1099 if (*p == DLG_BUTTON_SEP)
1100 ++count;
1101
1102 array = (char **)alloc((count + 1) * sizeof(char *));
1103 count = 0;
1104
1105 if (array != NULL)
1106 {
1107 array[count++] = (char *)button_string;
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00001108 for (p = button_string; *p != NUL; )
Bram Moolenaar071d4272004-06-13 20:20:40 +00001109 {
1110 if (*p == DLG_BUTTON_SEP)
1111 {
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00001112 *p++ = NUL;
1113 array[count++] = (char *)p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001114 }
1115 else if (*p == DLG_HOTKEY_CHAR)
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00001116 *p++ = '_';
1117 else
1118 mb_ptr_adv(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001119 }
1120 array[count] = NULL; /* currently not relied upon, but doesn't hurt */
1121 }
1122
1123 *n_buttons = count;
1124 return array;
1125}
1126
1127 static char **
1128split_button_translation(const char *message)
1129{
1130 char **buttons = NULL;
1131 char_u *str;
1132 int n_buttons = 0;
1133 int n_expected = 1;
1134
1135 for (str = (char_u *)message; *str != NUL; ++str)
1136 if (*str == DLG_BUTTON_SEP)
1137 ++n_expected;
1138
1139 str = (char_u *)_(message);
1140 if (str != NULL)
1141 {
1142 if (output_conv.vc_type != CONV_NONE)
1143 str = string_convert(&output_conv, str, NULL);
1144 else
1145 str = vim_strsave(str);
1146
1147 if (str != NULL)
1148 buttons = split_button_string(str, &n_buttons);
1149 }
1150 /*
1151 * Uh-oh... this should never ever happen. But we don't wanna crash
1152 * if the translation is broken, thus fall back to the untranslated
1153 * buttons string in case of emergency.
1154 */
1155 if (buttons == NULL || n_buttons != n_expected)
1156 {
1157 vim_free(buttons);
1158 vim_free(str);
1159 buttons = NULL;
1160 str = vim_strsave((char_u *)message);
1161
1162 if (str != NULL)
1163 buttons = split_button_string(str, &n_buttons);
1164 if (buttons == NULL)
1165 vim_free(str);
1166 }
1167
1168 return buttons;
1169}
1170
1171 static int
1172button_equal(const char *a, const char *b)
1173{
1174 while (*a != '\0' && *b != '\0')
1175 {
1176 if (*a == '_' && *++a == '\0')
1177 break;
1178 if (*b == '_' && *++b == '\0')
1179 break;
1180
1181 if (g_unichar_tolower(g_utf8_get_char(a))
1182 != g_unichar_tolower(g_utf8_get_char(b)))
1183 return FALSE;
1184
1185 a = g_utf8_next_char(a);
1186 b = g_utf8_next_char(b);
1187 }
1188
1189 return (*a == '\0' && *b == '\0');
1190}
1191
1192 static void
1193dialog_add_buttons(GtkDialog *dialog, char_u *button_string)
1194{
1195 char **ok;
1196 char **ync; /* "yes no cancel" */
1197 char **buttons;
1198 int n_buttons = 0;
Bram Moolenaar89d40322006-08-29 15:30:07 +00001199 int idx;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001200
1201 button_string = vim_strsave(button_string); /* must be writable */
1202 if (button_string == NULL)
1203 return;
1204
1205 /* Check 'v' flag in 'guioptions': vertical button placement. */
1206 if (vim_strchr(p_go, GO_VERTICAL) != NULL)
1207 {
1208 GtkWidget *vbutton_box;
1209
1210 vbutton_box = gtk_vbutton_box_new();
1211 gtk_widget_show(vbutton_box);
1212 gtk_box_pack_end(GTK_BOX(GTK_DIALOG(dialog)->vbox),
1213 vbutton_box, TRUE, FALSE, 0);
1214 /* Overrule the "action_area" value, hopefully this works... */
1215 GTK_DIALOG(dialog)->action_area = vbutton_box;
1216 }
1217
1218 /*
1219 * Yes this is ugly, I don't particularly like it either. But doing it
1220 * this way has the compelling advantage that translations need not to
1221 * be touched at all. See below what 'ok' and 'ync' are used for.
1222 */
1223 ok = split_button_translation(N_("&Ok"));
1224 ync = split_button_translation(N_("&Yes\n&No\n&Cancel"));
1225 buttons = split_button_string(button_string, &n_buttons);
1226
1227 /*
1228 * Yes, the buttons are in reversed order to match the GNOME 2 desktop
1229 * environment. Don't hit me -- it's all about consistency.
1230 * Well, apparently somebody changed his mind: with GTK 2.2.4 it works the
1231 * other way around...
1232 */
Bram Moolenaar89d40322006-08-29 15:30:07 +00001233 for (idx = 1; idx <= n_buttons; ++idx)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001234 {
1235 char *label;
1236 char_u *label8;
1237
Bram Moolenaar89d40322006-08-29 15:30:07 +00001238 label = buttons[idx - 1];
Bram Moolenaar071d4272004-06-13 20:20:40 +00001239 /*
1240 * Perform some guesswork to find appropriate stock items for the
1241 * buttons. We have to compare with a sample of the translated
1242 * button string to get things right. Yes, this is hackish :/
1243 *
1244 * But even the common button labels aren't necessarily translated,
1245 * since anyone can create their own dialogs using Vim functions.
1246 * Thus we have to check for those too.
1247 */
1248 if (ok != NULL && ync != NULL) /* almost impossible to fail */
1249 {
1250 if (button_equal(label, ok[0])) label = GTK_STOCK_OK;
1251 else if (button_equal(label, ync[0])) label = GTK_STOCK_YES;
1252 else if (button_equal(label, ync[1])) label = GTK_STOCK_NO;
1253 else if (button_equal(label, ync[2])) label = GTK_STOCK_CANCEL;
1254 else if (button_equal(label, "Ok")) label = GTK_STOCK_OK;
1255 else if (button_equal(label, "Yes")) label = GTK_STOCK_YES;
1256 else if (button_equal(label, "No")) label = GTK_STOCK_NO;
1257 else if (button_equal(label, "Cancel")) label = GTK_STOCK_CANCEL;
1258 }
1259 label8 = CONVERT_TO_UTF8((char_u *)label);
Bram Moolenaar89d40322006-08-29 15:30:07 +00001260 gtk_dialog_add_button(dialog, (const gchar *)label8, idx);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001261 CONVERT_TO_UTF8_FREE(label8);
1262 }
1263
1264 if (ok != NULL)
1265 vim_free(*ok);
1266 if (ync != NULL)
1267 vim_free(*ync);
1268 vim_free(ok);
1269 vim_free(ync);
1270 vim_free(buttons);
1271 vim_free(button_string);
1272}
1273
1274/*
1275 * Allow mnemonic accelerators to be activated without pressing <Alt>.
1276 * I'm not sure if it's a wise idea to do this. However, the old GTK+ 1.2
1277 * GUI used to work this way, and I consider the impact on UI consistency
1278 * low enough to justify implementing this as a special Vim feature.
1279 */
1280typedef struct _DialogInfo
1281{
1282 int ignore_enter; /* no default button, ignore "Enter" */
1283 int noalt; /* accept accelerators without Alt */
1284 GtkDialog *dialog; /* Widget of the dialog */
1285} DialogInfo;
1286
Bram Moolenaar071d4272004-06-13 20:20:40 +00001287 static gboolean
1288dialog_key_press_event_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
1289{
1290 DialogInfo *di = (DialogInfo *)data;
1291
Bram Moolenaard2c765e2007-08-14 13:00:40 +00001292 /* Ignore hitting Enter (or Space) when there is no default button. */
1293 if (di->ignore_enter && (event->keyval == GDK_Return
1294 || event->keyval == ' '))
1295 return TRUE;
1296 else /* A different key was pressed, return to normal behavior */
1297 di->ignore_enter = FALSE;
1298
Bram Moolenaar071d4272004-06-13 20:20:40 +00001299 /* Close the dialog when hitting "Esc". */
1300 if (event->keyval == GDK_Escape)
1301 {
1302 gtk_dialog_response(di->dialog, GTK_RESPONSE_REJECT);
1303 return TRUE;
1304 }
1305
1306 if (di->noalt
1307 && (event->state & gtk_accelerator_get_default_mod_mask()) == 0)
1308 {
1309 return gtk_window_mnemonic_activate(
1310 GTK_WINDOW(widget), event->keyval,
1311 gtk_window_get_mnemonic_modifier(GTK_WINDOW(widget)));
1312 }
1313
1314 return FALSE; /* continue emission */
1315}
1316
1317 int
1318gui_mch_dialog(int type, /* type of dialog */
1319 char_u *title, /* title of dialog */
1320 char_u *message, /* message text */
1321 char_u *buttons, /* names of buttons */
1322 int def_but, /* default button */
Bram Moolenaard2c340a2011-01-17 20:08:11 +01001323 char_u *textfield, /* text for textfield or NULL */
1324 int ex_cmd UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001325{
1326 GtkWidget *dialog;
1327 GtkWidget *entry = NULL;
1328 char_u *text;
1329 int response;
1330 DialogInfo dialoginfo;
1331
1332 dialog = create_message_dialog(type, title, message);
1333 dialoginfo.dialog = GTK_DIALOG(dialog);
1334 dialog_add_buttons(GTK_DIALOG(dialog), buttons);
1335
1336 if (textfield != NULL)
1337 {
1338 GtkWidget *alignment;
1339
1340 entry = gtk_entry_new();
1341 gtk_widget_show(entry);
1342
Bram Moolenaardf6b11e2010-11-24 18:48:12 +01001343 /* Make Enter work like pressing OK. */
Bram Moolenaar6c4b6462012-07-10 13:12:51 +02001344 gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
Bram Moolenaardf6b11e2010-11-24 18:48:12 +01001345
Bram Moolenaar071d4272004-06-13 20:20:40 +00001346 text = CONVERT_TO_UTF8(textfield);
1347 gtk_entry_set_text(GTK_ENTRY(entry), (const char *)text);
1348 CONVERT_TO_UTF8_FREE(text);
1349
1350 alignment = gtk_alignment_new((float)0.5, (float)0.5,
1351 (float)1.0, (float)1.0);
1352 gtk_container_add(GTK_CONTAINER(alignment), entry);
1353 gtk_container_set_border_width(GTK_CONTAINER(alignment), 5);
1354 gtk_widget_show(alignment);
1355
1356 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),
1357 alignment, TRUE, FALSE, 0);
1358 dialoginfo.noalt = FALSE;
1359 }
1360 else
1361 dialoginfo.noalt = TRUE;
1362
1363 /* Allow activation of mnemonic accelerators without pressing <Alt> when
Bram Moolenaar14716812006-05-04 21:54:08 +00001364 * there is no textfield. Handle pressing Esc. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001365 g_signal_connect(G_OBJECT(dialog), "key_press_event",
1366 G_CALLBACK(&dialog_key_press_event_cb), &dialoginfo);
1367
1368 if (def_but > 0)
1369 {
1370 gtk_dialog_set_default_response(GTK_DIALOG(dialog), def_but);
1371 dialoginfo.ignore_enter = FALSE;
1372 }
1373 else
1374 /* No default button, ignore pressing Enter. */
1375 dialoginfo.ignore_enter = TRUE;
1376
1377 /* Show the mouse pointer if it's currently hidden. */
1378 gui_mch_mousehide(FALSE);
1379
1380 response = gtk_dialog_run(GTK_DIALOG(dialog));
1381
1382 /* GTK_RESPONSE_NONE means the dialog was programmatically destroyed. */
1383 if (response != GTK_RESPONSE_NONE)
1384 {
Bram Moolenaar82cf9b62005-06-07 21:09:25 +00001385 if (response == GTK_RESPONSE_ACCEPT) /* Enter pressed */
1386 response = def_but;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001387 if (textfield != NULL)
1388 {
1389 text = (char_u *)gtk_entry_get_text(GTK_ENTRY(entry));
1390 text = CONVERT_FROM_UTF8(text);
1391
Bram Moolenaarce0842a2005-07-18 21:58:11 +00001392 vim_strncpy(textfield, text, IOSIZE - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001393
1394 CONVERT_FROM_UTF8_FREE(text);
1395 }
1396 gtk_widget_destroy(dialog);
1397 }
1398
Bram Moolenaar071d4272004-06-13 20:20:40 +00001399 return response > 0 ? response : 0;
1400}
1401
Bram Moolenaar182c5be2010-06-25 05:37:59 +02001402#endif /* FEAT_GUI_DIALOG */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001403
1404
1405#if defined(FEAT_MENU) || defined(PROTO)
1406
1407 void
1408gui_mch_show_popupmenu(vimmenu_T *menu)
1409{
Bram Moolenaar182c5be2010-06-25 05:37:59 +02001410# if defined(FEAT_XIM)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001411 /*
1412 * Append a submenu for selecting an input method. This is
1413 * currently the only way to switch input methods at runtime.
1414 */
1415 if (xic != NULL && g_object_get_data(G_OBJECT(menu->submenu_id),
1416 "vim-has-im-menu") == NULL)
1417 {
1418 GtkWidget *menuitem;
1419 GtkWidget *submenu;
1420 char_u *name;
1421
1422 menuitem = gtk_separator_menu_item_new();
1423 gtk_widget_show(menuitem);
1424 gtk_menu_shell_append(GTK_MENU_SHELL(menu->submenu_id), menuitem);
1425
1426 name = (char_u *)_("Input _Methods");
1427 name = CONVERT_TO_UTF8(name);
1428 menuitem = gtk_menu_item_new_with_mnemonic((const char *)name);
1429 CONVERT_TO_UTF8_FREE(name);
1430 gtk_widget_show(menuitem);
1431
1432 submenu = gtk_menu_new();
1433 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
1434 gtk_menu_shell_append(GTK_MENU_SHELL(menu->submenu_id), menuitem);
1435
1436 gtk_im_multicontext_append_menuitems(GTK_IM_MULTICONTEXT(xic),
1437 GTK_MENU_SHELL(submenu));
1438 g_object_set_data(G_OBJECT(menu->submenu_id),
1439 "vim-has-im-menu", GINT_TO_POINTER(TRUE));
1440 }
Bram Moolenaar182c5be2010-06-25 05:37:59 +02001441# endif /* FEAT_XIM */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001442
1443 gtk_menu_popup(GTK_MENU(menu->submenu_id),
1444 NULL, NULL,
1445 (GtkMenuPositionFunc)NULL, NULL,
Bram Moolenaar20892c12011-06-26 04:49:00 +02001446 3U, gui.event_time);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001447}
1448
Bram Moolenaar045e82d2005-07-08 22:25:33 +00001449/* Ugly global variable to pass "mouse_pos" flag from gui_make_popup() to
1450 * popup_menu_position_func(). */
1451static int popup_mouse_pos;
1452
Bram Moolenaar071d4272004-06-13 20:20:40 +00001453/*
1454 * Menu position callback; used by gui_make_popup() to place the menu
1455 * at the current text cursor position.
1456 *
1457 * Note: The push_in output argument seems to affect scrolling of huge
1458 * menus that don't fit on the screen. Leave it at the default for now.
1459 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001460 static void
Bram Moolenaarb85cb212009-05-17 14:24:23 +00001461popup_menu_position_func(GtkMenu *menu UNUSED,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001462 gint *x, gint *y,
Bram Moolenaarb85cb212009-05-17 14:24:23 +00001463 gboolean *push_in UNUSED,
Bram Moolenaarb85cb212009-05-17 14:24:23 +00001464 gpointer user_data UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001465{
Bram Moolenaar045e82d2005-07-08 22:25:33 +00001466 gdk_window_get_origin(gui.drawarea->window, x, y);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001467
Bram Moolenaar045e82d2005-07-08 22:25:33 +00001468 if (popup_mouse_pos)
1469 {
1470 int mx, my;
1471
1472 gui_mch_getmouse(&mx, &my);
1473 *x += mx;
1474 *y += my;
1475 }
1476 else if (curwin != NULL && gui.drawarea != NULL && gui.drawarea->window != NULL)
1477 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001478 /* Find the cursor position in the current window */
1479 *x += FILL_X(W_WINCOL(curwin) + curwin->w_wcol + 1) + 1;
1480 *y += FILL_Y(W_WINROW(curwin) + curwin->w_wrow + 1) + 1;
1481 }
1482}
1483
1484 void
Bram Moolenaar045e82d2005-07-08 22:25:33 +00001485gui_make_popup(char_u *path_name, int mouse_pos)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001486{
1487 vimmenu_T *menu;
1488
Bram Moolenaar045e82d2005-07-08 22:25:33 +00001489 popup_mouse_pos = mouse_pos;
1490
Bram Moolenaar071d4272004-06-13 20:20:40 +00001491 menu = gui_find_menu(path_name);
1492
1493 if (menu != NULL && menu->submenu_id != NULL)
1494 {
1495 gtk_menu_popup(GTK_MENU(menu->submenu_id),
1496 NULL, NULL,
1497 &popup_menu_position_func, NULL,
1498 0U, (guint32)GDK_CURRENT_TIME);
1499 }
1500}
1501
1502#endif /* FEAT_MENU */
1503
1504
1505/*
1506 * We don't create it twice.
1507 */
1508
1509typedef struct _SharedFindReplace
1510{
1511 GtkWidget *dialog; /* the main dialog widget */
1512 GtkWidget *wword; /* 'Whole word only' check button */
1513 GtkWidget *mcase; /* 'Match case' check button */
1514 GtkWidget *up; /* search direction 'Up' radio button */
1515 GtkWidget *down; /* search direction 'Down' radio button */
1516 GtkWidget *what; /* 'Find what' entry text widget */
1517 GtkWidget *with; /* 'Replace with' entry text widget */
1518 GtkWidget *find; /* 'Find Next' action button */
1519 GtkWidget *replace; /* 'Replace With' action button */
1520 GtkWidget *all; /* 'Replace All' action button */
1521} SharedFindReplace;
1522
Bram Moolenaarb85cb212009-05-17 14:24:23 +00001523static SharedFindReplace find_widgets = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
1524static SharedFindReplace repl_widgets = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
Bram Moolenaar071d4272004-06-13 20:20:40 +00001525
Bram Moolenaar071d4272004-06-13 20:20:40 +00001526 static int
1527find_key_press_event(
Bram Moolenaarb85cb212009-05-17 14:24:23 +00001528 GtkWidget *widget UNUSED,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001529 GdkEventKey *event,
1530 SharedFindReplace *frdp)
1531{
1532 /* If the user is holding one of the key modifiers we will just bail out,
1533 * thus preserving the possibility of normal focus traversal.
1534 */
1535 if (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK))
1536 return FALSE;
1537
1538 /* the Escape key synthesizes a cancellation action */
1539 if (event->keyval == GDK_Escape)
1540 {
1541 gtk_widget_hide(frdp->dialog);
1542
1543 return TRUE;
1544 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001545
Bram Moolenaar79166c42007-05-10 18:29:51 +00001546 /* It would be delightful if it where possible to do search history
Bram Moolenaar071d4272004-06-13 20:20:40 +00001547 * operations on the K_UP and K_DOWN keys here.
1548 */
1549
1550 return FALSE;
1551}
1552
Bram Moolenaar071d4272004-06-13 20:20:40 +00001553 static GtkWidget *
1554create_image_button(const char *stock_id, const char *label)
1555{
1556 char_u *text;
1557 GtkWidget *box;
1558 GtkWidget *alignment;
1559 GtkWidget *button;
1560
1561 text = CONVERT_TO_UTF8((char_u *)label);
1562
1563 box = gtk_hbox_new(FALSE, 3);
1564 gtk_box_pack_start(GTK_BOX(box),
1565 gtk_image_new_from_stock(stock_id, GTK_ICON_SIZE_BUTTON),
1566 FALSE, FALSE, 0);
1567 gtk_box_pack_start(GTK_BOX(box),
1568 gtk_label_new((const char *)text),
1569 FALSE, FALSE, 0);
1570
1571 CONVERT_TO_UTF8_FREE(text);
1572
1573 alignment = gtk_alignment_new((float)0.5, (float)0.5,
1574 (float)0.0, (float)0.0);
1575 gtk_container_add(GTK_CONTAINER(alignment), box);
1576 gtk_widget_show_all(alignment);
1577
1578 button = gtk_button_new();
1579 gtk_container_add(GTK_CONTAINER(button), alignment);
1580
1581 return button;
1582}
1583
1584/*
1585 * This is currently only used by find_replace_dialog_create(), and
1586 * I'd really like to keep it at that. In other words: don't spread
1587 * this nasty hack all over the code. Think twice.
1588 */
1589 static const char *
1590convert_localized_message(char_u **buffer, const char *message)
1591{
1592 if (output_conv.vc_type == CONV_NONE)
1593 return message;
1594
1595 vim_free(*buffer);
1596 *buffer = string_convert(&output_conv, (char_u *)message, NULL);
1597
1598 return (const char *)*buffer;
1599}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001600
1601 static void
1602find_replace_dialog_create(char_u *arg, int do_replace)
1603{
Bram Moolenaar071d4272004-06-13 20:20:40 +00001604 GtkWidget *hbox; /* main top down box */
1605 GtkWidget *actionarea;
1606 GtkWidget *table;
1607 GtkWidget *tmp;
1608 GtkWidget *vbox;
1609 gboolean sensitive;
1610 SharedFindReplace *frdp;
1611 char_u *entry_text;
1612 int wword = FALSE;
1613 int mcase = !p_ic;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001614 char_u *conv_buffer = NULL;
1615# define CONV(message) convert_localized_message(&conv_buffer, (message))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001616
1617 frdp = (do_replace) ? (&repl_widgets) : (&find_widgets);
1618
1619 /* Get the search string to use. */
1620 entry_text = get_find_dialog_text(arg, &wword, &mcase);
1621
Bram Moolenaar071d4272004-06-13 20:20:40 +00001622 if (entry_text != NULL && output_conv.vc_type != CONV_NONE)
1623 {
1624 char_u *old_text = entry_text;
1625 entry_text = string_convert(&output_conv, entry_text, NULL);
1626 vim_free(old_text);
1627 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001628
1629 /*
1630 * If the dialog already exists, just raise it.
1631 */
1632 if (frdp->dialog)
1633 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001634 if (entry_text != NULL)
1635 {
1636 gtk_entry_set_text(GTK_ENTRY(frdp->what), (char *)entry_text);
1637 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp->wword),
1638 (gboolean)wword);
1639 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp->mcase),
1640 (gboolean)mcase);
1641 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001642 gtk_window_present(GTK_WINDOW(frdp->dialog));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001643 vim_free(entry_text);
1644 return;
1645 }
1646
Bram Moolenaar071d4272004-06-13 20:20:40 +00001647 frdp->dialog = gtk_dialog_new();
1648 gtk_dialog_set_has_separator(GTK_DIALOG(frdp->dialog), FALSE);
1649 gtk_window_set_transient_for(GTK_WINDOW(frdp->dialog), GTK_WINDOW(gui.mainwin));
1650 gtk_window_set_destroy_with_parent(GTK_WINDOW(frdp->dialog), TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001651
1652 if (do_replace)
1653 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001654 gtk_window_set_title(GTK_WINDOW(frdp->dialog),
1655 CONV(_("VIM - Search and Replace...")));
1656 }
1657 else
1658 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001659 gtk_window_set_title(GTK_WINDOW(frdp->dialog),
1660 CONV(_("VIM - Search...")));
1661 }
1662
Bram Moolenaar071d4272004-06-13 20:20:40 +00001663 hbox = gtk_hbox_new(FALSE, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001664 gtk_container_set_border_width(GTK_CONTAINER(hbox), 10);
1665 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(frdp->dialog)->vbox), hbox);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001666
1667 if (do_replace)
1668 table = gtk_table_new(1024, 4, FALSE);
1669 else
1670 table = gtk_table_new(1024, 3, FALSE);
1671 gtk_box_pack_start(GTK_BOX(hbox), table, TRUE, TRUE, 0);
1672 gtk_container_border_width(GTK_CONTAINER(table), 4);
1673
1674 tmp = gtk_label_new(CONV(_("Find what:")));
1675 gtk_misc_set_alignment(GTK_MISC(tmp), (gfloat)0.0, (gfloat)0.5);
1676 gtk_table_attach(GTK_TABLE(table), tmp, 0, 1, 0, 1,
1677 GTK_FILL, GTK_EXPAND, 2, 2);
1678 frdp->what = gtk_entry_new();
1679 sensitive = (entry_text != NULL && entry_text[0] != NUL);
1680 if (entry_text != NULL)
1681 gtk_entry_set_text(GTK_ENTRY(frdp->what), (char *)entry_text);
1682 gtk_signal_connect(GTK_OBJECT(frdp->what), "changed",
1683 GTK_SIGNAL_FUNC(entry_changed_cb), frdp->dialog);
1684 gtk_signal_connect_after(GTK_OBJECT(frdp->what), "key_press_event",
1685 GTK_SIGNAL_FUNC(find_key_press_event),
1686 (gpointer) frdp);
1687 gtk_table_attach(GTK_TABLE(table), frdp->what, 1, 1024, 0, 1,
1688 GTK_EXPAND | GTK_FILL, GTK_EXPAND, 2, 2);
1689
1690 if (do_replace)
1691 {
1692 tmp = gtk_label_new(CONV(_("Replace with:")));
1693 gtk_misc_set_alignment(GTK_MISC(tmp), (gfloat)0.0, (gfloat)0.5);
1694 gtk_table_attach(GTK_TABLE(table), tmp, 0, 1, 1, 2,
1695 GTK_FILL, GTK_EXPAND, 2, 2);
1696 frdp->with = gtk_entry_new();
1697 gtk_signal_connect(GTK_OBJECT(frdp->with), "activate",
1698 GTK_SIGNAL_FUNC(find_replace_cb),
1699 GINT_TO_POINTER(FRD_R_FINDNEXT));
1700 gtk_signal_connect_after(GTK_OBJECT(frdp->with), "key_press_event",
1701 GTK_SIGNAL_FUNC(find_key_press_event),
1702 (gpointer) frdp);
1703 gtk_table_attach(GTK_TABLE(table), frdp->with, 1, 1024, 1, 2,
1704 GTK_EXPAND | GTK_FILL, GTK_EXPAND, 2, 2);
1705
1706 /*
1707 * Make the entry activation only change the input focus onto the
1708 * with item.
1709 */
1710 gtk_signal_connect(GTK_OBJECT(frdp->what), "activate",
1711 GTK_SIGNAL_FUNC(entry_activate_cb), frdp->with);
1712 }
1713 else
1714 {
1715 /*
1716 * Make the entry activation do the search.
1717 */
1718 gtk_signal_connect(GTK_OBJECT(frdp->what), "activate",
1719 GTK_SIGNAL_FUNC(find_replace_cb),
1720 GINT_TO_POINTER(FRD_FINDNEXT));
1721 }
1722
1723 /* whole word only button */
1724 frdp->wword = gtk_check_button_new_with_label(CONV(_("Match whole word only")));
1725 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp->wword),
1726 (gboolean)wword);
1727 if (do_replace)
1728 gtk_table_attach(GTK_TABLE(table), frdp->wword, 0, 1023, 2, 3,
1729 GTK_FILL, GTK_EXPAND, 2, 2);
1730 else
1731 gtk_table_attach(GTK_TABLE(table), frdp->wword, 0, 1023, 1, 2,
1732 GTK_FILL, GTK_EXPAND, 2, 2);
1733
1734 /* match case button */
1735 frdp->mcase = gtk_check_button_new_with_label(CONV(_("Match case")));
1736 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp->mcase),
1737 (gboolean)mcase);
1738 if (do_replace)
1739 gtk_table_attach(GTK_TABLE(table), frdp->mcase, 0, 1023, 3, 4,
1740 GTK_FILL, GTK_EXPAND, 2, 2);
1741 else
1742 gtk_table_attach(GTK_TABLE(table), frdp->mcase, 0, 1023, 2, 3,
1743 GTK_FILL, GTK_EXPAND, 2, 2);
1744
1745 tmp = gtk_frame_new(CONV(_("Direction")));
1746 if (do_replace)
1747 gtk_table_attach(GTK_TABLE(table), tmp, 1023, 1024, 2, 4,
1748 GTK_FILL, GTK_FILL, 2, 2);
1749 else
1750 gtk_table_attach(GTK_TABLE(table), tmp, 1023, 1024, 1, 3,
1751 GTK_FILL, GTK_FILL, 2, 2);
1752 vbox = gtk_vbox_new(FALSE, 0);
1753 gtk_container_border_width(GTK_CONTAINER(vbox), 0);
1754 gtk_container_add(GTK_CONTAINER(tmp), vbox);
1755
1756 /* 'Up' and 'Down' buttons */
1757 frdp->up = gtk_radio_button_new_with_label(NULL, CONV(_("Up")));
1758 gtk_box_pack_start(GTK_BOX(vbox), frdp->up, TRUE, TRUE, 0);
1759 frdp->down = gtk_radio_button_new_with_label(
1760 gtk_radio_button_group(GTK_RADIO_BUTTON(frdp->up)),
1761 CONV(_("Down")));
1762 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(frdp->down), TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001763 gtk_container_set_border_width(GTK_CONTAINER(vbox), 2);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001764 gtk_box_pack_start(GTK_BOX(vbox), frdp->down, TRUE, TRUE, 0);
1765
1766 /* vbox to hold the action buttons */
1767 actionarea = gtk_vbutton_box_new();
1768 gtk_container_border_width(GTK_CONTAINER(actionarea), 2);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001769 gtk_box_pack_end(GTK_BOX(hbox), actionarea, FALSE, FALSE, 0);
1770
1771 /* 'Find Next' button */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001772 frdp->find = create_image_button(GTK_STOCK_FIND, _("Find Next"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001773 gtk_widget_set_sensitive(frdp->find, sensitive);
1774
1775 gtk_signal_connect(GTK_OBJECT(frdp->find), "clicked",
1776 GTK_SIGNAL_FUNC(find_replace_cb),
1777 (do_replace) ? GINT_TO_POINTER(FRD_R_FINDNEXT)
1778 : GINT_TO_POINTER(FRD_FINDNEXT));
1779
1780 GTK_WIDGET_SET_FLAGS(frdp->find, GTK_CAN_DEFAULT);
1781 gtk_box_pack_start(GTK_BOX(actionarea), frdp->find, FALSE, FALSE, 0);
1782 gtk_widget_grab_default(frdp->find);
1783
1784 if (do_replace)
1785 {
1786 /* 'Replace' button */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001787 frdp->replace = create_image_button(GTK_STOCK_CONVERT, _("Replace"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001788 gtk_widget_set_sensitive(frdp->replace, sensitive);
1789 GTK_WIDGET_SET_FLAGS(frdp->replace, GTK_CAN_DEFAULT);
1790 gtk_box_pack_start(GTK_BOX(actionarea), frdp->replace, FALSE, FALSE, 0);
1791 gtk_signal_connect(GTK_OBJECT(frdp->replace), "clicked",
1792 GTK_SIGNAL_FUNC(find_replace_cb),
1793 GINT_TO_POINTER(FRD_REPLACE));
1794
1795 /* 'Replace All' button */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001796 frdp->all = create_image_button(GTK_STOCK_CONVERT, _("Replace All"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001797 gtk_widget_set_sensitive(frdp->all, sensitive);
1798 GTK_WIDGET_SET_FLAGS(frdp->all, GTK_CAN_DEFAULT);
1799 gtk_box_pack_start(GTK_BOX(actionarea), frdp->all, FALSE, FALSE, 0);
1800 gtk_signal_connect(GTK_OBJECT(frdp->all), "clicked",
1801 GTK_SIGNAL_FUNC(find_replace_cb),
1802 GINT_TO_POINTER(FRD_REPLACEALL));
1803 }
1804
1805 /* 'Cancel' button */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001806 tmp = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001807 GTK_WIDGET_SET_FLAGS(tmp, GTK_CAN_DEFAULT);
1808 gtk_box_pack_end(GTK_BOX(actionarea), tmp, FALSE, FALSE, 0);
1809 gtk_signal_connect_object(GTK_OBJECT(tmp),
1810 "clicked", GTK_SIGNAL_FUNC(gtk_widget_hide),
1811 GTK_OBJECT(frdp->dialog));
1812 gtk_signal_connect_object(GTK_OBJECT(frdp->dialog),
1813 "delete_event", GTK_SIGNAL_FUNC(gtk_widget_hide_on_delete),
1814 GTK_OBJECT(frdp->dialog));
1815
1816 tmp = gtk_vseparator_new();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001817 gtk_box_pack_end(GTK_BOX(hbox), tmp, FALSE, FALSE, 10);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001818
Bram Moolenaar071d4272004-06-13 20:20:40 +00001819 /* Suppress automatic show of the unused action area */
1820 gtk_widget_hide(GTK_DIALOG(frdp->dialog)->action_area);
1821 gtk_widget_show_all(hbox);
1822 gtk_widget_show(frdp->dialog);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001823
1824 vim_free(entry_text);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001825 vim_free(conv_buffer);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001826#undef CONV
1827}
1828
1829 void
1830gui_mch_find_dialog(exarg_T *eap)
1831{
1832 if (gui.in_use)
1833 find_replace_dialog_create(eap->arg, FALSE);
1834}
1835
1836 void
1837gui_mch_replace_dialog(exarg_T *eap)
1838{
1839 if (gui.in_use)
1840 find_replace_dialog_create(eap->arg, TRUE);
1841}
1842
Bram Moolenaar071d4272004-06-13 20:20:40 +00001843/*
1844 * Callback for actions of the find and replace dialogs
1845 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001846 static void
Bram Moolenaarb85cb212009-05-17 14:24:23 +00001847find_replace_cb(GtkWidget *widget UNUSED, gpointer data)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001848{
1849 int flags;
1850 char_u *find_text;
1851 char_u *repl_text;
1852 gboolean direction_down;
1853 SharedFindReplace *sfr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001854
1855 flags = (int)(long)data; /* avoid a lint warning here */
1856
1857 /* Get the search/replace strings from the dialog */
1858 if (flags == FRD_FINDNEXT)
1859 {
1860 repl_text = NULL;
1861 sfr = &find_widgets;
1862 }
1863 else
1864 {
1865 repl_text = (char_u *)gtk_entry_get_text(GTK_ENTRY(repl_widgets.with));
1866 sfr = &repl_widgets;
1867 }
1868
1869 find_text = (char_u *)gtk_entry_get_text(GTK_ENTRY(sfr->what));
1870 direction_down = GTK_TOGGLE_BUTTON(sfr->down)->active;
1871
1872 if (GTK_TOGGLE_BUTTON(sfr->wword)->active)
1873 flags |= FRD_WHOLE_WORD;
1874 if (GTK_TOGGLE_BUTTON(sfr->mcase)->active)
1875 flags |= FRD_MATCH_CASE;
1876
Bram Moolenaar071d4272004-06-13 20:20:40 +00001877 repl_text = CONVERT_FROM_UTF8(repl_text);
1878 find_text = CONVERT_FROM_UTF8(find_text);
Bram Moolenaare980d8a2010-12-08 13:11:21 +01001879 gui_do_findrepl(flags, find_text, repl_text, direction_down);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001880 CONVERT_FROM_UTF8_FREE(repl_text);
1881 CONVERT_FROM_UTF8_FREE(find_text);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001882}
1883
1884/* our usual callback function */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001885 static void
Bram Moolenaarb85cb212009-05-17 14:24:23 +00001886entry_activate_cb(GtkWidget *widget UNUSED, gpointer data)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001887{
1888 gtk_widget_grab_focus(GTK_WIDGET(data));
1889}
1890
1891/*
1892 * Syncing the find/replace dialogs on the fly is utterly useless crack,
1893 * and causes nothing but problems. Please tell me a use case for which
1894 * you'd need both a find dialog and a find/replace one at the same time,
1895 * without being able to actually use them separately since they're syncing
1896 * all the time. I don't think it's worthwhile to fix this nonsense,
1897 * particularly evil incarnation of braindeadness, whatever; I'd much rather
1898 * see it extinguished from this planet. Thanks for listening. Sorry.
1899 */
1900 static void
1901entry_changed_cb(GtkWidget * entry, GtkWidget * dialog)
1902{
1903 const gchar *entry_text;
1904 gboolean nonempty;
1905
1906 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
1907
1908 if (!entry_text)
1909 return; /* shouldn't happen */
1910
1911 nonempty = (entry_text[0] != '\0');
1912
1913 if (dialog == find_widgets.dialog)
1914 {
1915 gtk_widget_set_sensitive(find_widgets.find, nonempty);
1916 }
1917
1918 if (dialog == repl_widgets.dialog)
1919 {
1920 gtk_widget_set_sensitive(repl_widgets.find, nonempty);
1921 gtk_widget_set_sensitive(repl_widgets.replace, nonempty);
1922 gtk_widget_set_sensitive(repl_widgets.all, nonempty);
1923 }
1924}
1925
1926/*
1927 * ":helpfind"
1928 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001929 void
1930ex_helpfind(eap)
Bram Moolenaarb85cb212009-05-17 14:24:23 +00001931 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001932{
1933 /* This will fail when menus are not loaded. Well, it's only for
1934 * backwards compatibility anyway. */
1935 do_cmdline_cmd((char_u *)"emenu ToolBar.FindHelp");
1936}
Bram Moolenaar68fb5dc2012-04-25 17:10:16 +02001937
Bram Moolenaar08bc2742012-06-06 16:14:40 +02001938#if defined(FEAT_BROWSE) || defined(PROTO)
Bram Moolenaar68fb5dc2012-04-25 17:10:16 +02001939 static void
1940recent_func_log_func(const gchar *log_domain UNUSED,
1941 GLogLevelFlags log_level UNUSED,
1942 const gchar *message UNUSED,
1943 gpointer user_data UNUSED)
1944{
1945 /* We just want to suppress the warnings. */
1946 /* http://bugzilla.gnome.org/show_bug.cgi?id=664587 */
1947}
Bram Moolenaar08bc2742012-06-06 16:14:40 +02001948#endif