/* vi:set ts=8 sts=4 sw=4 noet:

*

* VIM - Vi IMproved by Bram Moolenaar

*

* Do ":help uganda" in Vim to read copying and usage conditions.

* Do ":help credits" in Vim to see a list of people who contributed.

* See README.txt for an overview of the Vim source code.

*/

/*

* Porting to GTK+ was done by:

*

* (C) 1998,1999,2000 by Marcin Dalecki <martin@dalecki.de>

*

* With GREAT support and continuous encouragements by Andy Kahn and of

* course Bram Moolenaar!

*

* Support for GTK+ 2 was added by:

*

* (C) 2002,2003 Jason Hildebrand <jason@peaceworks.ca>

* Daniel Elstner <daniel.elstner@gmx.net>

*

* Best supporting actor (He helped somewhat, aesthetically speaking):

* Maxime Romano <verbophobe@hotmail.com>

*

* Support for GTK+ 3 was added by:

*

* 2016 Kazunobu Kuriyama <kazunobu.kuriyama@gmail.com>

*

* With the help of Marius Gedminas and the word of Bram Moolenaar,

* "Let's give this some time to mature."

*/

#include "vim.h"

#ifdef FEAT_GUI_GTK

# include "gui_gtk_f.h"

#endif

/* GTK defines MAX and MIN, but some system header files as well. Undefine

* them and don't use them. */

#ifdef MIN

# undef MIN

#endif

#ifdef MAX

# undef MAX

#endif

#ifdef FEAT_GUI_GNOME

/* Gnome redefines _() and N_(). Grrr... */

# ifdef _

# undef _

# endif

# ifdef N_

# undef N_

# endif

# ifdef textdomain

# undef textdomain

# endif

# ifdef bindtextdomain

# undef bindtextdomain

# endif

# ifdef bind_textdomain_codeset

# undef bind_textdomain_codeset

# endif

# if defined(FEAT_GETTEXT) && !defined(ENABLE_NLS)

# define ENABLE_NLS /* so the texts in the dialog boxes are translated */

# endif

# include <gnome.h>

#endif

#ifdef FEAT_GUI_GTK

# if GTK_CHECK_VERSION(3,0,0)

# include <gdk/gdkkeysyms-compat.h>

# else

# include <gdk/gdkkeysyms.h>

# endif

# include <gdk/gdk.h>

# ifdef MSWIN

# include <gdk/gdkwin32.h>

# else

# include <gdk/gdkx.h>

# endif

# include <gtk/gtk.h>

#else

/* define these items to be able to generate prototypes without GTK */

typedef int GtkWidget;

# define gpointer int

# define guint8 int

# define GdkPixmap int

# define GdkBitmap int

# define GtkIconFactory int

# define GtkToolbar int

# define GtkAdjustment int

# define gboolean int

# define GdkEventKey int

# define CancelData int

#endif

static void entry_activate_cb(GtkWidget *widget, gpointer data);

static void entry_changed_cb(GtkWidget *entry, GtkWidget *dialog);

static void find_replace_cb(GtkWidget *widget, gpointer data);

#if defined(FEAT_BROWSE) || defined(PROTO)

static void recent_func_log_func(

const gchar *log_domain,

GLogLevelFlags log_level,

const gchar *message,

gpointer user_data);

#endif

#if defined(FEAT_TOOLBAR)

/*

* Table from BuiltIn## icon indices to GTK+ stock IDs. Order must exactly

* match toolbar_names[] in menu.c! All stock icons including the "vim-*"

* ones can be overridden in your gtkrc file.

*/

# if GTK_CHECK_VERSION(3,10,0)

static const char * const menu_themed_names[] =

