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

*

* VIM - Vi IMproved by Bram Moolenaar

* GUI/Motif support by Robert Webb

*

* 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.

*/

#include "vim.h"

// Structure containing all the GUI information

gui_T gui;

#if defined(FEAT_GUI_X11) && !defined(FEAT_GUI_GTK)

# define USE_SET_GUIFONTWIDE

static void set_guifontwide(char_u *font_name);

#endif

static void gui_check_pos(void);

static void gui_reset_scroll_region(void);

static void gui_outstr(char_u *, int);

static int gui_screenchar(int off, int flags, guicolor_T fg, guicolor_T bg, int back);

static int gui_outstr_nowrap(char_u *s, int len, int flags, guicolor_T fg, guicolor_T bg, int back);

static void gui_delete_lines(int row, int count);

static void gui_insert_lines(int row, int count);

static int gui_xy2colrow(int x, int y, int *colp);

#if defined(FEAT_GUI_TABLINE)

static int gui_has_tabline(void);

#endif

static void gui_do_scrollbar(win_T *wp, int which, int enable);

static void gui_update_horiz_scrollbar(int);

static void gui_set_fg_color(char_u *name);

static void gui_set_bg_color(char_u *name);

static void init_gui_options(void);

static win_T *xy2win(int x, int y, mouse_find_T popup);

#ifdef GUI_MAY_FORK

static void gui_do_fork(void);

static int gui_read_child_pipe(int fd);

// Return values for gui_read_child_pipe

enum {

GUI_CHILD_IO_ERROR,

GUI_CHILD_OK,

GUI_CHILD_FAILED

};

#endif

static void gui_attempt_start(void);

static int can_update_cursor = TRUE; // can display the cursor

static int disable_flush = 0; // If > 0, gui_mch_flush() is disabled.

/*

* gui_start -- Called when user wants to start the GUI.

*

* Careful: This function can be called recursively when there is a ":gui"

* command in the .gvimrc file. Only the first call should fork, not the

* recursive call.

*/

void

gui_start(char_u *arg UNUSED)

{

char_u *old_term;

#ifdef GUI_MAY_FORK

static int recursive = 0;

#endif

#if defined(GUI_MAY_SPAWN) && defined(EXPERIMENTAL_GUI_CMD)

char *msg = NULL;

#endif

old_term = vim_strsave(T_NAME);

settmode(TMODE_COOK); // stop RAW mode

if (full_screen)

cursor_on(); // needed for ":gui" in .vimrc

full_screen = FALSE;

// If GUI fails to start, then we will recover afterwards

term_disable_dec();

#ifdef GUI_MAY_FORK

++recursive;

/*

* Quit the current process and continue in the child.

* Makes "gvim file" disconnect from the shell it was started in.

* Don't do this when Vim was started with "-f" or the 'f' flag is present

* in 'guioptions'.

* Don't do this when there is a running job, we can only get the status

* of a child from the parent.

*/

if (gui.dofork && !vim_strchr(p_go, GO_FORG) && recursive <= 1

# ifdef FEAT_JOB_CHANNEL

&& !job_any_running()

# endif

)

{

gui_do_fork();

}

else

#endif

#ifdef GUI_MAY_SPAWN

if (gui.dospawn

# ifdef EXPERIMENTAL_GUI_CMD

&& gui.dofork

# endif

&& !vim_strchr(p_go, GO_FORG)

&& !anyBufIsChanged()

# ifdef FEAT_JOB_CHANNEL

&& !job_any_running()

# endif

)

{

# ifdef EXPERIMENTAL_GUI_CMD

msg =

# endif

gui_mch_do_spawn(arg);

}

else

#endif

{

#ifdef FEAT_GUI_GTK

// If there is 'f' in 'guioptions' and specify -g argument,

// gui_mch_init_check() was not called yet.

if (gui_mch_init_check() != OK)

getout_preserve_modified(1);

#endif

gui_attempt_start();

}

if (!gui.in_use) // failed to start GUI

{

// Back to old term settings

//

// FIXME: If we got here because a child process failed and flagged to

// the parent to resume, and X11 is enabled, this will

// hit an X11 I/O error and do a longjmp(), leaving recursive

// permanently set to 1. This is probably not as big a problem as it

// sounds, because gui_mch_init() in both gui_x11.c and gui_gtk_x11.c

// return "OK" unconditionally, so it would be very difficult to

// actually hit this case.

termcapinit(old_term);

settmode(TMODE_RAW); // restart RAW mode

set_title_defaults(); // set 'title' and 'icon' again

#ifdef UNIX

term_set_win_resize(true);

#endif

#if defined(GUI_MAY_SPAWN) && defined(EXPERIMENTAL_GUI_CMD)

if (msg != NULL)

emsg(msg);

#endif

}

#ifdef HAVE_CLIPMETHOD

else

// Reset clipmethod to CLIPMETHOD_NONE

choose_clipmethod();

#endif

#if defined(FEAT_SOCKETSERVER) && defined(FEAT_GUI_GTK)

// Install socket server listening socket if we are running it

if (socket_server_valid())

gui_gtk_init_socket_server();

#endif

#ifdef FEAT_GUI_MSWIN

// Enable fullscreen mode

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

gui_mch_set_fullscreen(TRUE);

#endif

vim_free(old_term);

// If the GUI started successfully, trigger the GUIEnter event, otherwise

// the GUIFailed event.

gui_mch_update();

apply_autocmds(gui.in_use ? EVENT_GUIENTER : EVENT_GUIFAILED,

NULL, NULL, FALSE, curbuf);

#ifdef GUI_MAY_FORK

--recursive;

#endif

}

