1 /* vi:set ts=8 sts=4 sw=4 noet:
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 *
13 * (C) 1998,1999,2000 by Marcin Dalecki <[email protected]>
14 *
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 <[email protected]>
21 * Daniel Elstner <[email protected]>
22 *
23 * Best supporting actor (He helped somewhat, aesthetically speaking):
24 * Maxime Romano <[email protected]>
25 *
26 * Support for GTK+ 3 was added by:
27 *
28 * 2016 Kazunobu Kuriyama <[email protected]>
29 *
30 * With the help of Marius Gedminas and the word of Bram Moolenaar,
31 * "Let's give this some time to mature."
32 */
33
34 #include "vim.h"
35
36 #ifdef FEAT_GUI_GTK
37 # include "gui_gtk_f.h"
38 #endif
39
40 // GTK defines MAX and MIN, but some system header files as well. Undefine
41 // them and don't use them.
42 #ifdef MIN
43 # undef MIN
44 #endif
45 #ifdef MAX
46 # undef MAX
47 #endif
48
49 #ifdef FEAT_GUI_GNOME
50 // Gnome redefines _() and N_(). Grrr...
51 # ifdef _
52 # undef _
53 # endif
54 # ifdef N_
55 # undef N_
56 # endif
57 # ifdef textdomain
58 # undef textdomain
59 # endif
60 # ifdef bindtextdomain
61 # undef bindtextdomain
62 # endif
63 # ifdef bind_textdomain_codeset
64 # undef bind_textdomain_codeset
65 # endif
66 # if defined(FEAT_GETTEXT) && !defined(ENABLE_NLS)
67 # define ENABLE_NLS // so the texts in the dialog boxes are translated
68 # endif
69 # include <gnome.h>
70 #endif
71
72 #ifdef FEAT_GUI_GTK
73 # if GTK_CHECK_VERSION(3,0,0)
74 # include <gdk/gdkkeysyms-compat.h>
75 # else
76 # include <gdk/gdkkeysyms.h>
77 # endif
78 # include <gdk/gdk.h>
79 # ifdef MSWIN
80 # include <gdk/gdkwin32.h>
81 # else
82 # include <gdk/gdkx.h>
83 # endif
84
85 # include <gtk/gtk.h>
86 #else
87 // define these items to be able to generate prototypes without GTK
88 typedef int GtkWidget;
89 # define gpointer int
90 # define guint8 int
91 # define GdkPixmap int
92 # define GdkBitmap int
93 # define GtkIconFactory int
94 # define GtkToolbar int
95 # define GtkAdjustment int
96 # define gboolean int
97 # define GdkEventKey int
98 # define CancelData int
99 #endif
100
101 static void entry_activate_cb(GtkWidget *widget, gpointer data);
102 static void entry_changed_cb(GtkWidget *entry, GtkWidget *dialog);
103 static void find_replace_cb(GtkWidget *widget, gpointer data);
104 #if defined(FEAT_BROWSE) || defined(PROTO)
105 static void recent_func_log_func(
106 const gchar *log_domain,
107 GLogLevelFlags log_level,
108 const gchar *message,
109 gpointer user_data);
110 #endif
111
112 #if defined(FEAT_TOOLBAR)
113 /*
114 * Table from BuiltIn## icon indices to GTK+ stock IDs. Order must exactly
115 * match toolbar_names[] in menu.c! All stock icons including the "vim-*"
116 * ones can be overridden in your gtkrc file.
117 */
118 # if GTK_CHECK_VERSION(3,10,0)
119 static const char * const menu_themed_names[] =
120 {
121 /* 00 */ "document-new", // sub. GTK_STOCK_NEW
122 /* 01 */ "document-open", // sub. GTK_STOCK_OPEN
123 /* 02 */ "document-save", // sub. GTK_STOCK_SAVE
124 /* 03 */ "edit-undo", // sub. GTK_STOCK_UNDO
125 /* 04 */ "edit-redo", // sub. GTK_STOCK_REDO
126 /* 05 */ "edit-cut", // sub. GTK_STOCK_CUT
127 /* 06 */ "edit-copy", // sub. GTK_STOCK_COPY
128 /* 07 */ "edit-paste", // sub. GTK_STOCK_PASTE
129 /* 08 */ "document-print", // sub. GTK_STOCK_PRINT
130 /* 09 */ "help-browser", // sub. GTK_STOCK_HELP
131 /* 10 */ "edit-find", // sub. GTK_STOCK_FIND
132 # if GTK_CHECK_VERSION(3,14,0)
133 // Use the file names in gui_gtk_res.xml, cutting off the extension.
134 // Similar changes follow.
135 /* 11 */ "stock_vim_save_all",
136 /* 12 */ "stock_vim_session_save",
137 /* 13 */ "stock_vim_session_new",
138 /* 14 */ "stock_vim_session_load",
139 # else
140 /* 11 */ "vim-save-all",
141 /* 12 */ "vim-session-save",
142 /* 13 */ "vim-session-new",
143 /* 14 */ "vim-session-load",
144 # endif
145 /* 15 */ "system-run", // sub. GTK_STOCK_EXECUTE
146 /* 16 */ "edit-find-replace", // sub. GTK_STOCK_FIND_AND_REPLACE
147 /* 17 */ "window-close", // sub. GTK_STOCK_CLOSE, FIXME: fuzzy
148 # if GTK_CHECK_VERSION(3,14,0)
149 /* 18 */ "stock_vim_window_maximize",
150 /* 19 */ "stock_vim_window_minimize",
151 /* 20 */ "stock_vim_window_split",
152 /* 21 */ "stock_vim_shell",
153 # else
154 /* 18 */ "vim-window-maximize",
155 /* 19 */ "vim-window-minimize",
156 /* 20 */ "vim-window-split",
157 /* 21 */ "vim-shell",
158 # endif
159 /* 22 */ "go-previous", // sub. GTK_STOCK_GO_BACK
160 /* 23 */ "go-next", // sub. GTK_STOCK_GO_FORWARD
161 # if GTK_CHECK_VERSION(3,14,0)
162 /* 24 */ "stock_vim_find_help",
163 # else
164 /* 24 */ "vim-find-help",
165 # endif
166 /* 25 */ "gtk-convert", // sub. GTK_STOCK_CONVERT
167 /* 26 */ "go-jump", // sub. GTK_STOCK_JUMP_TO
168 # if GTK_CHECK_VERSION(3,14,0)
169 /* 27 */ "stock_vim_build_tags",
170 /* 28 */ "stock_vim_window_split_vertical",
171 /* 29 */ "stock_vim_window_maximize_width",
172 /* 30 */ "stock_vim_window_minimize_width",
173 # else
174 /* 27 */ "vim-build-tags",
175 /* 28 */ "vim-window-split-vertical",
176 /* 29 */ "vim-window-maximize-width",
177 /* 30 */ "vim-window-minimize-width",
178 # endif
179 /* 31 */ "application-exit", // GTK_STOCK_QUIT
180 };
181 # else // !GTK_CHECK_VERSION(3,10,0)
182 static const char * const menu_stock_ids[] =
183 {
184 /* 00 */ GTK_STOCK_NEW,
185 /* 01 */ GTK_STOCK_OPEN,
186 /* 02 */ GTK_STOCK_SAVE,
187 /* 03 */ GTK_STOCK_UNDO,
188 /* 04 */ GTK_STOCK_REDO,
189 /* 05 */ GTK_STOCK_CUT,
190 /* 06 */ GTK_STOCK_COPY,
191 /* 07 */ GTK_STOCK_PASTE,
192 /* 08 */ GTK_STOCK_PRINT,
193 /* 09 */ GTK_STOCK_HELP,
194 /* 10 */ GTK_STOCK_FIND,
195 /* 11 */ "vim-save-all",
196 /* 12 */ "vim-session-save",
197 /* 13 */ "vim-session-new",
198 /* 14 */ "vim-session-load",
199 /* 15 */ GTK_STOCK_EXECUTE,
200 /* 16 */ GTK_STOCK_FIND_AND_REPLACE,
201 /* 17 */ GTK_STOCK_CLOSE, // FIXME: fuzzy
202 /* 18 */ "vim-window-maximize",
203 /* 19 */ "vim-window-minimize",
204 /* 20 */ "vim-window-split",
205 /* 21 */ "vim-shell",
206 /* 22 */ GTK_STOCK_GO_BACK,
207 /* 23 */ GTK_STOCK_GO_FORWARD,
208 /* 24 */ "vim-find-help",
209 /* 25 */ GTK_STOCK_CONVERT,
210 /* 26 */ GTK_STOCK_JUMP_TO,
211 /* 27 */ "vim-build-tags",
212 /* 28 */ "vim-window-split-vertical",
213 /* 29 */ "vim-window-maximize-width",
214 /* 30 */ "vim-window-minimize-width",
215 /* 31 */ GTK_STOCK_QUIT
216 };
217 # endif // !GTK_CHECK_VERSION(3,10,0)
218
219 # ifdef USE_GRESOURCE
220 # if !GTK_CHECK_VERSION(3,10,0)
221 typedef struct IconNames {
222 const char *icon_name;
223 const char *file_name;
224 } IconNames;
225
226 static IconNames stock_vim_icons[] = {
227 { "vim-build-tags", "stock_vim_build_tags.png" },
228 { "vim-find-help", "stock_vim_find_help.png" },
229 { "vim-save-all", "stock_vim_save_all.png" },
230 { "vim-session-load", "stock_vim_session_load.png" },
231 { "vim-session-new", "stock_vim_session_new.png" },
232 { "vim-session-save", "stock_vim_session_save.png" },
233 { "vim-shell", "stock_vim_shell.png" },
234 { "vim-window-maximize", "stock_vim_window_maximize.png" },
235 { "vim-window-maximize-width", "stock_vim_window_maximize_width.png" },
236 { "vim-window-minimize", "stock_vim_window_minimize.png" },
237 { "vim-window-minimize-width", "stock_vim_window_minimize_width.png" },
238 { "vim-window-split", "stock_vim_window_split.png" },
239 { "vim-window-split-vertical", "stock_vim_window_split_vertical.png" },
240 { NULL, NULL }
241 };
242 # endif
243 # endif // USE_G_RESOURCE
244
245 # ifndef USE_GRESOURCE
246 static void
add_stock_icon(GtkIconFactory * factory,const char * stock_id,const guint8 * inline_data,int data_length)247 add_stock_icon(GtkIconFactory *factory,
248 const char *stock_id,
249 const guint8 *inline_data,
250 int data_length)
251 {
252 GdkPixbuf *pixbuf;
253 GtkIconSet *icon_set;
254
255 pixbuf = gdk_pixbuf_new_from_inline(data_length, inline_data, FALSE, NULL);
256 icon_set = gtk_icon_set_new_from_pixbuf(pixbuf);
257
258 gtk_icon_factory_add(factory, stock_id, icon_set);
259
260 gtk_icon_set_unref(icon_set);
261 g_object_unref(pixbuf);
262 }
263 # endif
264
265 static int
lookup_menu_iconfile(char_u * iconfile,char_u * dest)266 lookup_menu_iconfile(char_u *iconfile, char_u *dest)
267 {
268 expand_env(iconfile, dest, MAXPATHL);
269
270 if (mch_isFullName(dest))
271 {
272 return vim_fexists(dest);
273 }
274 else
275 {
276 static const char suffixes[][4] = {"png", "xpm", "bmp"};
277 char_u buf[MAXPATHL];
278 unsigned int i;
279
280 for (i = 0; i < G_N_ELEMENTS(suffixes); ++i)
281 if (gui_find_bitmap(dest, buf, (char *)suffixes[i]) == OK)
282 {
283 STRCPY(dest, buf);
284 return TRUE;
285 }
286
287 return FALSE;
288 }
289 }
290
291 static GtkWidget *
load_menu_iconfile(char_u * name,GtkIconSize icon_size)292 load_menu_iconfile(char_u *name, GtkIconSize icon_size)
293 {
294 GtkWidget *image = NULL;
295 # if GTK_CHECK_VERSION(3,10,0)
296 int pixel_size = -1;
297
298 switch (icon_size)
299 {
300 case GTK_ICON_SIZE_MENU:
301 pixel_size = 16;
302 break;
303 case GTK_ICON_SIZE_SMALL_TOOLBAR:
304 pixel_size = 16;
305 break;
306 case GTK_ICON_SIZE_LARGE_TOOLBAR:
307 pixel_size = 24;
308 break;
309 case GTK_ICON_SIZE_BUTTON:
310 pixel_size = 16;
311 break;
312 case GTK_ICON_SIZE_DND:
313 pixel_size = 32;
314 break;
315 case GTK_ICON_SIZE_DIALOG:
316 pixel_size = 48;
317 break;
318 case GTK_ICON_SIZE_INVALID:
319 // FALLTHROUGH
320 default:
321 pixel_size = 0;
322 break;
323 }
324
325 if (pixel_size > 0 || pixel_size == -1)
326 {
327 GdkPixbuf * const pixbuf
328 = gdk_pixbuf_new_from_file_at_scale((const char *)name,
329 pixel_size, pixel_size, TRUE, NULL);
330 if (pixbuf != NULL)
331 {
332 image = gtk_image_new_from_pixbuf(pixbuf);
333 g_object_unref(pixbuf);
334 }
335 }
336 if (image == NULL)
337 image = gtk_image_new_from_icon_name("image-missing", icon_size);
338
339 return image;
340 # else // !GTK_CHECK_VERSION(3,10,0)
341 GtkIconSet *icon_set;
342 GtkIconSource *icon_source;
343
344 /*
345 * Rather than loading the icon directly into a GtkImage, create
346 * a new GtkIconSet and put it in there. This way we can easily
347 * scale the toolbar icons on the fly when needed.
348 */
349 icon_set = gtk_icon_set_new();
350 icon_source = gtk_icon_source_new();
351
352 gtk_icon_source_set_filename(icon_source, (const char *)name);
353 gtk_icon_set_add_source(icon_set, icon_source);
354
355 image = gtk_image_new_from_icon_set(icon_set, icon_size);
356
357 gtk_icon_source_free(icon_source);
358 gtk_icon_set_unref(icon_set);
359
360 return image;
361 # endif // !GTK_CHECK_VERSION(3,10,0)
362 }
363
364 static GtkWidget *
create_menu_icon(vimmenu_T * menu,GtkIconSize icon_size)365 create_menu_icon(vimmenu_T *menu, GtkIconSize icon_size)
366 {
367 GtkWidget *image = NULL;
368 char_u buf[MAXPATHL];
369
370 // First use a specified "icon=" argument.
371 if (menu->iconfile != NULL && lookup_menu_iconfile(menu->iconfile, buf))
372 image = load_menu_iconfile(buf, icon_size);
373
374 // If not found and not builtin specified try using the menu name.
375 if (image == NULL && !menu->icon_builtin
376 && lookup_menu_iconfile(menu->name, buf))
377 image = load_menu_iconfile(buf, icon_size);
378
379 // Still not found? Then use a builtin icon, a blank one as fallback.
380 if (image == NULL)
381 {
382 # if GTK_CHECK_VERSION(3,10,0)
383 const char *icon_name = NULL;
384 const int n_names = G_N_ELEMENTS(menu_themed_names);
385
386 if (menu->iconidx >= 0 && menu->iconidx < n_names)
387 icon_name = menu_themed_names[menu->iconidx];
388 if (icon_name == NULL)
389 icon_name = "image-missing";
390
391 image = gtk_image_new_from_icon_name(icon_name, icon_size);
392 # else
393 const char *stock_id;
394 const int n_ids = G_N_ELEMENTS(menu_stock_ids);
395
396 if (menu->iconidx >= 0 && menu->iconidx < n_ids)
397 stock_id = menu_stock_ids[menu->iconidx];
398 else
399 stock_id = GTK_STOCK_MISSING_IMAGE;
400
401 image = gtk_image_new_from_stock(stock_id, icon_size);
402 # endif
403 }
404
405 return image;
406 }
407
408 static gint
toolbar_button_focus_in_event(GtkWidget * widget UNUSED,GdkEventFocus * event UNUSED,gpointer data UNUSED)409 toolbar_button_focus_in_event(GtkWidget *widget UNUSED,
410 GdkEventFocus *event UNUSED,
411 gpointer data UNUSED)
412 {
413 // When we're in a GtkPlug, we don't have window focus events, only widget
414 // focus. To emulate stand-alone gvim, if a button gets focus (e.g.,
415 // <Tab> into GtkPlug) immediately pass it to mainwin.
416 if (gtk_socket_id != 0)
417 gtk_widget_grab_focus(gui.drawarea);
418
419 return TRUE;
420 }
421 #endif // FEAT_TOOLBAR
422
423 #if defined(FEAT_TOOLBAR) || defined(PROTO)
424
425 void
gui_gtk_register_stock_icons(void)426 gui_gtk_register_stock_icons(void)
427 {
428 # ifndef USE_GRESOURCE
429 # include "../pixmaps/stock_icons.h"
430 GtkIconFactory *factory;
431
432 factory = gtk_icon_factory_new();
433 # define ADD_ICON(Name, Data) add_stock_icon(factory, Name, Data, (int)sizeof(Data))
434
435 ADD_ICON("vim-build-tags", stock_vim_build_tags);
436 ADD_ICON("vim-find-help", stock_vim_find_help);
437 ADD_ICON("vim-save-all", stock_vim_save_all);
438 ADD_ICON("vim-session-load", stock_vim_session_load);
439 ADD_ICON("vim-session-new", stock_vim_session_new);
440 ADD_ICON("vim-session-save", stock_vim_session_save);
441 ADD_ICON("vim-shell", stock_vim_shell);
442 ADD_ICON("vim-window-maximize", stock_vim_window_maximize);
443 ADD_ICON("vim-window-maximize-width", stock_vim_window_maximize_width);
444 ADD_ICON("vim-window-minimize", stock_vim_window_minimize);
445 ADD_ICON("vim-window-minimize-width", stock_vim_window_minimize_width);
446 ADD_ICON("vim-window-split", stock_vim_window_split);
447 ADD_ICON("vim-window-split-vertical", stock_vim_window_split_vertical);
448
449 # undef ADD_ICON
450
451 gtk_icon_factory_add_default(factory);
452 g_object_unref(factory);
453 # else // defined(USE_GRESOURCE)
454 const char * const path_prefix = "/org/vim/gui/icon";
455 # if GTK_CHECK_VERSION(3,14,0)
456 GdkScreen *screen = NULL;
457 GtkIconTheme *icon_theme = NULL;
458
459 if (GTK_IS_WIDGET(gui.mainwin))
460 screen = gtk_widget_get_screen(gui.mainwin);
461 else
462 screen = gdk_screen_get_default();
463 icon_theme = gtk_icon_theme_get_for_screen(screen);
464 gtk_icon_theme_add_resource_path(icon_theme, path_prefix);
465 # elif GTK_CHECK_VERSION(3,0,0)
466 IconNames *names;
467
468 for (names = stock_vim_icons; names->icon_name != NULL; names++)
469 {
470 char path[MAXPATHL];
471
472 vim_snprintf(path, MAXPATHL, "%s/%s", path_prefix, names->file_name);
473 GdkPixbuf *pixbuf = NULL;
474 pixbuf = gdk_pixbuf_new_from_resource(path, NULL);
475 if (pixbuf != NULL)
476 {
477 const gint size = MAX(gdk_pixbuf_get_width(pixbuf),
478 gdk_pixbuf_get_height(pixbuf));
479 if (size > 16)
480 {
481 // An icon theme is supposed to provide fixed-size
482 // image files for each size, e.g., 16, 22, 24, ...
483 // Naturally, in contrast to GtkIconSet, GtkIconTheme
484 // won't prepare size variants for us out of a single
485 // fixed-size image.
486 //
487 // Currently, Vim provides 24x24 images only while the
488 // icon size on the menu and the toolbar is set to 16x16
489 // by default.
490 //
491 // Resize them by ourselves until we have our own fully
492 // fledged icon theme.
493 GdkPixbuf *src = pixbuf;
494 pixbuf = gdk_pixbuf_scale_simple(src,
495 16, 16,
496 GDK_INTERP_BILINEAR);
497 if (pixbuf == NULL)
498 pixbuf = src;
499 else
500 g_object_unref(src);
501 }
502 gtk_icon_theme_add_builtin_icon(names->icon_name, size, pixbuf);
503 g_object_unref(pixbuf);
504 }
505 }
506 # else // !GTK_CHECK_VERSION(3,0.0)
507 GtkIconFactory * const factory = gtk_icon_factory_new();
508 IconNames *names;
509
510 for (names = stock_vim_icons; names->icon_name != NULL; names++)
511 {
512 char path[MAXPATHL];
513 GdkPixbuf *pixbuf;
514
515 vim_snprintf(path, MAXPATHL, "%s/%s", path_prefix, names->file_name);
516 pixbuf = gdk_pixbuf_new_from_resource(path, NULL);
517 if (pixbuf != NULL)
518 {
519 GtkIconSet *icon_set = gtk_icon_set_new_from_pixbuf(pixbuf);
520 gtk_icon_factory_add(factory, names->icon_name, icon_set);
521 gtk_icon_set_unref(icon_set);
522 g_object_unref(pixbuf);
523 }
524 }
525
526 gtk_icon_factory_add_default(factory);
527 g_object_unref(factory);
528 # endif // !GTK_CHECK_VERSION(3,0,0)
529 # endif // defined(USE_GRESOURCE)
530 }
531
532 #endif // FEAT_TOOLBAR
533
534 #if defined(FEAT_MENU) || defined(PROTO)
535
536 /*
537 * Translate Vim's mnemonic tagging to GTK+ style and convert to UTF-8
538 * if necessary. The caller must vim_free() the returned string.
539 *
540 * Input Output
541 * _ __
542 * && &
543 * & _ stripped if use_mnemonic == FALSE
544 * <Tab> end of menu label text
545 */
546 static char_u *
translate_mnemonic_tag(char_u * name,int use_mnemonic)547 translate_mnemonic_tag(char_u *name, int use_mnemonic)
548 {
549 char_u *buf;
550 char_u *psrc;
551 char_u *pdest;
552 int n_underscores = 0;
553
554 name = CONVERT_TO_UTF8(name);
555 if (name == NULL)
556 return NULL;
557
558 for (psrc = name; *psrc != NUL && *psrc != TAB; ++psrc)
559 if (*psrc == '_')
560 ++n_underscores;
561
562 buf = alloc(psrc - name + n_underscores + 1);
563 if (buf != NULL)
564 {
565 pdest = buf;
566 for (psrc = name; *psrc != NUL && *psrc != TAB; ++psrc)
567 {
568 if (*psrc == '_')
569 {
570 *pdest++ = '_';
571 *pdest++ = '_';
572 }
573 else if (*psrc != '&')
574 {
575 *pdest++ = *psrc;
576 }
577 else if (*(psrc + 1) == '&')
578 {
579 *pdest++ = *psrc++;
580 }
581 else if (use_mnemonic)
582 {
583 *pdest++ = '_';
584 }
585 }
586 *pdest = NUL;
587 }
588
589 CONVERT_TO_UTF8_FREE(name);
590 return buf;
591 }
592
593 static void
menu_item_new(vimmenu_T * menu,GtkWidget * parent_widget)594 menu_item_new(vimmenu_T *menu, GtkWidget *parent_widget)
595 {
596 GtkWidget *box;
597 char_u *text;
598 int use_mnemonic;
599
600 // It would be neat to have image menu items, but that would require major
601 // changes to Vim's menu system. Not to mention that all the translations
602 // had to be updated.
603 menu->id = gtk_menu_item_new();
604 # if GTK_CHECK_VERSION(3,2,0)
605 box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 20);
606 gtk_box_set_homogeneous(GTK_BOX(box), FALSE);
607 # else
608 box = gtk_hbox_new(FALSE, 20);
609 # endif
610
611 use_mnemonic = (p_wak[0] != 'n' || !GTK_IS_MENU_BAR(parent_widget));
612 text = translate_mnemonic_tag(menu->name, use_mnemonic);
613
614 menu->label = gtk_label_new_with_mnemonic((const char *)text);
615 vim_free(text);
616
617 gtk_box_pack_start(GTK_BOX(box), menu->label, FALSE, FALSE, 0);
618
619 if (menu->actext != NULL && menu->actext[0] != NUL)
620 {
621 text = CONVERT_TO_UTF8(menu->actext);
622
623 gtk_box_pack_end(GTK_BOX(box),
624 gtk_label_new((const char *)text),
625 FALSE, FALSE, 0);
626
627 CONVERT_TO_UTF8_FREE(text);
628 }
629
630 gtk_container_add(GTK_CONTAINER(menu->id), box);
631 gtk_widget_show_all(menu->id);
632 }
633
634 void
gui_mch_add_menu(vimmenu_T * menu,int idx)635 gui_mch_add_menu(vimmenu_T *menu, int idx)
636 {
637 vimmenu_T *parent;
638 GtkWidget *parent_widget;
639
640 if (menu->name[0] == ']' || menu_is_popup(menu->name))
641 {
642 menu->submenu_id = gtk_menu_new();
643 return;
644 }
645
646 parent = menu->parent;
647
648 if ((parent != NULL && parent->submenu_id == NULL)
649 || !menu_is_menubar(menu->name))
650 return;
651
652 parent_widget = (parent != NULL) ? parent->submenu_id : gui.menubar;
653 menu_item_new(menu, parent_widget);
654
655 # if !GTK_CHECK_VERSION(3,4,0)
656 // since the tearoff should always appear first, increment idx
657 if (parent != NULL && !menu_is_popup(parent->name))
658 ++idx;
659 # endif
660
661 gtk_menu_shell_insert(GTK_MENU_SHELL(parent_widget), menu->id, idx);
662
663 menu->submenu_id = gtk_menu_new();
664
665 gtk_menu_set_accel_group(GTK_MENU(menu->submenu_id), gui.accel_group);
666 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu->id), menu->submenu_id);
667
668 # if !GTK_CHECK_VERSION(3,4,0)
669 menu->tearoff_handle = gtk_tearoff_menu_item_new();
670 if (vim_strchr(p_go, GO_TEAROFF) != NULL)
671 gtk_widget_show(menu->tearoff_handle);
672 # if GTK_CHECK_VERSION(3,0,0)
673 gtk_menu_shell_prepend(GTK_MENU_SHELL(menu->submenu_id),
674 menu->tearoff_handle);
675 # else
676 gtk_menu_prepend(GTK_MENU(menu->submenu_id), menu->tearoff_handle);
677 # endif
678 # endif
679 }
680
681 static void
menu_item_activate(GtkWidget * widget UNUSED,gpointer data)682 menu_item_activate(GtkWidget *widget UNUSED, gpointer data)
683 {
684 gui_menu_cb((vimmenu_T *)data);
685 }
686
687 static void
menu_item_select(GtkWidget * widget UNUSED,gpointer data)688 menu_item_select(GtkWidget *widget UNUSED, gpointer data)
689 {
690 vimmenu_T *menu;
691 char_u *tooltip;
692 static int did_msg = FALSE;
693
694 if (State & CMDLINE)
695 return;
696 menu = (vimmenu_T *)data;
697 tooltip = CONVERT_TO_UTF8(menu->strings[MENU_INDEX_TIP]);
698 if (tooltip != NULL && utf_valid_string(tooltip, NULL))
699 {
700 msg((char *)tooltip);
701 did_msg = TRUE;
702 setcursor();
703 out_flush_cursor(TRUE, FALSE);
704 }
705 else if (did_msg)
706 {
707 msg("");
708 did_msg = FALSE;
709 setcursor();
710 out_flush_cursor(TRUE, FALSE);
711 }
712 CONVERT_TO_UTF8_FREE(tooltip);
713 }
714
715 void
gui_mch_add_menu_item(vimmenu_T * menu,int idx)716 gui_mch_add_menu_item(vimmenu_T *menu, int idx)
717 {
718 vimmenu_T *parent;
719
720 parent = menu->parent;
721
722 # ifdef FEAT_TOOLBAR
723 if (menu_is_toolbar(parent->name))
724 {
725 GtkToolbar *toolbar;
726
727 toolbar = GTK_TOOLBAR(gui.toolbar);
728 menu->submenu_id = NULL;
729
730 if (menu_is_separator(menu->name))
731 {
732 # if GTK_CHECK_VERSION(3,0,0)
733 GtkToolItem *item = gtk_separator_tool_item_new();
734 gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(item),
735 TRUE);
736 gtk_tool_item_set_expand(GTK_TOOL_ITEM(item), FALSE);
737 gtk_widget_show(GTK_WIDGET(item));
738
739 gtk_toolbar_insert(toolbar, item, idx);
740 # else
741 gtk_toolbar_insert_space(toolbar, idx);
742 # endif
743 menu->id = NULL;
744 }
745 else
746 {
747 char_u *text;
748 char_u *tooltip;
749
750 text = CONVERT_TO_UTF8(menu->dname);
751 tooltip = CONVERT_TO_UTF8(menu->strings[MENU_INDEX_TIP]);
752 if (tooltip != NULL && !utf_valid_string(tooltip, NULL))
753 // Invalid text, can happen when 'encoding' is changed. Avoid
754 // a nasty GTK error message, skip the tooltip.
755 CONVERT_TO_UTF8_FREE(tooltip);
756
757 # if GTK_CHECK_VERSION(3,0,0)
758 {
759 GtkWidget *icon;
760 GtkToolItem *item;
761
762 icon = create_menu_icon(menu,
763 gtk_toolbar_get_icon_size(toolbar));
764 item = gtk_tool_button_new(icon, (const gchar *)text);
765 gtk_tool_item_set_tooltip_text(item, (const gchar *)tooltip);
766 g_signal_connect(G_OBJECT(item), "clicked",
767 G_CALLBACK(&menu_item_activate), menu);
768 gtk_widget_show_all(GTK_WIDGET(item));
769
770 gtk_toolbar_insert(toolbar, item, idx);
771
772 menu->id = GTK_WIDGET(item);
773 }
774 # else
775 menu->id = gtk_toolbar_insert_item(
776 toolbar,
777 (const char *)text,
778 (const char *)tooltip,
779 NULL,
780 create_menu_icon(menu, gtk_toolbar_get_icon_size(toolbar)),
781 G_CALLBACK(&menu_item_activate),
782 menu,
783 idx);
784 # endif
785
786 if (gtk_socket_id != 0)
787 g_signal_connect(G_OBJECT(menu->id), "focus-in-event",
788 G_CALLBACK(toolbar_button_focus_in_event), NULL);
789
790 CONVERT_TO_UTF8_FREE(text);
791 CONVERT_TO_UTF8_FREE(tooltip);
792 }
793 }
794 else
795 # endif // FEAT_TOOLBAR
796 {
797 // No parent, must be a non-menubar menu
798 if (parent == NULL || parent->submenu_id == NULL)
799 return;
800
801 # if !GTK_CHECK_VERSION(3,4,0)
802 // Make place for the possible tearoff handle item. Not in the popup
803 // menu, it doesn't have a tearoff item.
804 if (!menu_is_popup(parent->name))
805 ++idx;
806 # endif
807
808 if (menu_is_separator(menu->name))
809 {
810 // Separator: Just add it
811 # if GTK_CHECK_VERSION(3,0,0)
812 menu->id = gtk_separator_menu_item_new();
813 # else
814 menu->id = gtk_menu_item_new();
815 gtk_widget_set_sensitive(menu->id, FALSE);
816 # endif
817 gtk_widget_show(menu->id);
818 gtk_menu_shell_insert(GTK_MENU_SHELL(parent->submenu_id),
819 menu->id, idx);
820
821 return;
822 }
823
824 // Add textual menu item.
825 menu_item_new(menu, parent->submenu_id);
826 gtk_widget_show(menu->id);
827 gtk_menu_shell_insert(GTK_MENU_SHELL(parent->submenu_id),
828 menu->id, idx);
829
830 if (menu->id != NULL)
831 {
832 g_signal_connect(G_OBJECT(menu->id), "activate",
833 G_CALLBACK(menu_item_activate), menu);
834 g_signal_connect(G_OBJECT(menu->id), "select",
835 G_CALLBACK(menu_item_select), menu);
836 }
837 }
838 }
839 #endif // FEAT_MENU
840
841
842 void
gui_mch_set_text_area_pos(int x,int y,int w,int h)843 gui_mch_set_text_area_pos(int x, int y, int w, int h)
844 {
845 gui_gtk_form_move_resize(GTK_FORM(gui.formwin), gui.drawarea, x, y, w, h);
846 }
847
848
849 #if defined(FEAT_MENU) || defined(PROTO)
850 /*
851 * Enable or disable accelerators for the toplevel menus.
852 */
853 void
gui_gtk_set_mnemonics(int enable)854 gui_gtk_set_mnemonics(int enable)
855 {
856 vimmenu_T *menu;
857 char_u *name;
858
859 FOR_ALL_MENUS(menu)
860 {
861 if (menu->id == NULL)
862 continue;
863
864 name = translate_mnemonic_tag(menu->name, enable);
865 gtk_label_set_text_with_mnemonic(GTK_LABEL(menu->label),
866 (const char *)name);
867 vim_free(name);
868 }
869 }
870
871 # if !GTK_CHECK_VERSION(3,4,0)
872 static void
recurse_tearoffs(vimmenu_T * menu,int val)873 recurse_tearoffs(vimmenu_T *menu, int val)
874 {
875 for (; menu != NULL; menu = menu->next)
876 {
877 if (menu->submenu_id != NULL && menu->tearoff_handle != NULL
878 && menu->name[0] != ']' && !menu_is_popup(menu->name))
879 {
880 if (val)
881 gtk_widget_show(menu->tearoff_handle);
882 else
883 gtk_widget_hide(menu->tearoff_handle);
884 }
885 recurse_tearoffs(menu->children, val);
886 }
887 }
888 # endif
889
890 # if GTK_CHECK_VERSION(3,4,0)
891 void
gui_mch_toggle_tearoffs(int enable UNUSED)892 gui_mch_toggle_tearoffs(int enable UNUSED)
893 {
894 // Do nothing
895 }
896 # else
897 void
gui_mch_toggle_tearoffs(int enable)898 gui_mch_toggle_tearoffs(int enable)
899 {
900 recurse_tearoffs(root_menu, enable);
901 }
902 # endif
903 #endif // FEAT_MENU
904
905 #if defined(FEAT_TOOLBAR)
906 static int
get_menu_position(vimmenu_T * menu)907 get_menu_position(vimmenu_T *menu)
908 {
909 vimmenu_T *node;
910 int idx = 0;
911
912 for (node = menu->parent->children; node != menu; node = node->next)
913 {
914 g_return_val_if_fail(node != NULL, -1);
915 ++idx;
916 }
917
918 return idx;
919 }
920 #endif // FEAT_TOOLBAR
921
922
923 #if defined(FEAT_TOOLBAR) || defined(PROTO)
924 void
gui_mch_menu_set_tip(vimmenu_T * menu)925 gui_mch_menu_set_tip(vimmenu_T *menu)
926 {
927 if (menu->id != NULL && menu->parent != NULL && gui.toolbar != NULL)
928 {
929 char_u *tooltip;
930
931 tooltip = CONVERT_TO_UTF8(menu->strings[MENU_INDEX_TIP]);
932 if (tooltip != NULL && utf_valid_string(tooltip, NULL))
933 # if GTK_CHECK_VERSION(3,0,0)
934 // Only set the tooltip when it's valid utf-8.
935 gtk_widget_set_tooltip_text(menu->id, (const gchar *)tooltip);
936 # else
937 // Only set the tooltip when it's valid utf-8.
938 gtk_tooltips_set_tip(GTK_TOOLBAR(gui.toolbar)->tooltips,
939 menu->id, (const char *)tooltip, NULL);
940 # endif
941 CONVERT_TO_UTF8_FREE(tooltip);
942 }
943 }
944 #endif // FEAT_TOOLBAR
945
946
947 #if defined(FEAT_MENU) || defined(PROTO)
948 /*
949 * Destroy the machine specific menu widget.
950 */
951 void
gui_mch_destroy_menu(vimmenu_T * menu)952 gui_mch_destroy_menu(vimmenu_T *menu)
953 {
954 // Don't let gtk_container_remove automatically destroy menu->id.
955 if (menu->id != NULL)
956 g_object_ref(menu->id);
957
958 // Workaround for a spurious gtk warning in Ubuntu: "Trying to remove
959 // a child that doesn't believe we're its parent."
960 // Remove widget from gui.menubar before destroying it.
961 if (menu->id != NULL && gui.menubar != NULL
962 && gtk_widget_get_parent(menu->id) == gui.menubar)
963 gtk_container_remove(GTK_CONTAINER(gui.menubar), menu->id);
964
965 # ifdef FEAT_TOOLBAR
966 if (menu->parent != NULL && menu_is_toolbar(menu->parent->name))
967 {
968 if (menu_is_separator(menu->name))
969 # if GTK_CHECK_VERSION(3,0,0)
970 {
971 GtkToolItem *item = NULL;
972
973 item = gtk_toolbar_get_nth_item(GTK_TOOLBAR(gui.toolbar),
974 get_menu_position(menu));
975 if (item != NULL)
976 gtk_container_remove(GTK_CONTAINER(gui.toolbar),
977 GTK_WIDGET(item));
978 }
979 # else
980 gtk_toolbar_remove_space(GTK_TOOLBAR(gui.toolbar),
981 get_menu_position(menu));
982 # endif
983 else if (menu->id != NULL)
984 gtk_widget_destroy(menu->id);
985 }
986 else
987 # endif // FEAT_TOOLBAR
988 {
989 if (menu->submenu_id != NULL)
990 gtk_widget_destroy(menu->submenu_id);
991
992 if (menu->id != NULL)
993 gtk_widget_destroy(menu->id);
994 }
995
996 if (menu->id != NULL)
997 g_object_unref(menu->id);
998 menu->submenu_id = NULL;
999 menu->id = NULL;
1000 }
1001 #endif // FEAT_MENU
1002
1003
1004 /*
1005 * Scrollbar stuff.
1006 */
1007 void
gui_mch_set_scrollbar_thumb(scrollbar_T * sb,long val,long size,long max)1008 gui_mch_set_scrollbar_thumb(scrollbar_T *sb, long val, long size, long max)
1009 {
1010 if (sb->id != NULL)
1011 {
1012 GtkAdjustment *adjustment;
1013
1014 // ignore events triggered by moving the thumb (happens in GTK 3)
1015 ++hold_gui_events;
1016
1017 adjustment = gtk_range_get_adjustment(GTK_RANGE(sb->id));
1018
1019 gtk_adjustment_set_lower(adjustment, 0.0);
1020 gtk_adjustment_set_value(adjustment, val);
1021 gtk_adjustment_set_upper(adjustment, max + 1);
1022 gtk_adjustment_set_page_size(adjustment, size);
1023 gtk_adjustment_set_page_increment(adjustment,
1024 size < 3L ? 1L : size - 2L);
1025 gtk_adjustment_set_step_increment(adjustment, 1.0);
1026
1027 g_signal_handler_block(G_OBJECT(adjustment), (gulong)sb->handler_id);
1028
1029 --hold_gui_events;
1030
1031 #if !GTK_CHECK_VERSION(3,18,0)
1032 gtk_adjustment_changed(adjustment);
1033 #endif
1034
1035 g_signal_handler_unblock(G_OBJECT(adjustment),
1036 (gulong)sb->handler_id);
1037 }
1038 }
1039
1040 void
gui_mch_set_scrollbar_pos(scrollbar_T * sb,int x,int y,int w,int h)1041 gui_mch_set_scrollbar_pos(scrollbar_T *sb, int x, int y, int w, int h)
1042 {
1043 if (sb->id != NULL)
1044 gui_gtk_form_move_resize(GTK_FORM(gui.formwin), sb->id, x, y, w, h);
1045 }
1046
1047 int
gui_mch_get_scrollbar_xpadding(void)1048 gui_mch_get_scrollbar_xpadding(void)
1049 {
1050 int xpad;
1051 #if GTK_CHECK_VERSION(3,0,0)
1052 xpad = gtk_widget_get_allocated_width(gui.formwin)
1053 - gtk_widget_get_allocated_width(gui.drawarea) - gui.scrollbar_width;
1054 #else
1055 xpad = gui.formwin->allocation.width - gui.drawarea->allocation.width
1056 - gui.scrollbar_width;
1057 #endif
1058 if (gui.which_scrollbars[SBAR_LEFT] && gui.which_scrollbars[SBAR_RIGHT])
1059 xpad -= gui.scrollbar_width;
1060
1061 return (xpad < 0) ? 0 : xpad;
1062 }
1063
1064 int
gui_mch_get_scrollbar_ypadding(void)1065 gui_mch_get_scrollbar_ypadding(void)
1066 {
1067 int ypad;
1068 #if GTK_CHECK_VERSION(3,0,0)
1069 ypad = gtk_widget_get_allocated_height(gui.formwin)
1070 - gtk_widget_get_allocated_height(gui.drawarea) - gui.scrollbar_height;
1071 #else
1072 ypad = gui.formwin->allocation.height - gui.drawarea->allocation.height
1073 - gui.scrollbar_height;
1074 #endif
1075 return (ypad < 0) ? 0 : ypad;
1076 }
1077
1078 /*
1079 * Take action upon scrollbar dragging.
1080 */
1081 static void
adjustment_value_changed(GtkAdjustment * adjustment,gpointer data)1082 adjustment_value_changed(GtkAdjustment *adjustment, gpointer data)
1083 {
1084 scrollbar_T *sb;
1085 long value;
1086 int dragging = FALSE;
1087
1088 #ifdef FEAT_XIM
1089 // cancel any preediting
1090 if (im_is_preediting())
1091 xim_reset();
1092 #endif
1093
1094 sb = gui_find_scrollbar((long)data);
1095 value = gtk_adjustment_get_value(adjustment);
1096 #if !GTK_CHECK_VERSION(3,0,0)
1097 /*
1098 * The dragging argument must be right for the scrollbar to work with
1099 * closed folds. This isn't documented, hopefully this will keep on
1100 * working in later GTK versions.
1101 *
1102 * FIXME: Well, it doesn't work in GTK2. :)
1103 * HACK: Get the mouse pointer position, if it appears to be on an arrow
1104 * button set "dragging" to FALSE. This assumes square buttons!
1105 */
1106 if (sb != NULL)
1107 {
1108 dragging = TRUE;
1109
1110 if (sb->wp != NULL)
1111 {
1112 int x;
1113 int y;
1114 GdkModifierType state;
1115 int width;
1116 int height;
1117
1118 // vertical scrollbar: need to set "dragging" properly in case
1119 // there are closed folds.
1120 gdk_window_get_pointer(sb->id->window, &x, &y, &state);
1121 gdk_window_get_size(sb->id->window, &width, &height);
1122 if (x >= 0 && x < width && y >= 0 && y < height)
1123 {
1124 if (y < width)
1125 {
1126 // up arrow: move one (closed fold) line up
1127 dragging = FALSE;
1128 value = sb->wp->w_topline - 2;
1129 }
1130 else if (y > height - width)
1131 {
1132 // down arrow: move one (closed fold) line down
1133 dragging = FALSE;
1134 value = sb->wp->w_topline;
1135 }
1136 }
1137 }
1138 }
1139 #endif // !GTK_CHECK_VERSION(3,0,0)
1140 gui_drag_scrollbar(sb, value, dragging);
1141 }
1142
1143 // SBAR_VERT or SBAR_HORIZ
1144 void
gui_mch_create_scrollbar(scrollbar_T * sb,int orient)1145 gui_mch_create_scrollbar(scrollbar_T *sb, int orient)
1146 {
1147 if (orient == SBAR_HORIZ)
1148 #if GTK_CHECK_VERSION(3,2,0)
1149 sb->id = gtk_scrollbar_new(GTK_ORIENTATION_HORIZONTAL, NULL);
1150 #else
1151 sb->id = gtk_hscrollbar_new(NULL);
1152 #endif
1153 else if (orient == SBAR_VERT)
1154 #if GTK_CHECK_VERSION(3,2,0)
1155 sb->id = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, NULL);
1156 #else
1157 sb->id = gtk_vscrollbar_new(NULL);
1158 #endif
1159
1160 if (sb->id != NULL)
1161 {
1162 GtkAdjustment *adjustment;
1163
1164 gtk_widget_set_can_focus(sb->id, FALSE);
1165 gui_gtk_form_put(GTK_FORM(gui.formwin), sb->id, 0, 0);
1166
1167 adjustment = gtk_range_get_adjustment(GTK_RANGE(sb->id));
1168
1169 sb->handler_id = g_signal_connect(
1170 G_OBJECT(adjustment), "value-changed",
1171 G_CALLBACK(adjustment_value_changed),
1172 GINT_TO_POINTER(sb->ident));
1173 gui_mch_update();
1174 }
1175 }
1176
1177 void
gui_mch_destroy_scrollbar(scrollbar_T * sb)1178 gui_mch_destroy_scrollbar(scrollbar_T *sb)
1179 {
1180 if (sb->id != NULL)
1181 {
1182 gtk_widget_destroy(sb->id);
1183 sb->id = NULL;
1184 }
1185 gui_mch_update();
1186 }
1187
1188 #if defined(FEAT_BROWSE) || defined(PROTO)
1189 /*
1190 * Implementation of the file selector related stuff
1191 */
1192
1193 #ifndef USE_FILE_CHOOSER
1194 static void
browse_ok_cb(GtkWidget * widget UNUSED,gpointer cbdata)1195 browse_ok_cb(GtkWidget *widget UNUSED, gpointer cbdata)
1196 {
1197 gui_T *vw = (gui_T *)cbdata;
1198
1199 if (vw->browse_fname != NULL)
1200 g_free(vw->browse_fname);
1201
1202 vw->browse_fname = (char_u *)g_strdup(gtk_file_selection_get_filename(
1203 GTK_FILE_SELECTION(vw->filedlg)));
1204 gtk_widget_hide(vw->filedlg);
1205 }
1206
1207 static void
browse_cancel_cb(GtkWidget * widget UNUSED,gpointer cbdata)1208 browse_cancel_cb(GtkWidget *widget UNUSED, gpointer cbdata)
1209 {
1210 gui_T *vw = (gui_T *)cbdata;
1211
1212 if (vw->browse_fname != NULL)
1213 {
1214 g_free(vw->browse_fname);
1215 vw->browse_fname = NULL;
1216 }
1217 gtk_widget_hide(vw->filedlg);
1218 }
1219
1220 static gboolean
browse_destroy_cb(GtkWidget * widget UNUSED)1221 browse_destroy_cb(GtkWidget *widget UNUSED)
1222 {
1223 if (gui.browse_fname != NULL)
1224 {
1225 g_free(gui.browse_fname);
1226 gui.browse_fname = NULL;
1227 }
1228 gui.filedlg = NULL;
1229 gtk_main_quit();
1230 return FALSE;
1231 }
1232 #endif
1233
1234 /*
1235 * Put up a file requester.
1236 * Returns the selected name in allocated memory, or NULL for Cancel.
1237 * saving, select file to write
1238 * title title for the window
1239 * dflt default name
1240 * ext not used (extension added)
1241 * initdir initial directory, NULL for current dir
1242 * filter not used (file name filter)
1243 */
1244 char_u *
gui_mch_browse(int saving UNUSED,char_u * title,char_u * dflt,char_u * ext UNUSED,char_u * initdir,char_u * filter)1245 gui_mch_browse(int saving UNUSED,
1246 char_u *title,
1247 char_u *dflt,
1248 char_u *ext UNUSED,
1249 char_u *initdir,
1250 char_u *filter)
1251 {
1252 #ifdef USE_FILE_CHOOSER
1253 # if GTK_CHECK_VERSION(3,20,0)
1254 GtkFileChooserNative *fc;
1255 # else
1256 GtkWidget *fc;
1257 # endif
1258 #endif
1259 char_u dirbuf[MAXPATHL];
1260 guint log_handler;
1261 const gchar *domain = "Gtk";
1262
1263 title = CONVERT_TO_UTF8(title);
1264
1265 // GTK has a bug, it only works with an absolute path.
1266 if (initdir == NULL || *initdir == NUL)
1267 mch_dirname(dirbuf, MAXPATHL);
1268 else if (vim_FullName(initdir, dirbuf, MAXPATHL - 2, FALSE) == FAIL)
1269 dirbuf[0] = NUL;
1270 // Always need a trailing slash for a directory.
1271 add_pathsep(dirbuf);
1272
1273 // If our pointer is currently hidden, then we should show it.
1274 gui_mch_mousehide(FALSE);
1275
1276 // Hack: The GTK file dialog warns when it can't access a new file, this
1277 // makes it shut up. http://bugzilla.gnome.org/show_bug.cgi?id=664587
1278 log_handler = g_log_set_handler(domain, G_LOG_LEVEL_WARNING,
1279 recent_func_log_func, NULL);
1280
1281 #ifdef USE_FILE_CHOOSER
1282 // We create the dialog each time, so that the button text can be "Open"
1283 // or "Save" according to the action.
1284 # if GTK_CHECK_VERSION(3,20,0)
1285 fc = gtk_file_chooser_native_new(
1286 # else
1287 fc = gtk_file_chooser_dialog_new(
1288 # endif
1289 (const gchar *)title,
1290 GTK_WINDOW(gui.mainwin),
1291 saving ? GTK_FILE_CHOOSER_ACTION_SAVE
1292 : GTK_FILE_CHOOSER_ACTION_OPEN,
1293 # if GTK_CHECK_VERSION(3,20,0)
1294 saving ? _("_Save") : _("_Open"), _("_Cancel"));
1295 # else
1296 # if GTK_CHECK_VERSION(3,10,0)
1297 _("_Cancel"), GTK_RESPONSE_CANCEL,
1298 saving ? _("_Save") : _("_Open"), GTK_RESPONSE_ACCEPT,
1299 # else
1300 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1301 saving ? GTK_STOCK_SAVE : GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1302 # endif
1303 NULL);
1304 # endif
1305 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc),
1306 (const gchar *)dirbuf);
1307
1308 if (filter != NULL && *filter != NUL)
1309 {
1310 int i = 0;
1311 char_u *patt;
1312 char_u *p = filter;
1313 GtkFileFilter *gfilter;
1314
1315 gfilter = gtk_file_filter_new();
1316 patt = alloc(STRLEN(filter));
1317 while (p != NULL && *p != NUL)
1318 {
1319 if (*p == '\n' || *p == ';' || *p == '\t')
1320 {
1321 STRNCPY(patt, filter, i);
1322 patt[i] = '\0';
1323 if (*p == '\t')
1324 gtk_file_filter_set_name(gfilter, (gchar *)patt);
1325 else
1326 {
1327 gtk_file_filter_add_pattern(gfilter, (gchar *)patt);
1328 if (*p == '\n')
1329 {
1330 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fc),
1331 gfilter);
1332 if (*(p + 1) != NUL)
1333 gfilter = gtk_file_filter_new();
1334 }
1335 }
1336 filter = ++p;
1337 i = 0;
1338 }
1339 else
1340 {
1341 p++;
1342 i++;
1343 }
1344 }
1345 vim_free(patt);
1346 }
1347 if (saving && dflt != NULL && *dflt != NUL)
1348 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(fc), (char *)dflt);
1349
1350 gui.browse_fname = NULL;
1351 # if GTK_CHECK_VERSION(3,20,0)
1352 if (gtk_native_dialog_run(GTK_NATIVE_DIALOG(fc)) == GTK_RESPONSE_ACCEPT)
1353 # else
1354 if (gtk_dialog_run(GTK_DIALOG(fc)) == GTK_RESPONSE_ACCEPT)
1355 #endif
1356 {
1357 char *filename;
1358
1359 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fc));
1360 gui.browse_fname = (char_u *)g_strdup(filename);
1361 g_free(filename);
1362 }
1363 # if GTK_CHECK_VERSION(3,20,0)
1364 g_object_unref(fc);
1365 # else
1366 gtk_widget_destroy(GTK_WIDGET(fc));
1367 # endif
1368
1369 #else // !USE_FILE_CHOOSER
1370
1371 if (gui.filedlg == NULL)
1372 {
1373 GtkFileSelection *fs; // shortcut
1374
1375 gui.filedlg = gtk_file_selection_new((const gchar *)title);
1376 gtk_window_set_modal(GTK_WINDOW(gui.filedlg), TRUE);
1377 gtk_window_set_transient_for(GTK_WINDOW(gui.filedlg),
1378 GTK_WINDOW(gui.mainwin));
1379 fs = GTK_FILE_SELECTION(gui.filedlg);
1380
1381 gtk_container_border_width(GTK_CONTAINER(fs), 4);
1382
1383 gtk_signal_connect(GTK_OBJECT(fs->ok_button),
1384 "clicked", GTK_SIGNAL_FUNC(browse_ok_cb), &gui);
1385 gtk_signal_connect(GTK_OBJECT(fs->cancel_button),
1386 "clicked", GTK_SIGNAL_FUNC(browse_cancel_cb), &gui);
1387 // gtk_signal_connect() doesn't work for destroy, it causes a hang
1388 gtk_signal_connect_object(GTK_OBJECT(gui.filedlg),
1389 "destroy", GTK_SIGNAL_FUNC(browse_destroy_cb),
1390 GTK_OBJECT(gui.filedlg));
1391 }
1392 else
1393 gtk_window_set_title(GTK_WINDOW(gui.filedlg), (const gchar *)title);
1394
1395 // Concatenate "initdir" and "dflt".
1396 if (dflt != NULL && *dflt != NUL
1397 && STRLEN(dirbuf) + 2 + STRLEN(dflt) < MAXPATHL)
1398 STRCAT(dirbuf, dflt);
1399
1400 gtk_file_selection_set_filename(GTK_FILE_SELECTION(gui.filedlg),
1401 (const gchar *)dirbuf);
1402
1403 gtk_widget_show(gui.filedlg);
1404 gtk_main();
1405 #endif // !USE_FILE_CHOOSER
1406 g_log_remove_handler(domain, log_handler);
1407
1408 CONVERT_TO_UTF8_FREE(title);
1409 if (gui.browse_fname == NULL)
1410 return NULL;
1411
1412 // shorten the file name if possible
1413 return vim_strsave(shorten_fname1(gui.browse_fname));
1414 }
1415
1416 /*
1417 * Put up a directory selector
1418 * Returns the selected name in allocated memory, or NULL for Cancel.
1419 * title title for the window
1420 * dflt default name
1421 * initdir initial directory, NULL for current dir
1422 */
1423 char_u *
gui_mch_browsedir(char_u * title,char_u * initdir)1424 gui_mch_browsedir(
1425 char_u *title,
1426 char_u *initdir)
1427 {
1428 # if defined(GTK_FILE_CHOOSER) // Only in GTK 2.4 and later.
1429 char_u dirbuf[MAXPATHL];
1430 char_u *p;
1431 GtkWidget *dirdlg; // file selection dialog
1432 char_u *dirname = NULL;
1433
1434 title = CONVERT_TO_UTF8(title);
1435
1436 dirdlg = gtk_file_chooser_dialog_new(
1437 (const gchar *)title,
1438 GTK_WINDOW(gui.mainwin),
1439 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
1440 # if GTK_CHECK_VERSION(3,10,0)
1441 _("_Cancel"), GTK_RESPONSE_CANCEL,
1442 _("_OK"), GTK_RESPONSE_ACCEPT,
1443 # else
1444 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1445 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1446 # endif
1447 NULL);
1448
1449 CONVERT_TO_UTF8_FREE(title);
1450
1451 // if our pointer is currently hidden, then we should show it.
1452 gui_mch_mousehide(FALSE);
1453
1454 // GTK appears to insist on an absolute path.
1455 if (initdir == NULL || *initdir == NUL
1456 || vim_FullName(initdir, dirbuf, MAXPATHL - 10, FALSE) == FAIL)
1457 mch_dirname(dirbuf, MAXPATHL - 10);
1458
1459 // Always need a trailing slash for a directory.
1460 // Also add a dummy file name, so that we get to the directory.
1461 add_pathsep(dirbuf);
1462 STRCAT(dirbuf, "@zd(*&1|");
1463 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dirdlg),
1464 (const gchar *)dirbuf);
1465
1466 // Run the dialog.
1467 if (gtk_dialog_run(GTK_DIALOG(dirdlg)) == GTK_RESPONSE_ACCEPT)
1468 dirname = (char_u *)gtk_file_chooser_get_filename(
1469 GTK_FILE_CHOOSER(dirdlg));
1470 gtk_widget_destroy(dirdlg);
1471 if (dirname == NULL)
1472 return NULL;
1473
1474 // shorten the file name if possible
1475 p = vim_strsave(shorten_fname1(dirname));
1476 g_free(dirname);
1477 return p;
1478
1479 # else // !defined(GTK_FILE_CHOOSER)
1480 // For GTK 2.2 and earlier: fall back to ordinary file selector.
1481 return gui_mch_browse(0, title, NULL, NULL, initdir, NULL);
1482 # endif // !defined(GTK_FILE_CHOOSER)
1483 }
1484
1485
1486 #endif // FEAT_BROWSE
1487
1488 #if defined(FEAT_GUI_DIALOG) || defined(PROTO)
1489
1490 static GtkWidget *
create_message_dialog(int type,char_u * title,char_u * message)1491 create_message_dialog(int type, char_u *title, char_u *message)
1492 {
1493 GtkWidget *dialog;
1494 GtkMessageType message_type;
1495
1496 switch (type)
1497 {
1498 case VIM_ERROR: message_type = GTK_MESSAGE_ERROR; break;
1499 case VIM_WARNING: message_type = GTK_MESSAGE_WARNING; break;
1500 case VIM_QUESTION: message_type = GTK_MESSAGE_QUESTION; break;
1501 default: message_type = GTK_MESSAGE_INFO; break;
1502 }
1503
1504 message = CONVERT_TO_UTF8(message);
1505 dialog = gtk_message_dialog_new(GTK_WINDOW(gui.mainwin),
1506 GTK_DIALOG_DESTROY_WITH_PARENT,
1507 message_type,
1508 GTK_BUTTONS_NONE,
1509 "%s", (const char *)message);
1510 CONVERT_TO_UTF8_FREE(message);
1511
1512 if (title != NULL)
1513 {
1514 title = CONVERT_TO_UTF8(title);
1515 gtk_window_set_title(GTK_WINDOW(dialog), (const char *)title);
1516 CONVERT_TO_UTF8_FREE(title);
1517 }
1518 else if (type == VIM_GENERIC)
1519 {
1520 gtk_window_set_title(GTK_WINDOW(dialog), "VIM");
1521 }
1522
1523 return dialog;
1524 }
1525
1526 /*
1527 * Split up button_string into individual button labels by inserting
1528 * NUL bytes. Also replace the Vim-style mnemonic accelerator prefix
1529 * '&' with '_'. button_string must point to allocated memory!
1530 * Return an allocated array of pointers into button_string.
1531 */
1532 static char **
split_button_string(char_u * button_string,int * n_buttons)1533 split_button_string(char_u *button_string, int *n_buttons)
1534 {
1535 char **array;
1536 char_u *p;
1537 unsigned int count = 1;
1538
1539 for (p = button_string; *p != NUL; ++p)
1540 if (*p == DLG_BUTTON_SEP)
1541 ++count;
1542
1543 array = ALLOC_MULT(char *, count + 1);
1544 count = 0;
1545
1546 if (array != NULL)
1547 {
1548 array[count++] = (char *)button_string;
1549 for (p = button_string; *p != NUL; )
1550 {
1551 if (*p == DLG_BUTTON_SEP)
1552 {
1553 *p++ = NUL;
1554 array[count++] = (char *)p;
1555 }
1556 else if (*p == DLG_HOTKEY_CHAR)
1557 *p++ = '_';
1558 else
1559 MB_PTR_ADV(p);
1560 }
1561 array[count] = NULL; // currently not relied upon, but doesn't hurt
1562 }
1563
1564 *n_buttons = count;
1565 return array;
1566 }
1567
1568 static char **
split_button_translation(const char * message)1569 split_button_translation(const char *message)
1570 {
1571 char **buttons = NULL;
1572 char_u *str;
1573 int n_buttons = 0;
1574 int n_expected = 1;
1575
1576 for (str = (char_u *)message; *str != NUL; ++str)
1577 if (*str == DLG_BUTTON_SEP)
1578 ++n_expected;
1579
1580 str = (char_u *)_(message);
1581 if (str != NULL)
1582 {
1583 if (output_conv.vc_type != CONV_NONE)
1584 str = string_convert(&output_conv, str, NULL);
1585 else
1586 str = vim_strsave(str);
1587
1588 if (str != NULL)
1589 buttons = split_button_string(str, &n_buttons);
1590 }
1591 /*
1592 * Uh-oh... this should never ever happen. But we don't wanna crash
1593 * if the translation is broken, thus fall back to the untranslated
1594 * buttons string in case of emergency.
1595 */
1596 if (buttons == NULL || n_buttons != n_expected)
1597 {
1598 vim_free(buttons);
1599 vim_free(str);
1600 buttons = NULL;
1601 str = vim_strsave((char_u *)message);
1602
1603 if (str != NULL)
1604 buttons = split_button_string(str, &n_buttons);
1605 if (buttons == NULL)
1606 vim_free(str);
1607 }
1608
1609 return buttons;
1610 }
1611
1612 static int
button_equal(const char * a,const char * b)1613 button_equal(const char *a, const char *b)
1614 {
1615 while (*a != '\0' && *b != '\0')
1616 {
1617 if (*a == '_' && *++a == '\0')
1618 break;
1619 if (*b == '_' && *++b == '\0')
1620 break;
1621
1622 if (g_unichar_tolower(g_utf8_get_char(a))
1623 != g_unichar_tolower(g_utf8_get_char(b)))
1624 return FALSE;
1625
1626 a = g_utf8_next_char(a);
1627 b = g_utf8_next_char(b);
1628 }
1629
1630 return (*a == '\0' && *b == '\0');
1631 }
1632
1633 static void
dialog_add_buttons(GtkDialog * dialog,char_u * button_string)1634 dialog_add_buttons(GtkDialog *dialog, char_u *button_string)
1635 {
1636 char **ok;
1637 char **ync; // "yes no cancel"
1638 char **buttons;
1639 int n_buttons = 0;
1640 int idx;
1641
1642 button_string = vim_strsave(button_string); // must be writable
1643 if (button_string == NULL)
1644 return;
1645
1646 // Check 'v' flag in 'guioptions': vertical button placement.
1647 if (vim_strchr(p_go, GO_VERTICAL) != NULL)
1648 {
1649 # if GTK_CHECK_VERSION(3,0,0)
1650 // Add GTK+ 3 code if necessary.
1651 // N.B. GTK+ 3 doesn't allow you to access vbox and action_area via
1652 // the C API.
1653 # else
1654 GtkWidget *vbutton_box;
1655
1656 vbutton_box = gtk_vbutton_box_new();
1657 gtk_widget_show(vbutton_box);
1658 gtk_box_pack_end(GTK_BOX(GTK_DIALOG(dialog)->vbox),
1659 vbutton_box, TRUE, FALSE, 0);
1660 // Overrule the "action_area" value, hopefully this works...
1661 GTK_DIALOG(dialog)->action_area = vbutton_box;
1662 # endif
1663 }
1664
1665 /*
1666 * Yes this is ugly, I don't particularly like it either. But doing it
1667 * this way has the compelling advantage that translations need not to
1668 * be touched at all. See below what 'ok' and 'ync' are used for.
1669 */
1670 ok = split_button_translation(N_("&Ok"));
1671 ync = split_button_translation(N_("&Yes\n&No\n&Cancel"));
1672 buttons = split_button_string(button_string, &n_buttons);
1673
1674 /*
1675 * Yes, the buttons are in reversed order to match the GNOME 2 desktop
1676 * environment. Don't hit me -- it's all about consistency.
1677 * Well, apparently somebody changed his mind: with GTK 2.2.4 it works the
1678 * other way around...
1679 */
1680 for (idx = 1; idx <= n_buttons; ++idx)
1681 {
1682 char *label;
1683 char_u *label8;
1684
1685 label = buttons[idx - 1];
1686 /*
1687 * Perform some guesswork to find appropriate stock items for the
1688 * buttons. We have to compare with a sample of the translated
1689 * button string to get things right. Yes, this is hackish :/
1690 *
1691 * But even the common button labels aren't necessarily translated,
1692 * since anyone can create their own dialogs using Vim functions.
1693 * Thus we have to check for those too.
1694 */
1695 if (ok != NULL && ync != NULL) // almost impossible to fail
1696 {
1697 # if GTK_CHECK_VERSION(3,10,0)
1698 if (button_equal(label, ok[0])) label = _("OK");
1699 else if (button_equal(label, ync[0])) label = _("Yes");
1700 else if (button_equal(label, ync[1])) label = _("No");
1701 else if (button_equal(label, ync[2])) label = _("Cancel");
1702 else if (button_equal(label, "Ok")) label = _("OK");
1703 else if (button_equal(label, "Yes")) label = _("Yes");
1704 else if (button_equal(label, "No")) label = _("No");
1705 else if (button_equal(label, "Cancel")) label = _("Cancel");
1706 # else
1707 if (button_equal(label, ok[0])) label = GTK_STOCK_OK;
1708 else if (button_equal(label, ync[0])) label = GTK_STOCK_YES;
1709 else if (button_equal(label, ync[1])) label = GTK_STOCK_NO;
1710 else if (button_equal(label, ync[2])) label = GTK_STOCK_CANCEL;
1711 else if (button_equal(label, "Ok")) label = GTK_STOCK_OK;
1712 else if (button_equal(label, "Yes")) label = GTK_STOCK_YES;
1713 else if (button_equal(label, "No")) label = GTK_STOCK_NO;
1714 else if (button_equal(label, "Cancel")) label = GTK_STOCK_CANCEL;
1715 # endif
1716 }
1717 label8 = CONVERT_TO_UTF8((char_u *)label);
1718 gtk_dialog_add_button(dialog, (const gchar *)label8, idx);
1719 CONVERT_TO_UTF8_FREE(label8);
1720 }
1721
1722 if (ok != NULL)
1723 vim_free(*ok);
1724 if (ync != NULL)
1725 vim_free(*ync);
1726 vim_free(ok);
1727 vim_free(ync);
1728 vim_free(buttons);
1729 vim_free(button_string);
1730 }
1731
1732 /*
1733 * Allow mnemonic accelerators to be activated without pressing <Alt>.
1734 * I'm not sure if it's a wise idea to do this. However, the old GTK+ 1.2
1735 * GUI used to work this way, and I consider the impact on UI consistency
1736 * low enough to justify implementing this as a special Vim feature.
1737 */
1738 typedef struct _DialogInfo
1739 {
1740 int ignore_enter; // no default button, ignore "Enter"
1741 int noalt; // accept accelerators without Alt
1742 GtkDialog *dialog; // Widget of the dialog
1743 } DialogInfo;
1744
1745 static gboolean
dialog_key_press_event_cb(GtkWidget * widget,GdkEventKey * event,gpointer data)1746 dialog_key_press_event_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
1747 {
1748 DialogInfo *di = (DialogInfo *)data;
1749
1750 // Ignore hitting Enter (or Space) when there is no default button.
1751 if (di->ignore_enter && (event->keyval == GDK_Return
1752 || event->keyval == ' '))
1753 return TRUE;
1754 else // A different key was pressed, return to normal behavior
1755 di->ignore_enter = FALSE;
1756
1757 // Close the dialog when hitting "Esc".
1758 if (event->keyval == GDK_Escape)
1759 {
1760 gtk_dialog_response(di->dialog, GTK_RESPONSE_REJECT);
1761 return TRUE;
1762 }
1763
1764 if (di->noalt
1765 && (event->state & gtk_accelerator_get_default_mod_mask()) == 0)
1766 {
1767 return gtk_window_mnemonic_activate(
1768 GTK_WINDOW(widget), event->keyval,
1769 gtk_window_get_mnemonic_modifier(GTK_WINDOW(widget)));
1770 }
1771
1772 return FALSE; // continue emission
1773 }
1774
1775 int
gui_mch_dialog(int type,char_u * title,char_u * message,char_u * buttons,int def_but,char_u * textfield,int ex_cmd UNUSED)1776 gui_mch_dialog(int type, // type of dialog
1777 char_u *title, // title of dialog
1778 char_u *message, // message text
1779 char_u *buttons, // names of buttons
1780 int def_but, // default button
1781 char_u *textfield, // text for textfield or NULL
1782 int ex_cmd UNUSED)
1783 {
1784 GtkWidget *dialog;
1785 GtkWidget *entry = NULL;
1786 char_u *text;
1787 int response;
1788 DialogInfo dialoginfo;
1789
1790 dialog = create_message_dialog(type, title, message);
1791 dialoginfo.dialog = GTK_DIALOG(dialog);
1792 dialog_add_buttons(GTK_DIALOG(dialog), buttons);
1793
1794 if (textfield != NULL)
1795 {
1796 GtkWidget *alignment;
1797
1798 entry = gtk_entry_new();
1799 gtk_widget_show(entry);
1800
1801 // Make Enter work like pressing OK.
1802 gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
1803
1804 text = CONVERT_TO_UTF8(textfield);
1805 gtk_entry_set_text(GTK_ENTRY(entry), (const char *)text);
1806 CONVERT_TO_UTF8_FREE(text);
1807
1808 # if GTK_CHECK_VERSION(3,14,0)
1809 gtk_widget_set_halign(GTK_WIDGET(entry), GTK_ALIGN_CENTER);
1810 gtk_widget_set_valign(GTK_WIDGET(entry), GTK_ALIGN_CENTER);
1811 gtk_widget_set_hexpand(GTK_WIDGET(entry), TRUE);
1812 gtk_widget_set_vexpand(GTK_WIDGET(entry), TRUE);
1813
1814 alignment = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
1815 # else
1816 alignment = gtk_alignment_new((float)0.5, (float)0.5,
1817 (float)1.0, (float)1.0);
1818 # endif
1819 gtk_container_add(GTK_CONTAINER(alignment), entry);
1820 gtk_container_set_border_width(GTK_CONTAINER(alignment), 5);
1821 gtk_widget_show(alignment);
1822
1823 # if GTK_CHECK_VERSION(3,0,0)
1824 {
1825 GtkWidget * const vbox
1826 = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1827 gtk_box_pack_start(GTK_BOX(vbox),
1828 alignment, TRUE, FALSE, 0);
1829 }
1830 # else
1831 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),
1832 alignment, TRUE, FALSE, 0);
1833 # endif
1834 dialoginfo.noalt = FALSE;
1835 }
1836 else
1837 dialoginfo.noalt = TRUE;
1838
1839 // Allow activation of mnemonic accelerators without pressing <Alt> when
1840 // there is no textfield. Handle pressing Esc.
1841 g_signal_connect(G_OBJECT(dialog), "key-press-event",
1842 G_CALLBACK(&dialog_key_press_event_cb), &dialoginfo);
1843
1844 if (def_but > 0)
1845 {
1846 gtk_dialog_set_default_response(GTK_DIALOG(dialog), def_but);
1847 dialoginfo.ignore_enter = FALSE;
1848 }
1849 else
1850 // No default button, ignore pressing Enter.
1851 dialoginfo.ignore_enter = TRUE;
1852
1853 // Show the mouse pointer if it's currently hidden.
1854 gui_mch_mousehide(FALSE);
1855
1856 response = gtk_dialog_run(GTK_DIALOG(dialog));
1857
1858 // GTK_RESPONSE_NONE means the dialog was programmatically destroyed.
1859 if (response != GTK_RESPONSE_NONE)
1860 {
1861 if (response == GTK_RESPONSE_ACCEPT) // Enter pressed
1862 response = def_but;
1863 if (textfield != NULL)
1864 {
1865 text = (char_u *)gtk_entry_get_text(GTK_ENTRY(entry));
1866 text = CONVERT_FROM_UTF8(text);
1867
1868 vim_strncpy(textfield, text, IOSIZE - 1);
1869
1870 CONVERT_FROM_UTF8_FREE(text);
1871 }
1872 gtk_widget_destroy(dialog);
1873 }
1874
1875 return response > 0 ? response : 0;
1876 }
1877
1878 #endif // FEAT_GUI_DIALOG
1879
1880
1881 #if defined(FEAT_MENU) || defined(PROTO)
1882
1883 void
gui_mch_show_popupmenu(vimmenu_T * menu)1884 gui_mch_show_popupmenu(vimmenu_T *menu)
1885 {
1886 # if defined(FEAT_XIM)
1887 /*
1888 * Append a submenu for selecting an input method. This is
1889 * currently the only way to switch input methods at runtime.
1890 */
1891 # if !GTK_CHECK_VERSION(3,10,0)
1892 if (xic != NULL && g_object_get_data(G_OBJECT(menu->submenu_id),
1893 "vim-has-im-menu") == NULL)
1894 {
1895 GtkWidget *menuitem;
1896 GtkWidget *submenu;
1897 char_u *name;
1898
1899 menuitem = gtk_separator_menu_item_new();
1900 gtk_widget_show(menuitem);
1901 gtk_menu_shell_append(GTK_MENU_SHELL(menu->submenu_id), menuitem);
1902
1903 name = (char_u *)_("Input _Methods");
1904 name = CONVERT_TO_UTF8(name);
1905 menuitem = gtk_menu_item_new_with_mnemonic((const char *)name);
1906 CONVERT_TO_UTF8_FREE(name);
1907 gtk_widget_show(menuitem);
1908
1909 submenu = gtk_menu_new();
1910 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
1911 gtk_menu_shell_append(GTK_MENU_SHELL(menu->submenu_id), menuitem);
1912
1913 gtk_im_multicontext_append_menuitems(GTK_IM_MULTICONTEXT(xic),
1914 GTK_MENU_SHELL(submenu));
1915 g_object_set_data(G_OBJECT(menu->submenu_id),
1916 "vim-has-im-menu", GINT_TO_POINTER(TRUE));
1917 }
1918 # endif
1919 # endif // FEAT_XIM
1920
1921 # if GTK_CHECK_VERSION(3,22,2)
1922 {
1923 GdkEventButton trigger;
1924
1925 // A pseudo event to have gtk_menu_popup_at_pointer() work. Since the
1926 // function calculates the popup menu position on the basis of the
1927 // actual pointer position when it is invoked, the fields x, y, x_root
1928 // and y_root are set to zero for convenience.
1929 trigger.type = GDK_BUTTON_PRESS;
1930 trigger.window = gtk_widget_get_window(gui.drawarea);
1931 trigger.send_event = FALSE;
1932 trigger.time = gui.event_time;
1933 trigger.x = 0.0;
1934 trigger.y = 0.0;
1935 trigger.axes = NULL;
1936 trigger.state = 0;
1937 trigger.button = 3;
1938 trigger.device = NULL;
1939 trigger.x_root = 0.0;
1940 trigger.y_root = 0.0;
1941
1942 gtk_menu_popup_at_pointer(GTK_MENU(menu->submenu_id),
1943 (GdkEvent *)&trigger);
1944 }
1945 #else
1946 gtk_menu_popup(GTK_MENU(menu->submenu_id),
1947 NULL, NULL,
1948 (GtkMenuPositionFunc)NULL, NULL,
1949 3U, gui.event_time);
1950 #endif
1951 }
1952
1953 // Ugly global variable to pass "mouse_pos" flag from gui_make_popup() to
1954 // popup_menu_position_func().
1955 static int popup_mouse_pos;
1956
1957 /*
1958 * Menu position callback; used by gui_make_popup() to place the menu
1959 * at the current text cursor position.
1960 *
1961 * Note: The push_in output argument seems to affect scrolling of huge
1962 * menus that don't fit on the screen. Leave it at the default for now.
1963 */
1964 static void
popup_menu_position_func(GtkMenu * menu UNUSED,gint * x,gint * y,gboolean * push_in UNUSED,gpointer user_data UNUSED)1965 popup_menu_position_func(GtkMenu *menu UNUSED,
1966 gint *x, gint *y,
1967 gboolean *push_in UNUSED,
1968 gpointer user_data UNUSED)
1969 {
1970 gdk_window_get_origin(gtk_widget_get_window(gui.drawarea), x, y);
1971
1972 if (popup_mouse_pos)
1973 {
1974 int mx, my;
1975
1976 gui_mch_getmouse(&mx, &my);
1977 *x += mx;
1978 *y += my;
1979 }
1980 else if (curwin != NULL && gui.drawarea != NULL &&
1981 gtk_widget_get_window(gui.drawarea) != NULL)
1982 {
1983 // Find the cursor position in the current window
1984 *x += FILL_X(curwin->w_wincol + curwin->w_wcol + 1) + 1;
1985 *y += FILL_Y(W_WINROW(curwin) + curwin->w_wrow + 1) + 1;
1986 }
1987 }
1988
1989 void
gui_make_popup(char_u * path_name,int mouse_pos)1990 gui_make_popup(char_u *path_name, int mouse_pos)
1991 {
1992 vimmenu_T *menu;
1993
1994 popup_mouse_pos = mouse_pos;
1995
1996 menu = gui_find_menu(path_name);
1997
1998 if (menu != NULL && menu->submenu_id != NULL)
1999 {
2000 # if GTK_CHECK_VERSION(3,22,2)
2001 GdkWindow * const win = gtk_widget_get_window(gui.drawarea);
2002 GdkEventButton trigger;
2003
2004 // A pseudo event to have gtk_menu_popup_at_*() functions work. Since
2005 // the position where the menu pops up is automatically adjusted by
2006 // the functions, none of the fields x, y, x_root and y_root has to be
2007 // set to a specific value here; therefore, they are set to zero for
2008 // convenience.
2009 trigger.type = GDK_BUTTON_PRESS;
2010 trigger.window = win;
2011 trigger.send_event = FALSE;
2012 trigger.time = GDK_CURRENT_TIME;
2013 trigger.x = 0.0;
2014 trigger.y = 0.0;
2015 trigger.axes = NULL;
2016 trigger.state = 0;
2017 trigger.button = 0;
2018 trigger.device = NULL;
2019 trigger.x_root = 0.0;
2020 trigger.y_root = 0.0;
2021
2022 if (mouse_pos)
2023 gtk_menu_popup_at_pointer(GTK_MENU(menu->submenu_id),
2024 (GdkEvent *)&trigger);
2025 else
2026 {
2027 gint origin_x, origin_y;
2028 GdkRectangle rect = { 0, 0, 0, 0 };
2029
2030 gdk_window_get_origin(win, &origin_x, &origin_y);
2031 popup_menu_position_func(NULL, &rect.x, &rect.y, NULL, NULL);
2032
2033 rect.x -= origin_x;
2034 rect.y -= origin_y;
2035
2036 gtk_menu_popup_at_rect(GTK_MENU(menu->submenu_id),
2037 win,
2038 &rect,
2039 GDK_GRAVITY_SOUTH_EAST,
2040 GDK_GRAVITY_NORTH_WEST,
2041 (GdkEvent *)&trigger);
2042 }
2043 # else
2044 gtk_menu_popup(GTK_MENU(menu->submenu_id),
2045 NULL, NULL,
2046 &popup_menu_position_func, NULL,
2047 0U, (guint32)GDK_CURRENT_TIME);
2048 # endif
2049 }
2050 }
2051
2052 #endif // FEAT_MENU
2053
2054
2055 /*
2056 * We don't create it twice.
2057 */
2058
2059 typedef struct _SharedFindReplace
2060 {
2061 GtkWidget *dialog; // the main dialog widget
2062 GtkWidget *wword; // 'Whole word only' check button
2063 GtkWidget *mcase; // 'Match case' check button
2064 GtkWidget *up; // search direction 'Up' radio button
2065 GtkWidget *down; // search direction 'Down' radio button
2066 GtkWidget *what; // 'Find what' entry text widget
2067 GtkWidget *with; // 'Replace with' entry text widget
2068 GtkWidget *find; // 'Find Next' action button
2069 GtkWidget *replace; // 'Replace With' action button
2070 GtkWidget *all; // 'Replace All' action button
2071 } SharedFindReplace;
2072
2073 static SharedFindReplace find_widgets = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
2074 static SharedFindReplace repl_widgets = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
2075
2076 static int
find_key_press_event(GtkWidget * widget UNUSED,GdkEventKey * event,SharedFindReplace * frdp)2077 find_key_press_event(
2078 GtkWidget *widget UNUSED,
2079 GdkEventKey *event,
2080 SharedFindReplace *frdp)
2081 {
2082 // If the user is holding one of the key modifiers we will just bail out,
2083 // thus preserving the possibility of normal focus traversal.
2084 if (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK))
2085 return FALSE;
2086
2087 // the Escape key synthesizes a cancellation action
2088 if (event->keyval == GDK_Escape)
2089 {
2090 gtk_widget_hide(frdp->dialog);
2091
2092 return TRUE;
2093 }
2094
2095 // It would be delightful if it where possible to do search history
2096 // operations on the K_UP and K_DOWN keys here.
2097
2098 return FALSE;
2099 }
2100
2101 static GtkWidget *
2102 #if GTK_CHECK_VERSION(3,10,0)
create_image_button(const char * stock_id UNUSED,const char * label)2103 create_image_button(const char *stock_id UNUSED,
2104 const char *label)
2105 #else
2106 create_image_button(const char *stock_id,
2107 const char *label)
2108 #endif
2109 {
2110 char_u *text;
2111 GtkWidget *box;
2112 GtkWidget *alignment;
2113 GtkWidget *button;
2114
2115 text = CONVERT_TO_UTF8((char_u *)label);
2116
2117 #if GTK_CHECK_VERSION(3,2,0)
2118 box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3);
2119 gtk_box_set_homogeneous(GTK_BOX(box), FALSE);
2120 #else
2121 box = gtk_hbox_new(FALSE, 3);
2122 #endif
2123 #if !GTK_CHECK_VERSION(3,10,0)
2124 if (stock_id != NULL)
2125 gtk_box_pack_start(GTK_BOX(box),
2126 gtk_image_new_from_stock(stock_id, GTK_ICON_SIZE_BUTTON),
2127 FALSE, FALSE, 0);
2128 #endif
2129 gtk_box_pack_start(GTK_BOX(box),
2130 gtk_label_new((const char *)text),
2131 FALSE, FALSE, 0);
2132
2133 CONVERT_TO_UTF8_FREE(text);
2134
2135 #if GTK_CHECK_VERSION(3,14,0)
2136 gtk_widget_set_halign(GTK_WIDGET(box), GTK_ALIGN_CENTER);
2137 gtk_widget_set_valign(GTK_WIDGET(box), GTK_ALIGN_CENTER);
2138 gtk_widget_set_hexpand(GTK_WIDGET(box), TRUE);
2139 gtk_widget_set_vexpand(GTK_WIDGET(box), TRUE);
2140
2141 alignment = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
2142 #else
2143 alignment = gtk_alignment_new((float)0.5, (float)0.5,
2144 (float)0.0, (float)0.0);
2145 #endif
2146 gtk_container_add(GTK_CONTAINER(alignment), box);
2147 gtk_widget_show_all(alignment);
2148
2149 button = gtk_button_new();
2150 gtk_container_add(GTK_CONTAINER(button), alignment);
2151
2152 return button;
2153 }
2154
2155 /*
2156 * This is currently only used by find_replace_dialog_create(), and
2157 * I'd really like to keep it at that. In other words: don't spread
2158 * this nasty hack all over the code. Think twice.
2159 */
2160 static const char *
convert_localized_message(char_u ** buffer,const char * message)2161 convert_localized_message(char_u **buffer, const char *message)
2162 {
2163 if (output_conv.vc_type == CONV_NONE)
2164 return message;
2165
2166 vim_free(*buffer);
2167 *buffer = string_convert(&output_conv, (char_u *)message, NULL);
2168
2169 return (const char *)*buffer;
2170 }
2171
2172 /*
2173 * Returns the number of characters in GtkEntry.
2174 */
2175 static unsigned long
entry_get_text_length(GtkEntry * entry)2176 entry_get_text_length(GtkEntry *entry)
2177 {
2178 g_return_val_if_fail(entry != NULL, 0);
2179 g_return_val_if_fail(GTK_IS_ENTRY(entry) == TRUE, 0);
2180
2181 #if GTK_CHECK_VERSION(2,18,0)
2182 // 2.18 introduced a new object GtkEntryBuffer to handle text data for
2183 // GtkEntry instead of letting each instance of the latter have its own
2184 // storage for that. The code below is almost identical to the
2185 // implementation of gtk_entry_get_text_length() for the versions >= 2.18.
2186 return gtk_entry_buffer_get_length(gtk_entry_get_buffer(entry));
2187 #elif GTK_CHECK_VERSION(2,14,0)
2188 // 2.14 introduced a new function to avoid memory management bugs which can
2189 // happen when gtk_entry_get_text() is used without due care and attention.
2190 return gtk_entry_get_text_length(entry);
2191 #else
2192 // gtk_entry_get_text() returns the pointer to the storage allocated
2193 // internally by the widget. Accordingly, use the one with great care:
2194 // Don't free it nor modify the contents it points to; call the function
2195 // every time you need the pointer since its value may have been changed
2196 // by the widget.
2197 return g_utf8_strlen(gtk_entry_get_text(entry), -1);
2198 #endif
2199 }
2200
2201 static void
find_replace_dialog_create(char_u * arg,int do_replace)2202 find_replace_dialog_create(char_u *arg, int do_replace)
2203 {
2204 GtkWidget *hbox; // main top down box
2205 GtkWidget *actionarea;
2206 GtkWidget *table;
2207 GtkWidget *tmp;
2208 GtkWidget *vbox;
2209 gboolean sensitive;
2210 SharedFindReplace *frdp;
2211 char_u *entry_text;
2212 int wword = FALSE;
2213 int mcase = !p_ic;
2214 char_u *conv_buffer = NULL;
2215 # define CONV(message) convert_localized_message(&conv_buffer, (message))
2216
2217 frdp = (do_replace) ? (&repl_widgets) : (&find_widgets);
2218
2219 // Get the search string to use.
2220 entry_text = get_find_dialog_text(arg, &wword, &mcase);
2221
2222 if (entry_text != NULL && output_conv.vc_type != CONV_NONE)
2223 {
2224 char_u *old_text = entry_text;
2225 entry_text = string_convert(&output_conv, entry_text, NULL);
2226 vim_free(old_text);
2227 }
2228
2229 /*
2230 * If the dialog already exists, just raise it.
2231 */
2232 if (frdp->dialog)
2233 {
2234 if (entry_text != NULL)
2235 {
2236 gtk_entry_set_text(GTK_ENTRY(frdp->what), (char *)entry_text);
2237 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(frdp->wword),
2238 (gboolean)wword);
2239 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(frdp->mcase),
2240 (gboolean)mcase);
2241 }
2242 gtk_window_present(GTK_WINDOW(frdp->dialog));
2243
2244 // For :promptfind dialog, always give keyboard focus to 'what' entry.
2245 // For :promptrepl dialog, give it to 'with' entry if 'what' has an
2246 // non-empty entry; otherwise, to 'what' entry.
2247 gtk_widget_grab_focus(frdp->what);
2248 if (do_replace && entry_get_text_length(GTK_ENTRY(frdp->what)) > 0)
2249 gtk_widget_grab_focus(frdp->with);
2250
2251 vim_free(entry_text);
2252 return;
2253 }
2254
2255 frdp->dialog = gtk_dialog_new();
2256 #if GTK_CHECK_VERSION(3,0,0)
2257 // Nothing equivalent to gtk_dialog_set_has_separator() in GTK+ 3.
2258 #else
2259 gtk_dialog_set_has_separator(GTK_DIALOG(frdp->dialog), FALSE);
2260 #endif
2261 gtk_window_set_transient_for(GTK_WINDOW(frdp->dialog), GTK_WINDOW(gui.mainwin));
2262 gtk_window_set_destroy_with_parent(GTK_WINDOW(frdp->dialog), TRUE);
2263
2264 if (do_replace)
2265 {
2266 gtk_window_set_title(GTK_WINDOW(frdp->dialog),
2267 CONV(_("VIM - Search and Replace...")));
2268 }
2269 else
2270 {
2271 gtk_window_set_title(GTK_WINDOW(frdp->dialog),
2272 CONV(_("VIM - Search...")));
2273 }
2274
2275 #if GTK_CHECK_VERSION(3,2,0)
2276 hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
2277 gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE);
2278 #else
2279 hbox = gtk_hbox_new(FALSE, 0);
2280 #endif
2281 gtk_container_set_border_width(GTK_CONTAINER(hbox), 10);
2282 #if GTK_CHECK_VERSION(3,0,0)
2283 {
2284 GtkWidget * const dialog_vbox
2285 = gtk_dialog_get_content_area(GTK_DIALOG(frdp->dialog));
2286 gtk_container_add(GTK_CONTAINER(dialog_vbox), hbox);
2287 }
2288 #else
2289 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(frdp->dialog)->vbox), hbox);
2290 #endif
2291
2292 if (do_replace)
2293 #if GTK_CHECK_VERSION(3,4,0)
2294 table = gtk_grid_new();
2295 #else
2296 table = gtk_table_new(1024, 4, FALSE);
2297 #endif
2298 else
2299 #if GTK_CHECK_VERSION(3,4,0)
2300 table = gtk_grid_new();
2301 #else
2302 table = gtk_table_new(1024, 3, FALSE);
2303 #endif
2304 gtk_box_pack_start(GTK_BOX(hbox), table, TRUE, TRUE, 0);
2305 gtk_container_set_border_width(GTK_CONTAINER(table), 4);
2306
2307 tmp = gtk_label_new(CONV(_("Find what:")));
2308 #if GTK_CHECK_VERSION(3,16,0)
2309 gtk_label_set_xalign(GTK_LABEL(tmp), 0.0);
2310 gtk_label_set_yalign(GTK_LABEL(tmp), 0.5);
2311 #elif GTK_CHECK_VERSION(3,14,0)
2312 {
2313 GValue align_val = G_VALUE_INIT;
2314
2315 g_value_init(&align_val, G_TYPE_FLOAT);
2316
2317 g_value_set_float(&align_val, 0.0);
2318 g_object_set_property(G_OBJECT(tmp), "xalign", &align_val);
2319
2320 g_value_set_float(&align_val, 0.5);
2321 g_object_set_property(G_OBJECT(tmp), "yalign", &align_val);
2322
2323 g_value_unset(&align_val);
2324 }
2325 #else
2326 gtk_misc_set_alignment(GTK_MISC(tmp), (gfloat)0.0, (gfloat)0.5);
2327 #endif
2328 #if GTK_CHECK_VERSION(3,4,0)
2329 gtk_grid_attach(GTK_GRID(table), tmp, 0, 0, 2, 1);
2330 #else
2331 gtk_table_attach(GTK_TABLE(table), tmp, 0, 1, 0, 1,
2332 GTK_FILL, GTK_EXPAND, 2, 2);
2333 #endif
2334 frdp->what = gtk_entry_new();
2335 sensitive = (entry_text != NULL && entry_text[0] != NUL);
2336 if (entry_text != NULL)
2337 gtk_entry_set_text(GTK_ENTRY(frdp->what), (char *)entry_text);
2338 g_signal_connect(G_OBJECT(frdp->what), "changed",
2339 G_CALLBACK(entry_changed_cb), frdp->dialog);
2340 g_signal_connect_after(G_OBJECT(frdp->what), "key-press-event",
2341 G_CALLBACK(find_key_press_event),
2342 (gpointer) frdp);
2343 #if GTK_CHECK_VERSION(3,4,0)
2344 gtk_grid_attach(GTK_GRID(table), frdp->what, 2, 0, 5, 1);
2345 #else
2346 gtk_table_attach(GTK_TABLE(table), frdp->what, 1, 1024, 0, 1,
2347 GTK_EXPAND | GTK_FILL, GTK_EXPAND, 2, 2);
2348 #endif
2349
2350 if (do_replace)
2351 {
2352 tmp = gtk_label_new(CONV(_("Replace with:")));
2353 #if GTK_CHECK_VERSION(3,16,0)
2354 gtk_label_set_xalign(GTK_LABEL(tmp), 0.0);
2355 gtk_label_set_yalign(GTK_LABEL(tmp), 0.5);
2356 #elif GTK_CHECK_VERSION(3,14,0)
2357 {
2358 GValue align_val = G_VALUE_INIT;
2359
2360 g_value_init(&align_val, G_TYPE_FLOAT);
2361
2362 g_value_set_float(&align_val, 0.0);
2363 g_object_set_property(G_OBJECT(tmp), "xalign", &align_val);
2364
2365 g_value_set_float(&align_val, 0.5);
2366 g_object_set_property(G_OBJECT(tmp), "yalign", &align_val);
2367
2368 g_value_unset(&align_val);
2369 }
2370 #else
2371 gtk_misc_set_alignment(GTK_MISC(tmp), (gfloat)0.0, (gfloat)0.5);
2372 #endif
2373 #if GTK_CHECK_VERSION(3,4,0)
2374 gtk_grid_attach(GTK_GRID(table), tmp, 0, 1, 2, 1);
2375 #else
2376 gtk_table_attach(GTK_TABLE(table), tmp, 0, 1, 1, 2,
2377 GTK_FILL, GTK_EXPAND, 2, 2);
2378 #endif
2379 frdp->with = gtk_entry_new();
2380 g_signal_connect(G_OBJECT(frdp->with), "activate",
2381 G_CALLBACK(find_replace_cb),
2382 GINT_TO_POINTER(FRD_R_FINDNEXT));
2383 g_signal_connect_after(G_OBJECT(frdp->with), "key-press-event",
2384 G_CALLBACK(find_key_press_event),
2385 (gpointer) frdp);
2386 #if GTK_CHECK_VERSION(3,4,0)
2387 gtk_grid_attach(GTK_GRID(table), frdp->with, 2, 1, 5, 1);
2388 #else
2389 gtk_table_attach(GTK_TABLE(table), frdp->with, 1, 1024, 1, 2,
2390 GTK_EXPAND | GTK_FILL, GTK_EXPAND, 2, 2);
2391 #endif
2392
2393 /*
2394 * Make the entry activation only change the input focus onto the
2395 * with item.
2396 */
2397 g_signal_connect(G_OBJECT(frdp->what), "activate",
2398 G_CALLBACK(entry_activate_cb), frdp->with);
2399 }
2400 else
2401 {
2402 /*
2403 * Make the entry activation do the search.
2404 */
2405 g_signal_connect(G_OBJECT(frdp->what), "activate",
2406 G_CALLBACK(find_replace_cb),
2407 GINT_TO_POINTER(FRD_FINDNEXT));
2408 }
2409
2410 // whole word only button
2411 frdp->wword = gtk_check_button_new_with_label(CONV(_("Match whole word only")));
2412 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(frdp->wword),
2413 (gboolean)wword);
2414 if (do_replace)
2415 #if GTK_CHECK_VERSION(3,4,0)
2416 gtk_grid_attach(GTK_GRID(table), frdp->wword, 0, 2, 5, 1);
2417 #else
2418 gtk_table_attach(GTK_TABLE(table), frdp->wword, 0, 1023, 2, 3,
2419 GTK_FILL, GTK_EXPAND, 2, 2);
2420 #endif
2421 else
2422 #if GTK_CHECK_VERSION(3,4,0)
2423 gtk_grid_attach(GTK_GRID(table), frdp->wword, 0, 3, 5, 1);
2424 #else
2425 gtk_table_attach(GTK_TABLE(table), frdp->wword, 0, 1023, 1, 2,
2426 GTK_FILL, GTK_EXPAND, 2, 2);
2427 #endif
2428
2429 // match case button
2430 frdp->mcase = gtk_check_button_new_with_label(CONV(_("Match case")));
2431 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(frdp->mcase),
2432 (gboolean)mcase);
2433 if (do_replace)
2434 #if GTK_CHECK_VERSION(3,4,0)
2435 gtk_grid_attach(GTK_GRID(table), frdp->mcase, 0, 3, 5, 1);
2436 #else
2437 gtk_table_attach(GTK_TABLE(table), frdp->mcase, 0, 1023, 3, 4,
2438 GTK_FILL, GTK_EXPAND, 2, 2);
2439 #endif
2440 else
2441 #if GTK_CHECK_VERSION(3,4,0)
2442 gtk_grid_attach(GTK_GRID(table), frdp->mcase, 0, 4, 5, 1);
2443 #else
2444 gtk_table_attach(GTK_TABLE(table), frdp->mcase, 0, 1023, 2, 3,
2445 GTK_FILL, GTK_EXPAND, 2, 2);
2446 #endif
2447
2448 tmp = gtk_frame_new(CONV(_("Direction")));
2449 if (do_replace)
2450 #if GTK_CHECK_VERSION(3,4,0)
2451 gtk_grid_attach(GTK_GRID(table), tmp, 5, 2, 2, 4);
2452 #else
2453 gtk_table_attach(GTK_TABLE(table), tmp, 1023, 1024, 2, 4,
2454 GTK_FILL, GTK_FILL, 2, 2);
2455 #endif
2456 else
2457 #if GTK_CHECK_VERSION(3,4,0)
2458 gtk_grid_attach(GTK_GRID(table), tmp, 5, 2, 1, 3);
2459 #else
2460 gtk_table_attach(GTK_TABLE(table), tmp, 1023, 1024, 1, 3,
2461 GTK_FILL, GTK_FILL, 2, 2);
2462 #endif
2463 #if GTK_CHECK_VERSION(3,2,0)
2464 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
2465 gtk_box_set_homogeneous(GTK_BOX(vbox), FALSE);
2466 #else
2467 vbox = gtk_vbox_new(FALSE, 0);
2468 #endif
2469 gtk_container_set_border_width(GTK_CONTAINER(vbox), 0);
2470 gtk_container_add(GTK_CONTAINER(tmp), vbox);
2471
2472 // 'Up' and 'Down' buttons
2473 frdp->up = gtk_radio_button_new_with_label(NULL, CONV(_("Up")));
2474 gtk_box_pack_start(GTK_BOX(vbox), frdp->up, TRUE, TRUE, 0);
2475 frdp->down = gtk_radio_button_new_with_label(
2476 gtk_radio_button_get_group(GTK_RADIO_BUTTON(frdp->up)),
2477 CONV(_("Down")));
2478 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(frdp->down), TRUE);
2479 gtk_container_set_border_width(GTK_CONTAINER(vbox), 2);
2480 gtk_box_pack_start(GTK_BOX(vbox), frdp->down, TRUE, TRUE, 0);
2481
2482 // vbox to hold the action buttons
2483 #if GTK_CHECK_VERSION(3,2,0)
2484 actionarea = gtk_button_box_new(GTK_ORIENTATION_VERTICAL);
2485 #else
2486 actionarea = gtk_vbutton_box_new();
2487 #endif
2488 gtk_container_set_border_width(GTK_CONTAINER(actionarea), 2);
2489 gtk_box_pack_end(GTK_BOX(hbox), actionarea, FALSE, FALSE, 0);
2490
2491 // 'Find Next' button
2492 #if GTK_CHECK_VERSION(3,10,0)
2493 frdp->find = create_image_button(NULL, _("Find Next"));
2494 #else
2495 frdp->find = create_image_button(GTK_STOCK_FIND, _("Find Next"));
2496 #endif
2497 gtk_widget_set_sensitive(frdp->find, sensitive);
2498
2499 g_signal_connect(G_OBJECT(frdp->find), "clicked",
2500 G_CALLBACK(find_replace_cb),
2501 (do_replace) ? GINT_TO_POINTER(FRD_R_FINDNEXT)
2502 : GINT_TO_POINTER(FRD_FINDNEXT));
2503
2504 gtk_widget_set_can_default(frdp->find, TRUE);
2505 gtk_box_pack_start(GTK_BOX(actionarea), frdp->find, FALSE, FALSE, 0);
2506 gtk_widget_grab_default(frdp->find);
2507
2508 if (do_replace)
2509 {
2510 // 'Replace' button
2511 #if GTK_CHECK_VERSION(3,10,0)
2512 frdp->replace = create_image_button(NULL, _("Replace"));
2513 #else
2514 frdp->replace = create_image_button(GTK_STOCK_CONVERT, _("Replace"));
2515 #endif
2516 gtk_widget_set_sensitive(frdp->replace, sensitive);
2517 gtk_widget_set_can_default(frdp->find, TRUE);
2518 gtk_box_pack_start(GTK_BOX(actionarea), frdp->replace, FALSE, FALSE, 0);
2519 g_signal_connect(G_OBJECT(frdp->replace), "clicked",
2520 G_CALLBACK(find_replace_cb),
2521 GINT_TO_POINTER(FRD_REPLACE));
2522
2523 // 'Replace All' button
2524 #if GTK_CHECK_VERSION(3,10,0)
2525 frdp->all = create_image_button(NULL, _("Replace All"));
2526 #else
2527 frdp->all = create_image_button(GTK_STOCK_CONVERT, _("Replace All"));
2528 #endif
2529 gtk_widget_set_sensitive(frdp->all, sensitive);
2530 gtk_widget_set_can_default(frdp->all, TRUE);
2531 gtk_box_pack_start(GTK_BOX(actionarea), frdp->all, FALSE, FALSE, 0);
2532 g_signal_connect(G_OBJECT(frdp->all), "clicked",
2533 G_CALLBACK(find_replace_cb),
2534 GINT_TO_POINTER(FRD_REPLACEALL));
2535 }
2536
2537 // 'Cancel' button
2538 #if GTK_CHECK_VERSION(3,10,0)
2539 tmp = gtk_button_new_with_mnemonic(_("_Close"));
2540 #else
2541 tmp = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
2542 #endif
2543 gtk_widget_set_can_default(tmp, TRUE);
2544 gtk_box_pack_end(GTK_BOX(actionarea), tmp, FALSE, FALSE, 0);
2545 g_signal_connect_swapped(G_OBJECT(tmp),
2546 "clicked", G_CALLBACK(gtk_widget_hide),
2547 G_OBJECT(frdp->dialog));
2548 g_signal_connect_swapped(G_OBJECT(frdp->dialog),
2549 "delete-event", G_CALLBACK(gtk_widget_hide_on_delete),
2550 G_OBJECT(frdp->dialog));
2551
2552 #if GTK_CHECK_VERSION(3,2,0)
2553 tmp = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
2554 #else
2555 tmp = gtk_vseparator_new();
2556 #endif
2557 gtk_box_pack_end(GTK_BOX(hbox), tmp, FALSE, FALSE, 10);
2558
2559 // Suppress automatic show of the unused action area
2560 #if GTK_CHECK_VERSION(3,0,0)
2561 # if !GTK_CHECK_VERSION(3,12,0)
2562 gtk_widget_hide(gtk_dialog_get_action_area(GTK_DIALOG(frdp->dialog)));
2563 # endif
2564 #else
2565 gtk_widget_hide(GTK_DIALOG(frdp->dialog)->action_area);
2566 #endif
2567 gtk_widget_show_all(hbox);
2568 gtk_widget_show(frdp->dialog);
2569
2570 vim_free(entry_text);
2571 vim_free(conv_buffer);
2572 #undef CONV
2573 }
2574
2575 void
gui_mch_find_dialog(exarg_T * eap)2576 gui_mch_find_dialog(exarg_T *eap)
2577 {
2578 if (gui.in_use)
2579 find_replace_dialog_create(eap->arg, FALSE);
2580 }
2581
2582 void
gui_mch_replace_dialog(exarg_T * eap)2583 gui_mch_replace_dialog(exarg_T *eap)
2584 {
2585 if (gui.in_use)
2586 find_replace_dialog_create(eap->arg, TRUE);
2587 }
2588
2589 /*
2590 * Callback for actions of the find and replace dialogs
2591 */
2592 static void
find_replace_cb(GtkWidget * widget UNUSED,gpointer data)2593 find_replace_cb(GtkWidget *widget UNUSED, gpointer data)
2594 {
2595 int flags;
2596 char_u *find_text;
2597 char_u *repl_text;
2598 gboolean direction_down;
2599 SharedFindReplace *sfr;
2600
2601 flags = (int)(long)data; // avoid a lint warning here
2602
2603 // Get the search/replace strings from the dialog
2604 if (flags == FRD_FINDNEXT)
2605 {
2606 repl_text = NULL;
2607 sfr = &find_widgets;
2608 }
2609 else
2610 {
2611 repl_text = (char_u *)gtk_entry_get_text(GTK_ENTRY(repl_widgets.with));
2612 sfr = &repl_widgets;
2613 }
2614
2615 find_text = (char_u *)gtk_entry_get_text(GTK_ENTRY(sfr->what));
2616 direction_down = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sfr->down));
2617
2618 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sfr->wword)))
2619 flags |= FRD_WHOLE_WORD;
2620 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sfr->mcase)))
2621 flags |= FRD_MATCH_CASE;
2622
2623 repl_text = CONVERT_FROM_UTF8(repl_text);
2624 find_text = CONVERT_FROM_UTF8(find_text);
2625 gui_do_findrepl(flags, find_text, repl_text, direction_down);
2626 CONVERT_FROM_UTF8_FREE(repl_text);
2627 CONVERT_FROM_UTF8_FREE(find_text);
2628 }
2629
2630 /*
2631 * our usual callback function
2632 */
2633 static void
entry_activate_cb(GtkWidget * widget UNUSED,gpointer data)2634 entry_activate_cb(GtkWidget *widget UNUSED, gpointer data)
2635 {
2636 gtk_widget_grab_focus(GTK_WIDGET(data));
2637 }
2638
2639 /*
2640 * Syncing the find/replace dialogs on the fly is utterly useless crack,
2641 * and causes nothing but problems. Please tell me a use case for which
2642 * you'd need both a find dialog and a find/replace one at the same time,
2643 * without being able to actually use them separately since they're syncing
2644 * all the time. I don't think it's worthwhile to fix this nonsense,
2645 * particularly evil incarnation of braindeadness, whatever; I'd much rather
2646 * see it extinguished from this planet. Thanks for listening. Sorry.
2647 */
2648 static void
entry_changed_cb(GtkWidget * entry,GtkWidget * dialog)2649 entry_changed_cb(GtkWidget * entry, GtkWidget * dialog)
2650 {
2651 const gchar *entry_text;
2652 gboolean nonempty;
2653
2654 entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
2655
2656 if (!entry_text)
2657 return; // shouldn't happen
2658
2659 nonempty = (entry_text[0] != '\0');
2660
2661 if (dialog == find_widgets.dialog)
2662 gtk_widget_set_sensitive(find_widgets.find, nonempty);
2663
2664 if (dialog == repl_widgets.dialog)
2665 {
2666 gtk_widget_set_sensitive(repl_widgets.find, nonempty);
2667 gtk_widget_set_sensitive(repl_widgets.replace, nonempty);
2668 gtk_widget_set_sensitive(repl_widgets.all, nonempty);
2669 }
2670 }
2671
2672 /*
2673 * ":helpfind"
2674 */
2675 void
ex_helpfind(exarg_T * eap UNUSED)2676 ex_helpfind(exarg_T *eap UNUSED)
2677 {
2678 // This will fail when menus are not loaded. Well, it's only for
2679 // backwards compatibility anyway.
2680 do_cmdline_cmd((char_u *)"emenu ToolBar.FindHelp");
2681 }
2682
2683 #if defined(FEAT_BROWSE) || defined(PROTO)
2684 static void
recent_func_log_func(const gchar * log_domain UNUSED,GLogLevelFlags log_level UNUSED,const gchar * message UNUSED,gpointer user_data UNUSED)2685 recent_func_log_func(const gchar *log_domain UNUSED,
2686 GLogLevelFlags log_level UNUSED,
2687 const gchar *message UNUSED,
2688 gpointer user_data UNUSED)
2689 {
2690 // We just want to suppress the warnings.
2691 // http://bugzilla.gnome.org/show_bug.cgi?id=664587
2692 }
2693 #endif
2694