{

/* 00 */ "document-new", /* sub. GTK_STOCK_NEW */

/* 01 */ "document-open", /* sub. GTK_STOCK_OPEN */

/* 02 */ "document-save", /* sub. GTK_STOCK_SAVE */

/* 03 */ "edit-undo", /* sub. GTK_STOCK_UNDO */

/* 04 */ "edit-redo", /* sub. GTK_STOCK_REDO */

/* 05 */ "edit-cut", /* sub. GTK_STOCK_CUT */

/* 06 */ "edit-copy", /* sub. GTK_STOCK_COPY */

/* 07 */ "edit-paste", /* sub. GTK_STOCK_PASTE */

/* 08 */ "document-print", /* sub. GTK_STOCK_PRINT */

/* 09 */ "help-browser", /* sub. GTK_STOCK_HELP */

/* 10 */ "edit-find", /* sub. GTK_STOCK_FIND */

# if GTK_CHECK_VERSION(3,14,0)

/* Use the file names in gui_gtk_res.xml, cutting off the extension.

* Similar changes follow. */

/* 11 */ "stock_vim_save_all",

/* 12 */ "stock_vim_session_save",

/* 13 */ "stock_vim_session_new",

/* 14 */ "stock_vim_session_load",

# else

/* 11 */ "vim-save-all",

/* 12 */ "vim-session-save",

/* 13 */ "vim-session-new",

/* 14 */ "vim-session-load",

# endif

/* 15 */ "system-run", /* sub. GTK_STOCK_EXECUTE */

/* 16 */ "edit-find-replace", /* sub. GTK_STOCK_FIND_AND_REPLACE */

/* 17 */ "window-close", /* sub. GTK_STOCK_CLOSE, FIXME: fuzzy */

# if GTK_CHECK_VERSION(3,14,0)

/* 18 */ "stock_vim_window_maximize",

/* 19 */ "stock_vim_window_minimize",

/* 20 */ "stock_vim_window_split",

/* 21 */ "stock_vim_shell",

# else

/* 18 */ "vim-window-maximize",

/* 19 */ "vim-window-minimize",

/* 20 */ "vim-window-split",

/* 21 */ "vim-shell",

# endif

/* 22 */ "go-previous", /* sub. GTK_STOCK_GO_BACK */

/* 23 */ "go-next", /* sub. GTK_STOCK_GO_FORWARD */

# if GTK_CHECK_VERSION(3,14,0)

/* 24 */ "stock_vim_find_help",

# else

/* 24 */ "vim-find-help",

# endif

/* 25 */ "gtk-convert", /* sub. GTK_STOCK_CONVERT */

/* 26 */ "go-jump", /* sub. GTK_STOCK_JUMP_TO */

# if GTK_CHECK_VERSION(3,14,0)

/* 27 */ "stock_vim_build_tags",

/* 28 */ "stock_vim_window_split_vertical",

/* 29 */ "stock_vim_window_maximize_width",

/* 30 */ "stock_vim_window_minimize_width",

# else

/* 27 */ "vim-build-tags",

/* 28 */ "vim-window-split-vertical",

/* 29 */ "vim-window-maximize-width",

/* 30 */ "vim-window-minimize-width",

# endif

/* 31 */ "application-exit", /* GTK_STOCK_QUIT */

};

# else /* !GTK_CHECK_VERSION(3,10,0) */

static const char * const menu_stock_ids[] =

{

/* 00 */ GTK_STOCK_NEW,

/* 01 */ GTK_STOCK_OPEN,

/* 02 */ GTK_STOCK_SAVE,

/* 03 */ GTK_STOCK_UNDO,

/* 04 */ GTK_STOCK_REDO,

/* 05 */ GTK_STOCK_CUT,

/* 06 */ GTK_STOCK_COPY,

/* 07 */ GTK_STOCK_PASTE,

/* 08 */ GTK_STOCK_PRINT,

/* 09 */ GTK_STOCK_HELP,

/* 10 */ GTK_STOCK_FIND,

/* 11 */ "vim-save-all",

/* 12 */ "vim-session-save",

/* 13 */ "vim-session-new",

/* 14 */ "vim-session-load",

/* 15 */ GTK_STOCK_EXECUTE,

/* 16 */ GTK_STOCK_FIND_AND_REPLACE,

/* 17 */ GTK_STOCK_CLOSE, /* FIXME: fuzzy */

/* 18 */ "vim-window-maximize",

/* 19 */ "vim-window-minimize",

/* 20 */ "vim-window-split",

/* 21 */ "vim-shell",

/* 22 */ GTK_STOCK_GO_BACK,

/* 23 */ GTK_STOCK_GO_FORWARD,

/* 24 */ "vim-find-help",

/* 25 */ GTK_STOCK_CONVERT,

/* 26 */ GTK_STOCK_JUMP_TO,

/* 27 */ "vim-build-tags",

/* 28 */ "vim-window-split-vertical",

/* 29 */ "vim-window-maximize-width",

/* 30 */ "vim-window-minimize-width",

/* 31 */ GTK_STOCK_QUIT

};