/*

* Set_termname() will call gui_init() to start the GUI.

* Set the "starting" flag, to indicate that the GUI will start.

*

* We don't want to open the GUI shell until after we've read .gvimrc,

* otherwise we don't know what font we will use, and hence we don't know

* what size the shell should be. So if there are errors in the .gvimrc

* file, they will have to go to the terminal: Set full_screen to FALSE.

* full_screen will be set to TRUE again by a successful termcapinit().

*/

static void

gui_attempt_start(void)

{

static int recursive = 0;

++recursive;

gui.starting = true;

#ifdef FEAT_GUI_GTK

gui.event_time = GDK_CURRENT_TIME;

#endif

termcapinit((char_u *)"builtin_gui");

gui.starting = recursive - 1;

#if defined(FEAT_GUI_GTK) || defined(FEAT_GUI_X11)

if (gui.in_use)

{

# ifdef FEAT_EVAL

Window x11_window;

Display *x11_display;

if (gui_get_x11_windis(&x11_window, &x11_display) == OK)

set_vim_var_nr(VV_WINDOWID, (long)x11_window);

# endif

// Display error messages in a dialog now.

display_errors();

}

#endif

--recursive;

}

#ifdef GUI_MAY_FORK

// for waitpid()

# if defined(HAVE_SYS_WAIT_H)

# include <sys/wait.h>

# endif

/*

* Create a new process, by forking. In the child, start the GUI, and in

* the parent, exit.

*

* If something goes wrong, this will return with gui.in_use still set

* to FALSE, in which case the caller should continue execution without

* the GUI.

*

* If the child fails to start the GUI, then the child will exit and the

* parent will return. If the child succeeds, then the parent will exit

* and the child will return.

*/

static void

gui_do_fork(void)