# endif /* !GTK_CHECK_VERSION(3,10,0) */

# ifdef USE_GRESOURCE

# if !GTK_CHECK_VERSION(3,10,0)

typedef struct IconNames {

const char *icon_name;

const char *file_name;

} IconNames;

static IconNames stock_vim_icons[] = {

{ "vim-build-tags", "stock_vim_build_tags.png" },

{ "vim-find-help", "stock_vim_find_help.png" },

{ "vim-save-all", "stock_vim_save_all.png" },

{ "vim-session-load", "stock_vim_session_load.png" },

{ "vim-session-new", "stock_vim_session_new.png" },

{ "vim-session-save", "stock_vim_session_save.png" },

{ "vim-shell", "stock_vim_shell.png" },

{ "vim-window-maximize", "stock_vim_window_maximize.png" },

{ "vim-window-maximize-width", "stock_vim_window_maximize_width.png" },

{ "vim-window-minimize", "stock_vim_window_minimize.png" },

{ "vim-window-minimize-width", "stock_vim_window_minimize_width.png" },

{ "vim-window-split", "stock_vim_window_split.png" },

{ "vim-window-split-vertical", "stock_vim_window_split_vertical.png" },

{ NULL, NULL }

};

# endif

# endif /* USE_G_RESOURCE */

# ifndef USE_GRESOURCE

static void

add_stock_icon(GtkIconFactory *factory,

const char *stock_id,

const guint8 *inline_data,

int data_length)

{

GdkPixbuf *pixbuf;

GtkIconSet *icon_set;

pixbuf = gdk_pixbuf_new_from_inline(data_length, inline_data, FALSE, NULL);

icon_set = gtk_icon_set_new_from_pixbuf(pixbuf);

gtk_icon_factory_add(factory, stock_id, icon_set);

gtk_icon_set_unref(icon_set);

g_object_unref(pixbuf);

}

# endif

static int

lookup_menu_iconfile(char_u *iconfile, char_u *dest)

{

expand_env(iconfile, dest, MAXPATHL);

if (mch_isFullName(dest))

{

return vim_fexists(dest);

}

else

{

static const char suffixes[][4] = {"png", "xpm", "bmp"};

char_u buf[MAXPATHL];

unsigned int i;

for (i = 0; i < G_N_ELEMENTS(suffixes); ++i)

if (gui_find_bitmap(dest, buf, (char *)suffixes[i]) == OK)

{

STRCPY(dest, buf);

return TRUE;

}

return FALSE;

}

}

static GtkWidget *

load_menu_iconfile(char_u *name, GtkIconSize icon_size)

{

GtkWidget *image = NULL;

# if GTK_CHECK_VERSION(3,10,0)

int pixel_size = -1;

switch (icon_size)

{

case GTK_ICON_SIZE_MENU:

pixel_size = 16;

break;

case GTK_ICON_SIZE_SMALL_TOOLBAR:

pixel_size = 16;

break;

case GTK_ICON_SIZE_LARGE_TOOLBAR:

pixel_size = 24;

break;

case GTK_ICON_SIZE_BUTTON:

pixel_size = 16;

break;

case GTK_ICON_SIZE_DND:

pixel_size = 32;

break;

case GTK_ICON_SIZE_DIALOG:

pixel_size = 48;

break;

case GTK_ICON_SIZE_INVALID:

/* FALLTHROUGH */

default:

pixel_size = 0;

break;

}

if (pixel_size > 0 || pixel_size == -1)

{

GdkPixbuf * const pixbuf

= gdk_pixbuf_new_from_file_at_scale((const char *)name,

pixel_size, pixel_size, TRUE, NULL);

if (pixbuf != NULL)

{

image = gtk_image_new_from_pixbuf(pixbuf);

g_object_unref(pixbuf);

}

}

if (image == NULL)

image = gtk_image_new_from_icon_name("image-missing", icon_size);

return image;

# else /* !GTK_CHECK_VERSION(3,10,0) */

GtkIconSet *icon_set;

GtkIconSource *icon_source;

/*

* Rather than loading the icon directly into a GtkImage, create

* a new GtkIconSet and put it in there. This way we can easily

* scale the toolbar icons on the fly when needed.

*/

icon_set = gtk_icon_set_new();

icon_source = gtk_icon_source_new();

gtk_icon_source_set_filename(icon_source, (const char *)name);

gtk_icon_set_add_source(icon_set, icon_source);

image = gtk_image_new_from_icon_set(icon_set, icon_size);

gtk_icon_source_free(icon_source);

gtk_icon_set_unref(icon_set);

return image;

# endif /* !GTK_CHECK_VERSION(3,10,0) */

}

static GtkWidget *

create_menu_icon(vimmenu_T *menu, GtkIconSize icon_size)

{

GtkWidget *image = NULL;

char_u buf[MAXPATHL];

/* First use a specified "icon=" argument. */

if (menu->iconfile != NULL && lookup_menu_iconfile(menu->iconfile, buf))

image = load_menu_iconfile(buf, icon_size);

/* If not found and not builtin specified try using the menu name. */

if (image == NULL && !menu->icon_builtin

&& lookup_menu_iconfile(menu->name, buf))

image = load_menu_iconfile(buf, icon_size);

/* Still not found? Then use a builtin icon, a blank one as fallback. */

if (image == NULL)

{

# if GTK_CHECK_VERSION(3,10,0)

const char *icon_name = NULL;

const int n_names = G_N_ELEMENTS(menu_themed_names);

if (menu->iconidx >= 0 && menu->iconidx < n_names)

icon_name = menu_themed_names[menu->iconidx];

if (icon_name == NULL)

icon_name = "image-missing";

image = gtk_image_new_from_icon_name(icon_name, icon_size);

# else

const char *stock_id;

const int n_ids = G_N_ELEMENTS(menu_stock_ids);

if (menu->iconidx >= 0 && menu->iconidx < n_ids)

stock_id = menu_stock_ids[menu->iconidx];

else

stock_id = GTK_STOCK_MISSING_IMAGE;

image = gtk_image_new_from_stock(stock_id, icon_size);

# endif

}

return image;

}

static gint

toolbar_button_focus_in_event(GtkWidget *widget UNUSED,

GdkEventFocus *event UNUSED,

gpointer data UNUSED)

{

/* When we're in a GtkPlug, we don't have window focus events, only widget

* focus. To emulate stand-alone gvim, if a button gets focus (e.g.,

* <Tab> into GtkPlug) immediately pass it to mainwin. */

if (gtk_socket_id != 0)

gtk_widget_grab_focus(gui.drawarea);

return TRUE;

}

#endif /* FEAT_TOOLBAR */

#if defined(FEAT_TOOLBAR) || defined(PROTO)

void

gui_gtk_register_stock_icons(void)