{

int pipefd[2]; // pipe between parent and child

int pipe_error;

int status;

int exit_status;

pid_t pid = -1;

# if defined(FEAT_RELTIME) && defined(PROF_NSEC)

// a timer is not carried forward

delete_timer();

# endif

// Setup a pipe between the child and the parent, so that the parent

// knows when the child has done the setsid() call and is allowed to

// exit.

pipe_error = (pipe(pipefd) < 0);

pid = fork();

if (pid < 0) // Fork error

{

emsg(_(e_failed_to_create_new_process_for_GUI));

return;

}

else if (pid > 0) // Parent

{

// Give the child some time to do the setsid(), otherwise the

// exit() may kill the child too (when starting gvim from inside a

// gvim).

if (!pipe_error)

{

// The read returns when the child closes the pipe (or when

// the child dies for some reason).

close(pipefd[1]);

status = gui_read_child_pipe(pipefd[0]);

if (status == GUI_CHILD_FAILED)

{

// The child failed to start the GUI, so the caller must

// continue. There may be more error information written

// to stderr by the child.

waitpid(pid, &exit_status, 0);

emsg(_(e_the_child_process_failed_to_start_GUI));

return;

}

else if (status == GUI_CHILD_IO_ERROR)

{

pipe_error = TRUE;

}

// else GUI_CHILD_OK: parent exit

}

if (pipe_error)

ui_delay(301L, TRUE);

// When swapping screens we may need to go to the next line, e.g.,

// after a hit-enter prompt and using ":gui".

if (newline_on_exit)

mch_errmsg("\r\n");

/*

* The parent must skip the normal exit() processing, the child

* will do it. For example, GTK messes up signals when exiting.

*/

_exit(0);

}

// Child

# ifdef FEAT_GUI_GTK

// Call gtk_init_check() here after fork(). See gui_init_check().

if (gui_mch_init_check() != OK)

getout_preserve_modified(1);

# endif

# if defined(HAVE_SETSID) || defined(HAVE_SETPGID)

/*

* Change our process group. On some systems/shells a CTRL-C in the

* shell where Vim was started would otherwise kill gvim!

*/

# if defined(HAVE_SETSID)

(void)setsid();

# else

(void)setpgid(0, 0);

# endif

# endif

if (!pipe_error)

close(pipefd[0]);

# if defined(FEAT_GUI_GNOME) && defined(FEAT_SESSION)

// Tell the session manager our new PID

gui_mch_forked();

# endif

// Try to start the GUI

gui_attempt_start();

// Notify the parent

if (!pipe_error)

{

if (gui.in_use)

write_eintr(pipefd[1], "ok", 3);

else

write_eintr(pipefd[1], "fail", 5);

close(pipefd[1]);

}

// If we failed to start the GUI, exit now.

if (!gui.in_use)

getout_preserve_modified(1);

}

/*

* Read from a pipe assumed to be connected to the child process (this

* function is called from the parent).

* Return GUI_CHILD_OK if the child successfully started the GUI,

* GUY_CHILD_FAILED if the child failed, or GUI_CHILD_IO_ERROR if there was

* some other error.

*

* The file descriptor will be closed before the function returns.

*/

static int

gui_read_child_pipe(int fd)

{

long bytes_read;

# define READ_BUFFER_SIZE 10

char buffer[READ_BUFFER_SIZE];

bytes_read = read_eintr(fd, buffer, READ_BUFFER_SIZE - 1);

# undef READ_BUFFER_SIZE

close(fd);

if (bytes_read < 0)

return GUI_CHILD_IO_ERROR;

buffer[bytes_read] = NUL;

if (STRCMP(buffer, "ok") == 0)

return GUI_CHILD_OK;

return GUI_CHILD_FAILED;

}

#endif // GUI_MAY_FORK

/*

* Call this when vim starts up, whether or not the GUI is started

*/

void

gui_prepare(int *argc, char **argv)

{

gui.in_use = false; // No GUI yet (maybe later)

gui.starting = false; // No GUI yet (maybe later)

gui_mch_prepare(argc, argv);

}

/*

* Try initializing the GUI and check if it can be started.

* Used from main() to check early if "vim -g" can start the GUI.

* Used from gui_init() to prepare for starting the GUI.

* Returns FAIL or OK.

*/

int

gui_init_check(void)

{

static int result = MAYBE;

if (result != MAYBE)

{

if (result == FAIL)

emsg(_(e_cannot_start_the_GUI));

return result;

}

gui.shell_created = false;

gui.dying = false;

gui.in_focus = true; // so the guicursor setting works

gui.dragged_sb = SBAR_NONE;

gui.dragged_wp = NULL;

gui.pointer_hidden = false;

gui.col = 0;

gui.row = 0;

gui.num_cols = Columns;

gui.num_rows = Rows;

gui.cursor_is_valid = false;

gui.scroll_region_top = 0;

gui.scroll_region_bot = Rows - 1;

gui.scroll_region_left = 0;

gui.scroll_region_right = Columns - 1;

gui.highlight_mask = HL_NORMAL;

gui.char_width = 1;

gui.char_height = 1;

gui.char_ascent = 0;

gui.border_width = 0;

gui.norm_font = NOFONT;

#ifndef FEAT_GUI_GTK

gui.bold_font = NOFONT;

gui.ital_font = NOFONT;

gui.boldital_font = NOFONT;

# ifdef FEAT_XFONTSET

gui.fontset = NOFONTSET;

# endif

#endif

gui.wide_font = NOFONT;

#ifndef FEAT_GUI_GTK

gui.wide_bold_font = NOFONT;

gui.wide_ital_font = NOFONT;

gui.wide_boldital_font = NOFONT;

#endif

#ifdef FEAT_MENU

# ifndef FEAT_GUI_GTK

# ifdef FONTSET_ALWAYS

gui.menu_fontset = NOFONTSET;

# else

gui.menu_font = NOFONT;

# endif

# endif

gui.menu_is_active = true; // default: include menu

# ifndef FEAT_GUI_GTK

gui.menu_height = MENU_DEFAULT_HEIGHT;

gui.menu_width = 0;

# endif

#endif

#if defined(FEAT_TOOLBAR) && (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_HAIKU))

gui.toolbar_height = 0;

#endif

#ifdef FEAT_BEVAL_TIP

gui.tooltip_fontset = NOFONTSET;

#endif

gui.scrollbar_width = gui.scrollbar_height = SB_DEFAULT_WIDTH;

gui.prev_wrap = -1;

#if defined(FEAT_GUI_GTK) || defined(FEAT_GUI_MSWIN)

// Note: gui_set_ligatures() might already have been called e.g. from .vimrc,

// and in that case we don't want to overwrite ligatures map that has already

// been correctly populated (as that would lead to a cleared ligatures maps).

if (*p_guiligatures == NUL)

CLEAR_FIELD(gui.ligatures_map);

#endif

#if defined(ALWAYS_USE_GUI) || defined(VIMDLL)

result = OK;

#else

# ifdef FEAT_GUI_GTK

# ifdef GDK_WINDOWING_WAYLAND

gui.is_wayland = false;

# endif

/*

* Note: Don't call gtk_init_check() before fork, it will be called after

* the fork. When calling it before fork, it make vim hang for a while.

* See gui_do_fork().

* Use a simpler check if the GUI window can probably be opened.

*/

result = gui.dofork ? gui_mch_early_init_check(TRUE) : gui_mch_init_check();

# else

result = gui_mch_init_check();

# endif

#endif

return result;

}

/*

* This is the call which starts the GUI.

*/

void

gui_init(void)