{

# ifndef USE_GRESOURCE

# include "../pixmaps/stock_icons.h"

GtkIconFactory *factory;

factory = gtk_icon_factory_new();

# define ADD_ICON(Name, Data) add_stock_icon(factory, Name, Data, (int)sizeof(Data))

ADD_ICON("vim-build-tags", stock_vim_build_tags);

ADD_ICON("vim-find-help", stock_vim_find_help);

ADD_ICON("vim-save-all", stock_vim_save_all);

ADD_ICON("vim-session-load", stock_vim_session_load);

ADD_ICON("vim-session-new", stock_vim_session_new);

ADD_ICON("vim-session-save", stock_vim_session_save);

ADD_ICON("vim-shell", stock_vim_shell);

ADD_ICON("vim-window-maximize", stock_vim_window_maximize);

ADD_ICON("vim-window-maximize-width", stock_vim_window_maximize_width);

ADD_ICON("vim-window-minimize", stock_vim_window_minimize);

ADD_ICON("vim-window-minimize-width", stock_vim_window_minimize_width);

ADD_ICON("vim-window-split", stock_vim_window_split);

ADD_ICON("vim-window-split-vertical", stock_vim_window_split_vertical);

# undef ADD_ICON

gtk_icon_factory_add_default(factory);

g_object_unref(factory);

# else /* defined(USE_GRESOURCE) */

const char * const path_prefix = "/org/vim/gui/icon";

# if GTK_CHECK_VERSION(3,14,0)

GdkScreen *screen = NULL;

GtkIconTheme *icon_theme = NULL;

if (GTK_IS_WIDGET(gui.mainwin))

screen = gtk_widget_get_screen(gui.mainwin);

else

screen = gdk_screen_get_default();

icon_theme = gtk_icon_theme_get_for_screen(screen);

gtk_icon_theme_add_resource_path(icon_theme, path_prefix);

# elif GTK_CHECK_VERSION(3,0,0)

IconNames *names;

for (names = stock_vim_icons; names->icon_name != NULL; names++)

{

char path[MAXPATHL];

vim_snprintf(path, MAXPATHL, "%s/%s", path_prefix, names->file_name);

GdkPixbuf *pixbuf = NULL;

pixbuf = gdk_pixbuf_new_from_resource(path, NULL);

if (pixbuf != NULL)

{

const gint size = MAX(gdk_pixbuf_get_width(pixbuf),

gdk_pixbuf_get_height(pixbuf));

if (size > 16)

{

/* An icon theme is supposed to provide fixed-size

* image files for each size, e.g., 16, 22, 24, ...

* Naturally, in contrast to GtkIconSet, GtkIconTheme

* won't prepare size variants for us out of a single

* fixed-size image.

*

* Currently, Vim provides 24x24 images only while the

* icon size on the menu and the toolbar is set to 16x16

* by default.

*

* Resize them by ourselves until we have our own fully

* fledged icon theme. */

GdkPixbuf *src = pixbuf;

pixbuf = gdk_pixbuf_scale_simple(src,

16, 16,

GDK_INTERP_BILINEAR);

if (pixbuf == NULL)

pixbuf = src;

else

g_object_unref(src);

}

gtk_icon_theme_add_builtin_icon(names->icon_name, size, pixbuf);

g_object_unref(pixbuf);

}

}

# else /* !GTK_CHECK_VERSION(3,0.0) */

GtkIconFactory * const factory = gtk_icon_factory_new();

IconNames *names;

for (names = stock_vim_icons; names->icon_name != NULL; names++)

{

char path[MAXPATHL];

GdkPixbuf *pixbuf;

vim_snprintf(path, MAXPATHL, "%s/%s", path_prefix, names->file_name);

pixbuf = gdk_pixbuf_new_from_resource(path, NULL);

if (pixbuf != NULL)

{

GtkIconSet *icon_set = gtk_icon_set_new_from_pixbuf(pixbuf);

gtk_icon_factory_add(factory, names->icon_name, icon_set);

gtk_icon_set_unref(icon_set);

g_object_unref(pixbuf);

}

}

gtk_icon_factory_add_default(factory);

g_object_unref(factory);

# endif /* !GTK_CHECK_VERSION(3,0,0) */

# endif /* defined(USE_GRESOURCE) */

}

#endif /* FEAT_TOOLBAR */

#if defined(FEAT_MENU) || defined(PROTO)

/*

* Translate Vim's mnemonic tagging to GTK+ style and convert to UTF-8

* if necessary. The caller must vim_free() the returned string.

*

* Input Output

* _ __

* && &

* & _ stripped if use_mnemonic == FALSE

* <Tab> end of menu label text

*/

static char_u *

translate_mnemonic_tag(char_u *name, int use_mnemonic)

{

char_u *buf;

char_u *psrc;

char_u *pdest;

int n_underscores = 0;

name = CONVERT_TO_UTF8(name);

if (name == NULL)

return NULL;

for (psrc = name; *psrc != NUL && *psrc != TAB; ++psrc)

if (*psrc == '_')

++n_underscores;

buf = alloc((unsigned)(psrc - name + n_underscores + 1));

if (buf != NULL)

{

pdest = buf;

for (psrc = name; *psrc != NUL && *psrc != TAB; ++psrc)

{

if (*psrc == '_')

{

*pdest++ = '_';

*pdest++ = '_';

}

else if (*psrc != '&')

{

*pdest++ = *psrc;

}

else if (*(psrc + 1) == '&')

{

*pdest++ = *psrc++;

}

else if (use_mnemonic)

{

*pdest++ = '_';

}

}

*pdest = NUL;

}

CONVERT_TO_UTF8_FREE(name);

return buf;

}

static void

menu_item_new(vimmenu_T *menu, GtkWidget *parent_widget)