{

win_T *wp;

tabpage_T *tp;

static int recursive = 0;

/*

* It's possible to use ":gui" in a .gvimrc file. The first half of this

* function will then be executed at the first call, the rest by the

* recursive call. This allow the shell to be opened halfway reading a

* gvimrc file.

*/

if (!recursive)

{

++recursive;

clip_init(TRUE);

// If can't initialize, don't try doing the rest

if (gui_init_check() == FAIL)

{

--recursive;

clip_init(FALSE);

return;

}

/*

* Reset 'paste'. It's useful in the terminal, but not in the GUI. It

* breaks the Paste toolbar button.

*/

set_option_value_give_err((char_u *)"paste", 0L, NULL, 0);

// Set t_Co to the number of colors: RGB.

set_color_count(256 * 256 * 256);

/*

* Set up system-wide default menus.

*/

#if defined(SYS_MENU_FILE) && defined(FEAT_MENU)

if (vim_strchr(p_go, GO_NOSYSMENU) == NULL)

{

sys_menu = TRUE;

do_source((char_u *)SYS_MENU_FILE, FALSE, DOSO_NONE, NULL);

sys_menu = FALSE;

}

#endif

/*

* Switch on the mouse by default, unless the user changed it already.

* This can then be changed in the .gvimrc.

*/

if (!option_was_set((char_u *)"mouse"))

set_string_option_direct((char_u *)"mouse", -1,

(char_u *)"a", OPT_FREE, SID_NONE);

/*

* If -U option given, use only the initializations from that file and

* nothing else. Skip all initializations for "-U NONE" or "-u NORC".

*/

if (use_gvimrc != NULL)

{

if (STRCMP(use_gvimrc, "NONE") != 0

&& STRCMP(use_gvimrc, "NORC") != 0

&& do_source(use_gvimrc, FALSE, DOSO_NONE, NULL) != OK)

semsg(_(e_cannot_read_from_str), use_gvimrc);

}

else

{

/*

* Get system wide defaults for gvim, only when file name defined.

*/

#ifdef SYS_GVIMRC_FILE

do_source((char_u *)SYS_GVIMRC_FILE, FALSE, DOSO_NONE, NULL);

#endif

/*

* Try to read GUI initialization commands from the following

* places:

* - environment variable GVIMINIT

* - the user gvimrc file (~/.gvimrc)

* - the second user gvimrc file ($VIM/.gvimrc for Dos)

* - the third user gvimrc file ($VIM/.gvimrc for Amiga)

* The first that exists is used, the rest is ignored.

*/

if (process_env((char_u *)"GVIMINIT", FALSE) == FAIL

&& do_source((char_u *)USR_GVIMRC_FILE, TRUE,

DOSO_GVIMRC, NULL) == FAIL

#ifdef USR_GVIMRC_FILE2

&& do_source((char_u *)USR_GVIMRC_FILE2, TRUE,

DOSO_GVIMRC, NULL) == FAIL

#endif

#ifdef USR_GVIMRC_FILE3

&& do_source((char_u *)USR_GVIMRC_FILE3, TRUE,

DOSO_GVIMRC, NULL) == FAIL

#endif

)

{

#ifdef USR_GVIMRC_FILE4

(void)do_source((char_u *)USR_GVIMRC_FILE4, TRUE,

DOSO_GVIMRC, NULL);

#endif

}

/*

* Read initialization commands from ".gvimrc" in current

* directory. This is only done if the 'exrc' option is set.

* Because of security reasons we disallow shell and write

* commands now, except for unix if the file is owned by the user

* or 'secure' option has been reset in environment of global

* ".gvimrc".

* Only do this if GVIMRC_FILE is not the same as USR_GVIMRC_FILE,

* USR_GVIMRC_FILE2, USR_GVIMRC_FILE3 or SYS_GVIMRC_FILE.

*/

if (p_exrc)

{

#ifdef UNIX

{

stat_T s;

// if ".gvimrc" file is not owned by user, set 'secure'

// mode

if (mch_stat(GVIMRC_FILE, &s) || s.st_uid != getuid())

secure = p_secure;

}

#else

secure = p_secure;

#endif

if ( fullpathcmp((char_u *)USR_GVIMRC_FILE,

(char_u *)GVIMRC_FILE, FALSE, TRUE) != FPC_SAME

#ifdef SYS_GVIMRC_FILE

&& fullpathcmp((char_u *)SYS_GVIMRC_FILE,

(char_u *)GVIMRC_FILE, FALSE, TRUE) != FPC_SAME

#endif

#ifdef USR_GVIMRC_FILE2

&& fullpathcmp((char_u *)USR_GVIMRC_FILE2,

(char_u *)GVIMRC_FILE, FALSE, TRUE) != FPC_SAME

#endif

#ifdef USR_GVIMRC_FILE3

&& fullpathcmp((char_u *)USR_GVIMRC_FILE3,

(char_u *)GVIMRC_FILE, FALSE, TRUE) != FPC_SAME

#endif

#ifdef USR_GVIMRC_FILE4

&& fullpathcmp((char_u *)USR_GVIMRC_FILE4,

(char_u *)GVIMRC_FILE, FALSE, TRUE) != FPC_SAME

#endif

)

do_source((char_u *)GVIMRC_FILE, TRUE, DOSO_GVIMRC, NULL);

if (secure == 2)

need_wait_return = TRUE;

secure = 0;

}

}

if (need_wait_return || msg_didany)

wait_return(TRUE);

--recursive;

}

// If recursive call opened the shell, return here from the first call

if (gui.in_use)

return;

/*

* Create the GUI shell.

*/

gui.in_use = true; // Must be set after menus have been set up

if (gui_mch_init() == FAIL)

goto error;

// Avoid a delay for an error message that was printed in the terminal

// where Vim was started.

emsg_on_display = FALSE;

msg_scrolled = 0;

clear_sb_text(TRUE);

need_wait_return = FALSE;

msg_didany = FALSE;

/*

* Check validity of any generic resources that may have been loaded.

*/

if (gui.border_width < 0)

gui.border_width = 0;

/*

* Set up the fonts. First use a font specified with "-fn" or "-font".

*/

if (font_argument != NULL)

set_option_value_give_err((char_u *)"gfn",

0L, (char_u *)font_argument, 0);

if (

#ifdef FEAT_XFONTSET

(*p_guifontset == NUL

|| gui_init_font(p_guifontset, TRUE) == FAIL) &&

#endif

gui_init_font(*p_guifont == NUL ? hl_get_font_name()

: p_guifont, FALSE) == FAIL)

{

emsg(_(e_cannot_start_gui_no_valid_font_found));

goto error2;

}

if (gui_get_wide_font() == FAIL)

emsg(_(e_guifontwide_invalid));

gui.num_cols = Columns;

gui.num_rows = Rows;

gui_reset_scroll_region();

// Create initial scrollbars

FOR_ALL_TAB_WINDOWS(tp, wp)

{

gui_create_scrollbar(&wp->w_scrollbars[SBAR_LEFT], SBAR_LEFT, wp);

gui_create_scrollbar(&wp->w_scrollbars[SBAR_RIGHT], SBAR_RIGHT, wp);

}

gui_create_scrollbar(&gui.bottom_sbar, SBAR_BOTTOM, NULL);

#ifdef FEAT_MENU

gui_create_initial_menus(root_menu);

#endif

#ifdef FEAT_SIGN_ICONS

sign_gui_started();

#endif

// Configure the desired menu and scrollbars

gui_init_which_components(NULL);

// All components of the GUI have been created now

gui.shell_created = true;

#ifdef FEAT_GUI_MSWIN

// Set the shell size, adjusted for the screen size. For GTK this only

// works after the shell has been opened, thus it is further down.

// If the window is already maximized (e.g. when --windowid is passed in),

// we want to use the system-provided dimensions by passing FALSE to

// mustset. Otherwise, we want to initialize with the default rows/columns.

if (gui_mch_maximized())

gui_set_shellsize(FALSE, TRUE, RESIZE_BOTH);

else

gui_set_shellsize(TRUE, TRUE, RESIZE_BOTH);

#else

# ifndef FEAT_GUI_GTK

gui_set_shellsize(FALSE, TRUE, RESIZE_BOTH);

# endif

#endif

#if defined(FEAT_GUI_MOTIF) && defined(FEAT_MENU)

// Need to set the size of the menubar after all the menus have been

// created.

gui_mch_compute_menu_height((Widget)0);

#endif

/*

* Actually open the GUI shell.

*/

if (gui_mch_open() != FAIL)

{

maketitle();

resettitle();

init_gui_options();

#ifdef FEAT_ARABIC

// Our GUI can't do bidi.

p_tbidi = FALSE;

#endif

#if defined(FEAT_GUI_GTK)

// Give GTK+ a chance to put all widget's into place.

gui_mch_update();

# ifdef FEAT_MENU

// If there is no 'm' in 'guioptions' we need to remove the menu now.

// It was still there to make F10 work.

if (vim_strchr(p_go, GO_MENUS) == NULL)

{

bool save_starting = gui.starting;

gui.starting = false;

gui_mch_enable_menu(FALSE);

gui.starting = save_starting;

gui_mch_update();

}

# endif

// Now make sure the shell fits on the screen.

if (gui_mch_maximized())

gui_set_shellsize(FALSE, TRUE, RESIZE_BOTH);

else

gui_set_shellsize(TRUE, TRUE, RESIZE_BOTH);

#endif

// When 'lines' was set while starting up the topframe may have to be

// resized.

win_new_shellsize();

#ifdef FEAT_BEVAL_GUI

// Always create the Balloon Evaluation area, but disable it when

// 'ballooneval' is off.

if (balloonEval != NULL)

{

# ifdef FEAT_VARTABS

vim_free(balloonEval->vts);

# endif

vim_free(balloonEval);

}

balloonEvalForTerm = FALSE;

# ifdef FEAT_GUI_GTK

balloonEval = gui_mch_create_beval_area(gui.drawarea, NULL,

&general_beval_cb, NULL);

# else

# if defined(FEAT_GUI_MOTIF)

{

extern Widget textArea;

balloonEval = gui_mch_create_beval_area(textArea, NULL,

&general_beval_cb, NULL);

}

# else

# ifdef FEAT_GUI_MSWIN

balloonEval = gui_mch_create_beval_area(NULL, NULL,

&general_beval_cb, NULL);

# endif

# endif

# endif

if (!p_beval)

gui_mch_disable_beval_area(balloonEval);

#endif

#ifndef FEAT_GUI_MSWIN

// In the GUI modifiers are prepended to keys.

// Don't do this for MS-Windows yet, it sends CTRL-K without the

// modifier.

seenModifyOtherKeys = TRUE;

#endif

#if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)

if (!im_xim_isvalid_imactivate())

emsg(_(e_value_of_imactivatekey_is_invalid));

#endif

// When 'cmdheight' was set during startup it may not have taken

// effect yet.

if (p_ch != 1L)

command_height();

return;

}

error2:

#ifdef FEAT_GUI_X11

// undo gui_mch_init()

gui_mch_uninit();

#endif

error:

gui.in_use = false;

clip_init(FALSE);

}

void

gui_exit(int rc)

{

// don't free the fonts, it leads to a BUS error

// richard@whitequeen.com Jul 99

free_highlight_fonts();

gui.in_use = false;

gui_mch_exit(rc);

}

#if defined(FEAT_GUI_GTK) || defined(FEAT_GUI_X11) || defined(FEAT_GUI_MSWIN) \

|| defined(FEAT_GUI_PHOTON)

# define NEED_GUI_UPDATE_SCREEN 1

/*

* Called when the GUI shell is closed by the user. If there are no changed

* files Vim exits, otherwise there will be a dialog to ask the user what to

* do.

* When this function returns, Vim should NOT exit!

*/

void

gui_shell_closed(void)

{

cmdmod_T save_cmdmod = cmdmod;

if (before_quit_autocmds(curwin, TRUE, FALSE))

return;

// Only exit when there are no changed files

exiting = TRUE;

# ifdef FEAT_BROWSE

cmdmod.cmod_flags |= CMOD_BROWSE;

# endif

# if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)

cmdmod.cmod_flags |= CMOD_CONFIRM;

# endif

// If there are changed buffers, present the user with a dialog if

// possible, otherwise give an error message.

if (!check_changed_any(FALSE, FALSE))

getout(0);

exiting = FALSE;

cmdmod = save_cmdmod;

gui_update_screen(); // redraw, window may show changed buffer

}