{

GtkWidget *box;

char_u *text;

int use_mnemonic;

/* It would be neat to have image menu items, but that would require major

* changes to Vim's menu system. Not to mention that all the translations

* had to be updated. */

menu->id = gtk_menu_item_new();

# if GTK_CHECK_VERSION(3,2,0)

box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 20);

gtk_box_set_homogeneous(GTK_BOX(box), FALSE);

# else

box = gtk_hbox_new(FALSE, 20);

# endif

use_mnemonic = (p_wak[0] != 'n' || !GTK_IS_MENU_BAR(parent_widget));

text = translate_mnemonic_tag(menu->name, use_mnemonic);

menu->label = gtk_label_new_with_mnemonic((const char *)text);

vim_free(text);

gtk_box_pack_start(GTK_BOX(box), menu->label, FALSE, FALSE, 0);

if (menu->actext != NULL && menu->actext[0] != NUL)

{

text = CONVERT_TO_UTF8(menu->actext);

gtk_box_pack_end(GTK_BOX(box),

gtk_label_new((const char *)text),

FALSE, FALSE, 0);

CONVERT_TO_UTF8_FREE(text);

}

gtk_container_add(GTK_CONTAINER(menu->id), box);

gtk_widget_show_all(menu->id);

}

void

gui_mch_add_menu(vimmenu_T *menu, int idx)

{

vimmenu_T *parent;

GtkWidget *parent_widget;

if (menu->name[0] == ']' || menu_is_popup(menu->name))

{

menu->submenu_id = gtk_menu_new();

return;

}

parent = menu->parent;

if ((parent != NULL && parent->submenu_id == NULL)

|| !menu_is_menubar(menu->name))

return;

parent_widget = (parent != NULL) ? parent->submenu_id : gui.menubar;

menu_item_new(menu, parent_widget);

# if !GTK_CHECK_VERSION(3,4,0)

/* since the tearoff should always appear first, increment idx */

if (parent != NULL && !menu_is_popup(parent->name))

++idx;

# endif

gtk_menu_shell_insert(GTK_MENU_SHELL(parent_widget), menu->id, idx);

menu->submenu_id = gtk_menu_new();

gtk_menu_set_accel_group(GTK_MENU(menu->submenu_id), gui.accel_group);

gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu->id), menu->submenu_id);

# if !GTK_CHECK_VERSION(3,4,0)

menu->tearoff_handle = gtk_tearoff_menu_item_new();

if (vim_strchr(p_go, GO_TEAROFF) != NULL)

gtk_widget_show(menu->tearoff_handle);

# if GTK_CHECK_VERSION(3,0,0)

gtk_menu_shell_prepend(GTK_MENU_SHELL(menu->submenu_id),

menu->tearoff_handle);

# else

gtk_menu_prepend(GTK_MENU(menu->submenu_id), menu->tearoff_handle);

# endif

# endif

}

static void

menu_item_activate(GtkWidget *widget UNUSED, gpointer data)

{

gui_menu_cb((vimmenu_T *)data);

}

void

gui_mch_add_menu_item(vimmenu_T *menu, int idx)

{

vimmenu_T *parent;

parent = menu->parent;

# ifdef FEAT_TOOLBAR

if (menu_is_toolbar(parent->name))

{

GtkToolbar *toolbar;

toolbar = GTK_TOOLBAR(gui.toolbar);

menu->submenu_id = NULL;

if (menu_is_separator(menu->name))

{

# if GTK_CHECK_VERSION(3,0,0)

GtkToolItem *item = gtk_separator_tool_item_new();

gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(item),

TRUE);

gtk_tool_item_set_expand(GTK_TOOL_ITEM(item), FALSE);

gtk_widget_show(GTK_WIDGET(item));

gtk_toolbar_insert(toolbar, item, idx);

# else

gtk_toolbar_insert_space(toolbar, idx);

# endif

menu->id = NULL;

}

else

{

char_u *text;

char_u *tooltip;

text = CONVERT_TO_UTF8(menu->dname);

tooltip = CONVERT_TO_UTF8(menu->strings[MENU_INDEX_TIP]);

if (tooltip != NULL && !utf_valid_string(tooltip, NULL))

/* Invalid text, can happen when 'encoding' is changed. Avoid

* a nasty GTK error message, skip the tooltip. */

CONVERT_TO_UTF8_FREE(tooltip);

# if GTK_CHECK_VERSION(3,0,0)

{

GtkWidget *icon;

GtkToolItem *item;

icon = create_menu_icon(menu,

gtk_toolbar_get_icon_size(toolbar));

item = gtk_tool_button_new(icon, (const gchar *)text);

gtk_tool_item_set_tooltip_text(item, (const gchar *)tooltip);

g_signal_connect(G_OBJECT(item), "clicked",

G_CALLBACK(&menu_item_activate), menu);

gtk_widget_show_all(GTK_WIDGET(item));

gtk_toolbar_insert(toolbar, item, idx);

menu->id = GTK_WIDGET(item);

}

# else

menu->id = gtk_toolbar_insert_item(

toolbar,

(const char *)text,

(const char *)tooltip,

NULL,

create_menu_icon(menu, gtk_toolbar_get_icon_size(toolbar)),

G_CALLBACK(&menu_item_activate),

menu,

idx);

# endif

if (gtk_socket_id != 0)

g_signal_connect(G_OBJECT(menu->id), "focus-in-event",

G_CALLBACK(toolbar_button_focus_in_event), NULL);

CONVERT_TO_UTF8_FREE(text);

CONVERT_TO_UTF8_FREE(tooltip);

}

}

else

# endif /* FEAT_TOOLBAR */

{

/* No parent, must be a non-menubar menu */

if (parent == NULL || parent->submenu_id == NULL)

return;

# if !GTK_CHECK_VERSION(3,4,0)

/* Make place for the possible tearoff handle item. Not in the popup

* menu, it doesn't have a tearoff item. */

if (!menu_is_popup(parent->name))

++idx;

# endif

if (menu_is_separator(menu->name))

{

/* Separator: Just add it */

# if GTK_CHECK_VERSION(3,0,0)

menu->id = gtk_separator_menu_item_new();

# else

menu->id = gtk_menu_item_new();

gtk_widget_set_sensitive(menu->id, FALSE);

# endif

gtk_widget_show(menu->id);

gtk_menu_shell_insert(GTK_MENU_SHELL(parent->submenu_id),

menu->id, idx);

return;

}

/* Add textual menu item. */

menu_item_new(menu, parent->submenu_id);

gtk_widget_show(menu->id);

gtk_menu_shell_insert(GTK_MENU_SHELL(parent->submenu_id),

menu->id, idx);

if (menu->id != NULL)

g_signal_connect(G_OBJECT(menu->id), "activate",

G_CALLBACK(menu_item_activate), menu);

}

}

#endif /* FEAT_MENU */

void

gui_mch_set_text_area_pos(int x, int y, int w, int h)

{

gtk_form_move_resize(GTK_FORM(gui.formwin), gui.drawarea, x, y, w, h);

}

#if defined(FEAT_MENU) || defined(PROTO)

/*

* Enable or disable accelerators for the toplevel menus.

*/

void

gui_gtk_set_mnemonics(int enable)

{

vimmenu_T *menu;

char_u *name;

for (menu = root_menu; menu != NULL; menu = menu->next)

{

if (menu->id == NULL)

continue;

name = translate_mnemonic_tag(menu->name, enable);

gtk_label_set_text_with_mnemonic(GTK_LABEL(menu->label),

(const char *)name);

vim_free(name);

}

}

# if !GTK_CHECK_VERSION(3,4,0)

static void

recurse_tearoffs(vimmenu_T *menu, int val)

{

for (; menu != NULL; menu = menu->next)

{

if (menu->submenu_id != NULL && menu->tearoff_handle != NULL

&& menu->name[0] != ']' && !menu_is_popup(menu->name))

{

if (val)

gtk_widget_show(menu->tearoff_handle);

else

gtk_widget_hide(menu->tearoff_handle);

}

recurse_tearoffs(menu->children, val);

}

}

# endif

# if GTK_CHECK_VERSION(3,4,0)

void

gui_mch_toggle_tearoffs(int enable UNUSED)

{

/* Do nothing */

}

# else

void

gui_mch_toggle_tearoffs(int enable)

{

recurse_tearoffs(root_menu, enable);

}

# endif

#endif /* FEAT_MENU */