#endif

/*

* Set the font. "font_list" is a comma separated list of font names. The

* first font name that works is used. If none is found, use the default

* font.

* If "fontset" is TRUE, the "font_list" is used as one name for the fontset.

* Return OK when able to set the font. When it failed FAIL is returned and

* the fonts are unchanged.

*/

int

gui_init_font(char_u *font_list, int fontset UNUSED)

{

#define FONTLEN 320

char_u font_name[FONTLEN];

int font_list_empty = FALSE;

int ret = FAIL;

if (!gui.in_use)

return FAIL;

font_name[0] = NUL;

if (*font_list == NUL)

font_list_empty = TRUE;

else

{

#ifdef FEAT_XFONTSET

// When using a fontset, the whole list of fonts is one name.

if (fontset)

ret = gui_mch_init_font(font_list, TRUE);

else

#endif

while (*font_list != NUL)

{

// Isolate one comma separated font name.

(void)copy_option_part(&font_list, font_name, FONTLEN, ",");

// Careful!!! The Win32 version of gui_mch_init_font(), when

// called with "*" will change p_guifont to the selected font

// name, which frees the old value. This makes font_list

// invalid. Thus when OK is returned here, font_list must no

// longer be used!

if (gui_mch_init_font(font_name, FALSE) == OK)

{

#ifdef USE_SET_GUIFONTWIDE

// If it's a Unicode font, try setting 'guifontwide' to a

// similar double-width font.

if ((p_guifontwide == NULL || *p_guifontwide == NUL)

&& strstr((char *)font_name, "10646") != NULL)

set_guifontwide(font_name);

#endif

ret = OK;

break;

}

}

}

if (ret != OK

&& STRCMP(font_list, "*") != 0

&& (font_list_empty || gui.norm_font == NOFONT))

{

/*

* Couldn't load any font in 'font_list', keep the current font if

* there is one. If 'font_list' is empty, or if there is no current

* font, tell gui_mch_init_font() to try to find a font we can load.

*/

ret = gui_mch_init_font(NULL, FALSE);

}

if (ret == OK)

{

#ifndef FEAT_GUI_GTK

// Set normal font as current font

# ifdef FEAT_XFONTSET

if (gui.fontset != NOFONTSET)

gui_mch_set_fontset(gui.fontset);

else

# endif

gui_mch_set_font(gui.norm_font);

#endif

gui_set_shellsize(FALSE, TRUE, RESIZE_BOTH);

}

return ret;

}

#ifdef USE_SET_GUIFONTWIDE

/*

* Try setting 'guifontwide' to a font twice as wide as "name".

*/

static void

set_guifontwide(char_u *name)