#if defined(FEAT_TOOLBAR)

static int

get_menu_position(vimmenu_T *menu)

{

vimmenu_T *node;

int idx = 0;

for (node = menu->parent->children; node != menu; node = node->next)

{

g_return_val_if_fail(node != NULL, -1);

++idx;

}

return idx;

}

#endif /* FEAT_TOOLBAR */

#if defined(FEAT_TOOLBAR) || defined(PROTO)

void

gui_mch_menu_set_tip(vimmenu_T *menu)

{

if (menu->id != NULL && menu->parent != NULL

&& gui.toolbar != NULL && menu_is_toolbar(menu->parent->name))

{

char_u *tooltip;

tooltip = CONVERT_TO_UTF8(menu->strings[MENU_INDEX_TIP]);

if (tooltip != NULL && utf_valid_string(tooltip, NULL))

# if GTK_CHECK_VERSION(3,0,0)

/* Only set the tooltip when it's valid utf-8. */

gtk_widget_set_tooltip_text(menu->id, (const gchar *)tooltip);

# else

/* Only set the tooltip when it's valid utf-8. */

gtk_tooltips_set_tip(GTK_TOOLBAR(gui.toolbar)->tooltips,

menu->id, (const char *)tooltip, NULL);

# endif

CONVERT_TO_UTF8_FREE(tooltip);

}

}

#endif /* FEAT_TOOLBAR */

#if defined(FEAT_MENU) || defined(PROTO)

/*

* Destroy the machine specific menu widget.

*/

void

gui_mch_destroy_menu(vimmenu_T *menu)

{

/* Don't let gtk_container_remove automatically destroy menu->id. */

if (menu->id != NULL)

g_object_ref(menu->id);

/* Workaround for a spurious gtk warning in Ubuntu: "Trying to remove

* a child that doesn't believe we're its parent."

* Remove widget from gui.menubar before destroying it. */

if (menu->id != NULL && gui.menubar != NULL

&& gtk_widget_get_parent(menu->id) == gui.menubar)

gtk_container_remove(GTK_CONTAINER(gui.menubar), menu->id);

# ifdef FEAT_TOOLBAR

if (menu->parent != NULL && menu_is_toolbar(menu->parent->name))

{

if (menu_is_separator(menu->name))

# if GTK_CHECK_VERSION(3,0,0)

{

GtkToolItem *item = NULL;

item = gtk_toolbar_get_nth_item(GTK_TOOLBAR(gui.toolbar),

get_menu_position(menu));

if (item != NULL)

gtk_container_remove(GTK_CONTAINER(gui.toolbar),

GTK_WIDGET(item));

}

# else

gtk_toolbar_remove_space(GTK_TOOLBAR(gui.toolbar),

get_menu_position(menu));

# endif

else if (menu->id != NULL)

gtk_widget_destroy(menu->id);

}

else

# endif /* FEAT_TOOLBAR */

{

if (menu->submenu_id != NULL)

gtk_widget_destroy(menu->submenu_id);

if (menu->id != NULL)

gtk_widget_destroy(menu->id);

}

if (menu->id != NULL)

g_object_unref(menu->id);

menu->submenu_id = NULL;

menu->id = NULL;

}

#endif /* FEAT_MENU */

/*

* Scrollbar stuff.

*/

void

gui_mch_set_scrollbar_thumb(scrollbar_T *sb, long val, long size, long max)

{

if (sb->id != NULL)

{

GtkAdjustment *adjustment;

adjustment = gtk_range_get_adjustment(GTK_RANGE(sb->id));

gtk_adjustment_set_lower(adjustment, 0.0);

gtk_adjustment_set_value(adjustment, val);

gtk_adjustment_set_upper(adjustment, max + 1);

gtk_adjustment_set_page_size(adjustment, size);

gtk_adjustment_set_page_increment(adjustment,

size < 3L ? 1L : size - 2L);

gtk_adjustment_set_step_increment(adjustment, 1.0);

g_signal_handler_block(G_OBJECT(adjustment), (gulong)sb->handler_id);

#if !GTK_CHECK_VERSION(3,18,0)

gtk_adjustment_changed(adjustment);

#endif

g_signal_handler_unblock(G_OBJECT(adjustment),

(gulong)sb->handler_id);