nyx/vim
1
0
Fork 0
mirror of https://github.com/vim/vim synced 2025-03-16 14:57:52 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
vim/src/gui.c
Yee Cheng Chin a5e03f68a8
patch 9.1.1079: GUI late startup leads to uninitialized scrollbars 
Problem:  GUI late startup leads to uninitialized scrollbars
Solution: initialize scrollbars for all windows in all tabpages
          (Yee Cheng Chin)

GUI startup was erroneously only initializing scrollbars for all windows
in current tab, instead of all tabs. This breaks if the user has created
tab pages before using `:gui` command to enter GUI mode, or sourced a
session file in vimrc.

closes: #16588
related: macvim-dev/macvim#862

Signed-off-by: Yee Cheng Chin <ychin.git@gmail.com>
Signed-off-by: Christian Brabandt <cb@256bit.org>
2025-02-06 21:18:17 +01:00

5544 lines
137 KiB
C
Raw Permalink Blame History

/* 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) || defined(PROTO)
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;
#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
#if defined(GUI_MAY_SPAWN) && defined(EXPERIMENTAL_GUI_CMD)
if (msg != NULL)
emsg(msg);
#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) || defined(HAVE_UNION_WAIT)
# 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.
# ifdef __NeXT__
wait4(pid, &exit_status, 0, (struct rusage *)0);
# else
waitpid(pid, &exit_status, 0);
# endif
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
/*
* 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)
{
--gui.starting;
gui_mch_enable_menu(FALSE);
++gui.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) || defined(PROTO)
# 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)
{
int i = 0;
char_u wide_name[FONTLEN + 10]; // room for 2 * width and '*'
char_u *wp = NULL;
char_u *p;
GuiFont font;
wp = wide_name;
for (p = name; *p != NUL; ++p)
{
*wp++ = *p;
if (*p == '-')
{
++i;
if (i == 6) // font type: change "--" to "-*-"
{
if (p[1] == '-')
*wp++ = '*';
}
else if (i == 12) // found the width
{
++p;
i = getdigits(&p);
if (i != 0)
{
// Double the width specification.
sprintf((char *)wp, "%d%s", i * 2, p);
font = gui_mch_get_font(wide_name, FALSE);
if (font != NOFONT)
{
gui_mch_free_font(gui.wide_font);
gui.wide_font = font;
set_string_option_direct((char_u *)"gfw", -1,
wide_name, OPT_FREE, 0);
}
}
break;
}
}
}
}
#endif
/*
* Get the font for 'guifontwide'.
* Return FAIL for an invalid font name.
*/
int
gui_get_wide_font(void)
{
GuiFont font = NOFONT;
char_u font_name[FONTLEN];
char_u *p;
if (!gui.in_use) // Can't allocate font yet, assume it's OK.
return OK; // Will give an error message later.
if (p_guifontwide != NULL && *p_guifontwide != NUL)
{
for (p = p_guifontwide; *p != NUL; )
{
// Isolate one comma separated font name.
(void)copy_option_part(&p, font_name, FONTLEN, ",");
font = gui_mch_get_font(font_name, FALSE);
if (font != NOFONT)
break;
}
if (font == NOFONT)
return FAIL;
}
gui_mch_free_font(gui.wide_font);
#ifdef FEAT_GUI_GTK
// Avoid unnecessary overhead if 'guifontwide' is equal to 'guifont'.
if (font != NOFONT && gui.norm_font != NOFONT
&& pango_font_description_equal(font, gui.norm_font))
{
gui.wide_font = NOFONT;
gui_mch_free_font(font);
}
else
#endif
gui.wide_font = font;
#ifdef FEAT_GUI_MSWIN
gui_mch_wide_font_changed();
#else
/*
* TODO: setup wide_bold_font, wide_ital_font and wide_boldital_font to
* support those fonts for 'guifontwide'.
*/
#endif
return OK;
}
#if defined(FEAT_GUI_GTK) || defined(FEAT_GUI_MSWIN) || defined(PROTO)
/*
* Set list of ascii characters that combined can create ligature.
* Store them in char map for quick access from gui_gtk2_draw_string.
*/
void
gui_set_ligatures(void)
{
char_u *p;
if (*p_guiligatures != NUL)
{
// check for invalid characters
for (p = p_guiligatures; *p != NUL; ++p)
if (*p < 32 || *p > 127)
{
emsg(_(e_ascii_code_not_in_range));
return;
}
// store valid setting into ligatures_map
CLEAR_FIELD(gui.ligatures_map);
for (p = p_guiligatures; *p != NUL; ++p)
gui.ligatures_map[*p] = 1;
}
else
CLEAR_FIELD(gui.ligatures_map);
}
/*
* Adjust the columns to undraw for when the cursor is on ligatures.
*/
static void
gui_adjust_undraw_cursor_for_ligatures(int *startcol, int *endcol)
{
int off;
if (ScreenLines == NULL || *p_guiligatures == NUL)
return;
// expand before the cursor for all the chars in gui.ligatures_map
off = LineOffset[gui.cursor_row] + *startcol;
if (gui.ligatures_map[ScreenLines[off]])
while (*startcol > 0 && gui.ligatures_map[ScreenLines[--off]])
(*startcol)--;
// expand after the cursor for all the chars in gui.ligatures_map
off = LineOffset[gui.cursor_row] + *endcol;
if (gui.ligatures_map[ScreenLines[off]])
while (*endcol < ((int)screen_Columns - 1)
&& gui.ligatures_map[ScreenLines[++off]])
(*endcol)++;
}
#endif
static void
gui_set_cursor(int row, int col)
{
gui.row = row;
gui.col = col;
}
/*
* gui_check_pos - check if the cursor is on the screen.
*/
static void
gui_check_pos(void)
{
if (gui.row >= screen_Rows)
gui.row = screen_Rows - 1;
if (gui.col >= screen_Columns)
gui.col = screen_Columns - 1;
if (gui.cursor_row >= screen_Rows || gui.cursor_col >= screen_Columns)
gui.cursor_is_valid = FALSE;
}
/*
* Redraw the cursor if necessary or when forced.
* Careful: The contents of ScreenLines[] must match what is on the screen,
* otherwise this goes wrong. May need to call out_flush() first.
*/
void
gui_update_cursor(
int force, // when TRUE, update even when not moved
int clear_selection) // clear selection under cursor
{
int cur_width = 0;
int cur_height = 0;
int old_hl_mask;
cursorentry_T *shape;
int id;
#ifdef FEAT_TERMINAL
guicolor_T shape_fg = INVALCOLOR;
guicolor_T shape_bg = INVALCOLOR;
#endif
guicolor_T cfg, cbg, cc; // cursor fore-/background color
int cattr; // cursor attributes
int attr;
attrentry_T *aep = NULL;
// Don't update the cursor when halfway busy scrolling or the screen size
// doesn't match 'columns' and 'lines. ScreenLines[] isn't valid then.
if (!can_update_cursor || screen_Columns != gui.num_cols
|| screen_Rows != gui.num_rows)
return;
gui_check_pos();
if (gui.cursor_is_valid && !force
&& gui.row == gui.cursor_row && gui.col == gui.cursor_col)
return;
gui_undraw_cursor();
// If a cursor-less sleep is ongoing, leave the cursor invisible
if (cursor_is_sleeping())
return;
if (gui.row < 0)
return;
#ifdef HAVE_INPUT_METHOD
if (gui.row != gui.cursor_row || gui.col != gui.cursor_col)
im_set_position(gui.row, gui.col);
#endif
gui.cursor_row = gui.row;
gui.cursor_col = gui.col;
// Only write to the screen after ScreenLines[] has been initialized
if (!screen_cleared || ScreenLines == NULL)
return;
// Clear the selection if we are about to write over it
if (clear_selection)
clip_may_clear_selection(gui.row, gui.row);
// Check that the cursor is inside the shell (resizing may have made
// it invalid)
if (gui.row >= screen_Rows || gui.col >= screen_Columns)
return;
gui.cursor_is_valid = TRUE;
/*
* How the cursor is drawn depends on the current mode.
* When in a terminal window use the shape/color specified there.
*/
#ifdef FEAT_TERMINAL
if (terminal_is_active())
shape = term_get_cursor_shape(&shape_fg, &shape_bg);
else
#endif
shape = &shape_table[get_shape_idx(FALSE)];
if (State & MODE_LANGMAP)
id = shape->id_lm;
else
id = shape->id;
// get the colors and attributes for the cursor. Default is inverted
cfg = INVALCOLOR;
cbg = INVALCOLOR;
cattr = HL_INVERSE;
gui_mch_set_blinking(shape->blinkwait,
shape->blinkon,
shape->blinkoff);
if (shape->blinkwait == 0 || shape->blinkon == 0
|| shape->blinkoff == 0)
gui_mch_stop_blink(FALSE);
#ifdef FEAT_TERMINAL
if (shape_bg != INVALCOLOR)
{
cattr = 0;
cfg = shape_fg;
cbg = shape_bg;
}
else
#endif
if (id > 0)
{
cattr = syn_id2colors(id, &cfg, &cbg);
#if defined(HAVE_INPUT_METHOD)
{
static int iid;
guicolor_T fg, bg;
if (
# if defined(FEAT_GUI_GTK) && defined(FEAT_XIM)
preedit_get_status()
# else
im_get_status()
# endif
)
{
iid = syn_name2id((char_u *)"CursorIM");
if (iid > 0)
{
syn_id2colors(iid, &fg, &bg);
if (bg != INVALCOLOR)
cbg = bg;
if (fg != INVALCOLOR)
cfg = fg;
}
}
}
#endif
}
/*
* Get the attributes for the character under the cursor.
* When no cursor color was given, use the character color.
*/
attr = ScreenAttrs[LineOffset[gui.row] + gui.col];
if (attr > HL_ALL)
aep = syn_gui_attr2entry(attr);
if (aep != NULL)
{
attr = aep->ae_attr;
if (cfg == INVALCOLOR)
cfg = ((attr & HL_INVERSE) ? aep->ae_u.gui.bg_color
: aep->ae_u.gui.fg_color);
if (cbg == INVALCOLOR)
cbg = ((attr & HL_INVERSE) ? aep->ae_u.gui.fg_color
: aep->ae_u.gui.bg_color);
}
if (cfg == INVALCOLOR)
cfg = (attr & HL_INVERSE) ? gui.back_pixel : gui.norm_pixel;
if (cbg == INVALCOLOR)
cbg = (attr & HL_INVERSE) ? gui.norm_pixel : gui.back_pixel;
#ifdef FEAT_XIM
if (aep != NULL)
{
xim_bg_color = ((attr & HL_INVERSE) ? aep->ae_u.gui.fg_color
: aep->ae_u.gui.bg_color);
xim_fg_color = ((attr & HL_INVERSE) ? aep->ae_u.gui.bg_color
: aep->ae_u.gui.fg_color);
if (xim_bg_color == INVALCOLOR)
xim_bg_color = (attr & HL_INVERSE) ? gui.norm_pixel
: gui.back_pixel;
if (xim_fg_color == INVALCOLOR)
xim_fg_color = (attr & HL_INVERSE) ? gui.back_pixel
: gui.norm_pixel;
}
else
{
xim_bg_color = (attr & HL_INVERSE) ? gui.norm_pixel
: gui.back_pixel;
xim_fg_color = (attr & HL_INVERSE) ? gui.back_pixel
: gui.norm_pixel;
}
#endif
attr &= ~HL_INVERSE;
if (cattr & HL_INVERSE)
{
cc = cbg;
cbg = cfg;
cfg = cc;
}
cattr &= ~HL_INVERSE;
/*
* When we don't have window focus, draw a hollow cursor.
*/
if (!gui.in_focus)
{
gui_mch_draw_hollow_cursor(cbg);
return;
}
old_hl_mask = gui.highlight_mask;
if (shape->shape == SHAPE_BLOCK)
{
/*
* Draw the text character with the cursor colors. Use the
* character attributes plus the cursor attributes.
*/
gui.highlight_mask = (cattr | attr);
(void)gui_screenchar(LineOffset[gui.row] + gui.col,
GUI_MON_IS_CURSOR | GUI_MON_NOCLEAR, cfg, cbg, 0);
}
else
{
#if defined(FEAT_RIGHTLEFT)
int col_off = FALSE;
#endif
/*
* First draw the partial cursor, then overwrite with the text
* character, using a transparent background.
*/
if (shape->shape == SHAPE_VER)
{
cur_height = gui.char_height;
cur_width = (gui.char_width * shape->percentage + 99) / 100;
}
else
{
cur_height = (gui.char_height * shape->percentage + 99) / 100;
cur_width = gui.char_width;
}
if (has_mbyte && (*mb_off2cells)(LineOffset[gui.row] + gui.col,
LineOffset[gui.row] + screen_Columns) > 1)
{
// Double wide character.
if (shape->shape != SHAPE_VER)
cur_width += gui.char_width;
#ifdef FEAT_RIGHTLEFT
if (CURSOR_BAR_RIGHT)
{
// gui.col points to the left half of the character but
// the vertical line needs to be on the right half.
// A double-wide horizontal line is also drawn from the
// right half in gui_mch_draw_part_cursor().
col_off = TRUE;
++gui.col;
}
#endif
}
gui_mch_draw_part_cursor(cur_width, cur_height, cbg);
#if defined(FEAT_RIGHTLEFT)
if (col_off)
--gui.col;
#endif
#ifndef FEAT_GUI_MSWIN // doesn't seem to work for MSWindows
gui.highlight_mask = ScreenAttrs[LineOffset[gui.row] + gui.col];
(void)gui_screenchar(LineOffset[gui.row] + gui.col,
GUI_MON_TRS_CURSOR | GUI_MON_NOCLEAR,
(guicolor_T)0, (guicolor_T)0, 0);
#endif
}
gui.highlight_mask = old_hl_mask;
}
#if defined(FEAT_MENU) || defined(PROTO)
static void
gui_position_menu(void)
{
# if !defined(FEAT_GUI_GTK) && !defined(FEAT_GUI_MOTIF)
if (gui.menu_is_active && gui.in_use)
gui_mch_set_menu_pos(0, 0, gui.menu_width, gui.menu_height);
# endif
}
#endif
/*
* Position the various GUI components (text area, menu). The vertical
* scrollbars are NOT handled here. See gui_update_scrollbars().
*/
static void
gui_position_components(int total_width UNUSED)
{
int text_area_x;
int text_area_y;
int text_area_width;
int text_area_height;
// avoid that moving components around generates events
++hold_gui_events;
text_area_x = 0;
if (gui.which_scrollbars[SBAR_LEFT])
text_area_x += gui.scrollbar_width;
text_area_y = 0;
#if defined(FEAT_MENU) && !(defined(FEAT_GUI_GTK) || defined(FEAT_GUI_PHOTON))
gui.menu_width = total_width;
if (gui.menu_is_active)
text_area_y += gui.menu_height;
#endif
#if defined(FEAT_GUI_TABLINE) && (defined(FEAT_GUI_MSWIN) \
|| defined(FEAT_GUI_MOTIF))
if (gui_has_tabline())
text_area_y += gui.tabline_height;
#endif
#if defined(FEAT_TOOLBAR) && (defined(FEAT_GUI_MOTIF) \
|| defined(FEAT_GUI_HAIKU) || defined(FEAT_GUI_MSWIN))
if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
{
# if defined(FEAT_GUI_HAIKU)
gui_mch_set_toolbar_pos(0, text_area_y,
gui.menu_width, gui.toolbar_height);
# endif
text_area_y += gui.toolbar_height;
}
#endif
#if defined(FEAT_GUI_TABLINE) && defined(FEAT_GUI_HAIKU)
gui_mch_set_tabline_pos(0, text_area_y,
gui.menu_width, gui.tabline_height);
if (gui_has_tabline())
text_area_y += gui.tabline_height;
#endif
text_area_width = gui.num_cols * gui.char_width + gui.border_offset * 2;
text_area_height = gui.num_rows * gui.char_height + gui.border_offset * 2;
gui_mch_set_text_area_pos(text_area_x,
text_area_y,
text_area_width,
text_area_height
#if defined(FEAT_XIM) && !defined(FEAT_GUI_GTK)
+ xim_get_status_area_height()
#endif
);
#ifdef FEAT_MENU
gui_position_menu();
#endif
if (gui.which_scrollbars[SBAR_BOTTOM])
gui_mch_set_scrollbar_pos(&gui.bottom_sbar,
text_area_x,
text_area_y + text_area_height
+ gui_mch_get_scrollbar_ypadding(),
text_area_width,
gui.scrollbar_height);
gui.left_sbar_x = 0;
gui.right_sbar_x = text_area_x + text_area_width
+ gui_mch_get_scrollbar_xpadding();
--hold_gui_events;
}
/*
* Get the width of the widgets and decorations to the side of the text area.
*/
int
gui_get_base_width(void)
{
int base_width;
base_width = 2 * gui.border_offset;
if (gui.which_scrollbars[SBAR_LEFT])
base_width += gui.scrollbar_width;
if (gui.which_scrollbars[SBAR_RIGHT])
base_width += gui.scrollbar_width;
return base_width;
}
/*
* Get the height of the widgets and decorations above and below the text area.
*/
int
gui_get_base_height(void)
{
int base_height;
base_height = 2 * gui.border_offset;
if (gui.which_scrollbars[SBAR_BOTTOM])
base_height += gui.scrollbar_height;
#ifdef FEAT_GUI_GTK
// We can't take the sizes properly into account until anything is
// realized. Therefore we recalculate all the values here just before
// setting the size. (--mdcki)
#else
# ifdef FEAT_MENU
if (gui.menu_is_active)
base_height += gui.menu_height;
# endif
# ifdef FEAT_TOOLBAR
if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
base_height += gui.toolbar_height;
# endif
# if defined(FEAT_GUI_TABLINE) && (defined(FEAT_GUI_MSWIN) \
|| defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_HAIKU))
if (gui_has_tabline())
base_height += gui.tabline_height;
# endif
# if defined(FEAT_GUI_MOTIF) && defined(FEAT_MENU)
base_height += gui_mch_text_area_extra_height();
# endif
#endif
return base_height;
}
/*
* Should be called after the GUI shell has been resized. Its arguments are
* the new width and height of the shell in pixels.
*/
void
gui_resize_shell(int pixel_width, int pixel_height)
{
static int busy = FALSE;
if (!gui.shell_created) // ignore when still initializing
return;
/*
* Can't resize the screen while it is being redrawn. Remember the new
* size and handle it later.
*/
if (updating_screen || busy)
{
new_pixel_width = pixel_width;
new_pixel_height = pixel_height;
return;
}
again:
new_pixel_width = 0;
new_pixel_height = 0;
busy = TRUE;
#ifdef FEAT_GUI_HAIKU
vim_lock_screen();
#endif
// Flush pending output before redrawing
out_flush();
gui.num_cols = (pixel_width - gui_get_base_width()) / gui.char_width;
gui.num_rows = (pixel_height - gui_get_base_height()) / gui.char_height;
gui_position_components(pixel_width);
gui_reset_scroll_region();
/*
* At the "more" and ":confirm" prompt there is no redraw, put the cursor
* at the last line here (why does it have to be one row too low?).
*/
if (State == MODE_ASKMORE || State == MODE_CONFIRM)
gui.row = gui.num_rows;
// Only comparing Rows and Columns may be sufficient, but let's stay on
// the safe side.
if (gui.num_rows != screen_Rows || gui.num_cols != screen_Columns
|| gui.num_rows != Rows || gui.num_cols != Columns || gui.force_redraw)
{
shell_resized();
gui.force_redraw = 0;
}
#ifdef FEAT_GUI_HAIKU
vim_unlock_screen();
#endif
gui_update_scrollbars(TRUE);
gui_update_cursor(FALSE, TRUE);
#if defined(FEAT_XIM) && !defined(FEAT_GUI_GTK)
xim_set_status_area();
#endif
busy = FALSE;
// We may have been called again while redrawing the screen.
// Need to do it all again with the latest size then. But only if the size
// actually changed.
if (new_pixel_height)
{
if (pixel_width == new_pixel_width && pixel_height == new_pixel_height)
{
new_pixel_width = 0;
new_pixel_height = 0;
}
else
{
pixel_width = new_pixel_width;
pixel_height = new_pixel_height;
goto again;
}
}
}
/*
* Check if gui_resize_shell() must be called.
*/
void
gui_may_resize_shell(void)
{
if (new_pixel_height)
// careful: gui_resize_shell() may postpone the resize again if we
// were called indirectly by it
gui_resize_shell(new_pixel_width, new_pixel_height);
}
int
gui_get_shellsize(void)
{
Rows = gui.num_rows;
Columns = gui.num_cols;
return OK;
}
/*
* Set the size of the Vim shell according to Rows and Columns.
* If "fit_to_display" is TRUE then the size may be reduced to fit the window
* on the screen.
* When "mustset" is TRUE the size was set by the user. When FALSE a UI
* component was added or removed (e.g., a scrollbar).
*/
void
gui_set_shellsize(
int mustset UNUSED,
int fit_to_display,
int direction) // RESIZE_HOR, RESIZE_VER
{
int base_width;
int base_height;
int width;
int height;
int min_width;
int min_height;
int screen_w;
int screen_h;
#ifdef FEAT_GUI_GTK
int un_maximize = mustset;
int did_adjust = 0;
#endif
int x = -1, y = -1;
if (!gui.shell_created)
return;
#if defined(MSWIN) || defined(FEAT_GUI_GTK)
// If not setting to a user specified size and maximized, calculate the
// number of characters that fit in the maximized window.
if (!mustset && (vim_strchr(p_go, GO_KEEPWINSIZE) != NULL
|| gui_mch_maximized()))
{
gui_mch_newfont();
return;
}
#endif
base_width = gui_get_base_width();
base_height = gui_get_base_height();
if (fit_to_display)
// Remember the original window position.
(void)gui_mch_get_winpos(&x, &y);
width = Columns * gui.char_width + base_width;
height = Rows * gui.char_height + base_height;
if (fit_to_display)
{
gui_mch_get_screen_dimensions(&screen_w, &screen_h);
if ((direction & RESIZE_HOR) && width > screen_w)
{
Columns = (screen_w - base_width) / gui.char_width;
if (Columns < MIN_COLUMNS)
Columns = MIN_COLUMNS;
width = Columns * gui.char_width + base_width;
#ifdef FEAT_GUI_GTK
++did_adjust;
#endif
}
if ((direction & RESIZE_VERT) && height > screen_h)
{
Rows = (screen_h - base_height) / gui.char_height;
check_shellsize();
height = Rows * gui.char_height + base_height;
#ifdef FEAT_GUI_GTK
++did_adjust;
#endif
}
#ifdef FEAT_GUI_GTK
if (did_adjust == 2 || (width + gui.char_width >= screen_w
&& height + gui.char_height >= screen_h))
// don't unmaximize if at maximum size
un_maximize = FALSE;
#endif
}
limit_screen_size();
gui.num_cols = Columns;
gui.num_rows = Rows;
min_width = base_width + MIN_COLUMNS * gui.char_width;
min_height = base_height + MIN_LINES * gui.char_height;
min_height += tabline_height() * gui.char_height;
#ifdef FEAT_GUI_GTK
if (un_maximize)
{
// If the window size is smaller than the screen unmaximize the
// window, otherwise resizing won't work.
gui_mch_get_screen_dimensions(&screen_w, &screen_h);
if ((width + gui.char_width < screen_w
|| height + gui.char_height * 2 < screen_h)
&& gui_mch_maximized())
gui_mch_unmaximize();
}
#endif
gui_mch_set_shellsize(width, height, min_width, min_height,
base_width, base_height, direction);
if (fit_to_display && x >= 0 && y >= 0)
{
// Some window managers put the Vim window left of/above the screen.
// Only change the position if it wasn't already negative before
// (happens on MS-Windows with a secondary monitor).
gui_mch_update();
if (gui_mch_get_winpos(&x, &y) == OK && (x < 0 || y < 0))
gui_mch_set_winpos(x < 0 ? 0 : x, y < 0 ? 0 : y);
}
gui_position_components(width);
gui_update_scrollbars(TRUE);
gui_reset_scroll_region();
}
/*
* Called when Rows and/or Columns has changed.
*/
void
gui_new_shellsize(void)
{
gui_reset_scroll_region();
}
/*
* Make scroll region cover whole screen.
*/
static void
gui_reset_scroll_region(void)
{
gui.scroll_region_top = 0;
gui.scroll_region_bot = gui.num_rows - 1;
gui.scroll_region_left = 0;
gui.scroll_region_right = gui.num_cols - 1;
}
static void
gui_start_highlight(int mask)
{
if (mask > HL_ALL) // highlight code
gui.highlight_mask = mask;
else // mask
gui.highlight_mask |= mask;
}
void
gui_stop_highlight(int mask)
{
if (mask > HL_ALL) // highlight code
gui.highlight_mask = HL_NORMAL;
else // mask
gui.highlight_mask &= ~mask;
}
/*
* Clear a rectangular region of the screen from text pos (row1, col1) to
* (row2, col2) inclusive.
*/
void
gui_clear_block(
int row1,
int col1,
int row2,
int col2)
{
// Clear the selection if we are about to write over it
clip_may_clear_selection(row1, row2);
gui_mch_clear_block(row1, col1, row2, col2);
// Invalidate cursor if it was in this block
if ( gui.cursor_row >= row1 && gui.cursor_row <= row2
&& gui.cursor_col >= col1 && gui.cursor_col <= col2)
gui.cursor_is_valid = FALSE;
}
/*
* Write code to update the cursor later. This avoids the need to flush the
* output buffer before calling gui_update_cursor().
*/
void
gui_update_cursor_later(void)
{
OUT_STR("\033|s");
}
void
gui_write(
char_u *s,
int len)
{
char_u *p;
int arg1 = 0, arg2 = 0;
int force_cursor = FALSE; // force cursor update
int force_scrollbar = FALSE;
static win_T *old_curwin = NULL;
// #define DEBUG_GUI_WRITE
#ifdef DEBUG_GUI_WRITE
{
int i;
char_u *str;
printf("gui_write(%d):\n ", len);
for (i = 0; i < len; i++)
if (s[i] == ESC)
{
if (i != 0)
printf("\n ");
printf("<ESC>");
}
else
{
str = transchar_byte(s[i]);
if (str[0] && str[1])
printf("<%s>", (char *)str);
else
printf("%s", (char *)str);
}
printf("\n");
}
#endif
while (len)
{
if (s[0] == ESC && s[1] == '|')
{
p = s + 2;
if (VIM_ISDIGIT(*p) || (*p == '-' && VIM_ISDIGIT(*(p + 1))))
{
arg1 = getdigits(&p);
if (p > s + len)
break;
if (*p == ';')
{
++p;
arg2 = getdigits(&p);
if (p > s + len)
break;
}
}
switch (*p)
{
case 'C': // Clear screen
clip_scroll_selection(9999);
gui_mch_clear_all();
gui.cursor_is_valid = FALSE;
force_scrollbar = TRUE;
break;
case 'M': // Move cursor
gui_set_cursor(arg1, arg2);
break;
case 's': // force cursor (shape) update
force_cursor = TRUE;
break;
case 'R': // Set scroll region
if (arg1 < arg2)
{
gui.scroll_region_top = arg1;
gui.scroll_region_bot = arg2;
}
else
{
gui.scroll_region_top = arg2;
gui.scroll_region_bot = arg1;
}
break;
case 'V': // Set vertical scroll region
if (arg1 < arg2)
{
gui.scroll_region_left = arg1;
gui.scroll_region_right = arg2;
}
else
{
gui.scroll_region_left = arg2;
gui.scroll_region_right = arg1;
}
break;
case 'd': // Delete line
gui_delete_lines(gui.row, 1);
break;
case 'D': // Delete lines
gui_delete_lines(gui.row, arg1);
break;
case 'i': // Insert line
gui_insert_lines(gui.row, 1);
break;
case 'I': // Insert lines
gui_insert_lines(gui.row, arg1);
break;
case '$': // Clear to end-of-line
gui_clear_block(gui.row, gui.col, gui.row,
(int)Columns - 1);
break;
case 'h': // Turn on highlighting
gui_start_highlight(arg1);
break;
case 'H': // Turn off highlighting
gui_stop_highlight(arg1);
break;
case 'f': // flash the window (visual bell)
gui_mch_flash(arg1 == 0 ? 20 : arg1);
break;
default:
p = s + 1; // Skip the ESC
break;
}
len -= (int)(++p - s);
s = p;
}
else if (s[0] < 0x20 // Ctrl character
#ifdef FEAT_SIGN_ICONS
&& s[0] != SIGN_BYTE
# ifdef FEAT_NETBEANS_INTG
&& s[0] != MULTISIGN_BYTE
# endif
#endif
)
{
if (s[0] == '\n') // NL
{
gui.col = 0;
if (gui.row < gui.scroll_region_bot)
gui.row++;
else
gui_delete_lines(gui.scroll_region_top, 1);
}
else if (s[0] == '\r') // CR
{
gui.col = 0;
}
else if (s[0] == '\b') // Backspace
{
if (gui.col)
--gui.col;
}
else if (s[0] == Ctrl_L) // cursor-right
{
++gui.col;
}
else if (s[0] == Ctrl_G) // Beep
{
gui_mch_beep();
}
// Other Ctrl character: shouldn't happen!
--len; // Skip this char
++s;
}
else
{
p = s;
while (len > 0 && (
*p >= 0x20
#ifdef FEAT_SIGN_ICONS
|| *p == SIGN_BYTE
# ifdef FEAT_NETBEANS_INTG
|| *p == MULTISIGN_BYTE
# endif
#endif
))
{
len--;
p++;
}
gui_outstr(s, (int)(p - s));
s = p;
}
}
// Postponed update of the cursor (won't work if "can_update_cursor" isn't
// set).
if (force_cursor)
gui_update_cursor(TRUE, TRUE);
// When switching to another window the dragging must have stopped.
// Required for GTK, dragged_sb isn't reset.
if (old_curwin != curwin)
gui.dragged_sb = SBAR_NONE;
// Update the scrollbars after clearing the screen or when switched
// to another window.
// Update the horizontal scrollbar always, it's difficult to check all
// situations where it might change.
if (force_scrollbar || old_curwin != curwin)
gui_update_scrollbars(force_scrollbar);
else
gui_update_horiz_scrollbar(FALSE);
old_curwin = curwin;
/*
* We need to make sure this is cleared since GTK doesn't tell us when
* the user is done dragging.
*/
#if defined(FEAT_GUI_GTK)
gui.dragged_sb = SBAR_NONE;
#endif
gui_may_flush(); // In case vim decides to take a nap
}
/*
* When ScreenLines[] is invalid, updating the cursor should not be done, it
* produces wrong results. Call gui_dont_update_cursor() before that code and
* gui_can_update_cursor() afterwards.
*/
void
gui_dont_update_cursor(int undraw)
{
if (!gui.in_use)
return;
// Undraw the cursor now, we probably can't do it after the change.
if (undraw)
gui_undraw_cursor();
can_update_cursor = FALSE;
}
void
gui_can_update_cursor(void)
{
can_update_cursor = TRUE;
// No need to update the cursor right now, there is always more output
// after scrolling.
}
/*
* Disable issuing gui_mch_flush().
*/
void
gui_disable_flush(void)
{
++disable_flush;
}
/*
* Enable issuing gui_mch_flush().
*/
void
gui_enable_flush(void)
{
--disable_flush;
}
/*
* Issue gui_mch_flush() if it is not disabled.
*/
void
gui_may_flush(void)
{
if (disable_flush == 0)
gui_mch_flush();
}
static void
gui_outstr(char_u *s, int len)
{
int this_len;
int cells;
if (len == 0)
return;
if (len < 0)
len = (int)STRLEN(s);
while (len > 0)
{
if (has_mbyte)
{
// Find out how many chars fit in the current line.
cells = 0;
for (this_len = 0; this_len < len; )
{
cells += (*mb_ptr2cells)(s + this_len);
if (gui.col + cells > Columns)
break;
this_len += (*mb_ptr2len)(s + this_len);
}
if (this_len > len)
this_len = len; // don't include following composing char
}
else if (gui.col + len > Columns)
this_len = Columns - gui.col;
else
this_len = len;
(void)gui_outstr_nowrap(s, this_len,
0, (guicolor_T)0, (guicolor_T)0, 0);
s += this_len;
len -= this_len;
// fill up for a double-width char that doesn't fit.
if (len > 0 && gui.col < Columns)
(void)gui_outstr_nowrap((char_u *)" ", 1,
0, (guicolor_T)0, (guicolor_T)0, 0);
// The cursor may wrap to the next line.
if (gui.col >= Columns)
{
gui.col = 0;
gui.row++;
}
}
}
/*
* Output one character (may be one or two display cells).
* Caller must check for valid "off".
* Returns FAIL or OK, just like gui_outstr_nowrap().
*/
static int
gui_screenchar(
int off, // Offset from start of screen
int flags,
guicolor_T fg, // colors for cursor
guicolor_T bg, // colors for cursor
int back) // backup this many chars when using bold trick
{
char_u buf[MB_MAXBYTES + 1];
// Don't draw right half of a double-width UTF-8 char. "cannot happen"
if (enc_utf8 && ScreenLines[off] == 0)
return OK;
if (enc_utf8 && ScreenLinesUC[off] != 0)
// Draw UTF-8 multi-byte character.
return gui_outstr_nowrap(buf, utfc_char2bytes(off, buf),
flags, fg, bg, back);
if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e)
{
buf[0] = ScreenLines[off];
buf[1] = ScreenLines2[off];
return gui_outstr_nowrap(buf, 2, flags, fg, bg, back);
}
// Draw non-multi-byte character or DBCS character.
return gui_outstr_nowrap(ScreenLines + off,
enc_dbcs ? (*mb_ptr2len)(ScreenLines + off) : 1,
flags, fg, bg, back);
}
#ifdef FEAT_GUI_GTK
/*
* Output the string at the given screen position. This is used in place
* of gui_screenchar() where possible because Pango needs as much context
* as possible to work nicely. It's a lot faster as well.
*/
static int
gui_screenstr(
int off, // Offset from start of screen
int len, // string length in screen cells
int flags,
guicolor_T fg, // colors for cursor
guicolor_T bg, // colors for cursor
int back) // backup this many chars when using bold trick
{
char_u *buf;
int outlen = 0;
int i;
int retval;
if (len <= 0) // "cannot happen"?
return OK;
if (enc_utf8)
{
buf = alloc(len * MB_MAXBYTES + 1);
if (buf == NULL)
return OK; // not much we could do here...
for (i = off; i < off + len; ++i)
{
if (ScreenLines[i] == 0)
continue; // skip second half of double-width char
if (ScreenLinesUC[i] == 0)
buf[outlen++] = ScreenLines[i];
else
outlen += utfc_char2bytes(i, buf + outlen);
}
buf[outlen] = NUL; // only to aid debugging
retval = gui_outstr_nowrap(buf, outlen, flags, fg, bg, back);
vim_free(buf);
return retval;
}
else if (enc_dbcs == DBCS_JPNU)
{
buf = alloc(len * 2 + 1);
if (buf == NULL)
return OK; // not much we could do here...
for (i = off; i < off + len; ++i)
{
buf[outlen++] = ScreenLines[i];
// handle double-byte single-width char
if (ScreenLines[i] == 0x8e)
buf[outlen++] = ScreenLines2[i];
else if (MB_BYTE2LEN(ScreenLines[i]) == 2)
buf[outlen++] = ScreenLines[++i];
}
buf[outlen] = NUL; // only to aid debugging
retval = gui_outstr_nowrap(buf, outlen, flags, fg, bg, back);
vim_free(buf);
return retval;
}
else
{
return gui_outstr_nowrap(&ScreenLines[off], len,
flags, fg, bg, back);
}
}
#endif // FEAT_GUI_GTK
/*
* Output the given string at the current cursor position. If the string is
* too long to fit on the line, then it is truncated.
* "flags":
* GUI_MON_IS_CURSOR should only be used when this function is being called to
* actually draw (an inverted) cursor.
* GUI_MON_TRS_CURSOR is used to draw the cursor text with a transparent
* background.
* GUI_MON_NOCLEAR is used to avoid clearing the selection when drawing over
* it.
* Returns OK, unless "back" is non-zero and using the bold trick, then return
* FAIL (the caller should start drawing "back" chars back).
*/
static int
gui_outstr_nowrap(
char_u *s,
int len,
int flags,
guicolor_T fg, // colors for cursor
guicolor_T bg, // colors for cursor
int back) // backup this many chars when using bold trick
{
long_u highlight_mask;
long_u hl_mask_todo;
guicolor_T fg_color;
guicolor_T bg_color;
guicolor_T sp_color;
#if !defined(FEAT_GUI_GTK)
GuiFont font = NOFONT;
GuiFont wide_font = NOFONT;
# ifdef FEAT_XFONTSET
GuiFontset fontset = NOFONTSET;
# endif
#endif
attrentry_T *aep = NULL;
int draw_flags;
int col = gui.col;
#ifdef FEAT_SIGN_ICONS
int draw_sign = FALSE;
int signcol = 0;
char_u extra[18];
# ifdef FEAT_NETBEANS_INTG
int multi_sign = FALSE;
# endif
#endif
if (len < 0)
len = (int)STRLEN(s);
if (len == 0)
return OK;
#ifdef FEAT_SIGN_ICONS
if (*s == SIGN_BYTE
# ifdef FEAT_NETBEANS_INTG
|| *s == MULTISIGN_BYTE
# endif
)
{
# ifdef FEAT_NETBEANS_INTG
if (*s == MULTISIGN_BYTE)
multi_sign = TRUE;
# endif
// draw spaces instead
if (*curwin->w_p_scl == 'n' && *(curwin->w_p_scl + 1) == 'u' &&
(curwin->w_p_nu || curwin->w_p_rnu))
{
sprintf((char *)extra, "%*c ", number_width(curwin), ' ');
s = extra;
}
else
s = (char_u *)" ";
if (len == 1 && col > 0)
--col;
len = (int)STRLEN(s);
if (len > 2)
// right align sign icon in the number column
signcol = col + len - 3;
else
signcol = col;
draw_sign = TRUE;
highlight_mask = 0;
}
else
#endif
if (gui.highlight_mask > HL_ALL)
{
aep = syn_gui_attr2entry(gui.highlight_mask);
if (aep == NULL) // highlighting not set
highlight_mask = 0;
else
highlight_mask = aep->ae_attr;
}
else
highlight_mask = gui.highlight_mask;
hl_mask_todo = highlight_mask;
#if !defined(FEAT_GUI_GTK)
// Set the font
if (aep != NULL && aep->ae_u.gui.font != NOFONT)
font = aep->ae_u.gui.font;
# ifdef FEAT_XFONTSET
else if (aep != NULL && aep->ae_u.gui.fontset != NOFONTSET)
fontset = aep->ae_u.gui.fontset;
# endif
else
{
# ifdef FEAT_XFONTSET
if (gui.fontset != NOFONTSET)
fontset = gui.fontset;
else
# endif
if (hl_mask_todo & (HL_BOLD | HL_STANDOUT))
{
if ((hl_mask_todo & HL_ITALIC) && gui.boldital_font != NOFONT)
{
font = gui.boldital_font;
hl_mask_todo &= ~(HL_BOLD | HL_STANDOUT | HL_ITALIC);
}
else if (gui.bold_font != NOFONT)
{
font = gui.bold_font;
hl_mask_todo &= ~(HL_BOLD | HL_STANDOUT);
}
else
font = gui.norm_font;
}
else if ((hl_mask_todo & HL_ITALIC) && gui.ital_font != NOFONT)
{
font = gui.ital_font;
hl_mask_todo &= ~HL_ITALIC;
}
else
font = gui.norm_font;
/*
* Choose correct wide_font by font. wide_font should be set with font
* at same time in above block. But it will make many "ifdef" nasty
* blocks. So we do it here.
*/
if (font == gui.boldital_font && gui.wide_boldital_font)
wide_font = gui.wide_boldital_font;
else if (font == gui.bold_font && gui.wide_bold_font)
wide_font = gui.wide_bold_font;
else if (font == gui.ital_font && gui.wide_ital_font)
wide_font = gui.wide_ital_font;
else if (font == gui.norm_font && gui.wide_font)
wide_font = gui.wide_font;
}
# ifdef FEAT_XFONTSET
if (fontset != NOFONTSET)
gui_mch_set_fontset(fontset);
else
# endif
gui_mch_set_font(font);
#endif
draw_flags = 0;
// Set the color
bg_color = gui.back_pixel;
if ((flags & GUI_MON_IS_CURSOR) && gui.in_focus)
{
draw_flags |= DRAW_CURSOR;
fg_color = fg;
bg_color = bg;
sp_color = fg;
}
else if (aep != NULL)
{
fg_color = aep->ae_u.gui.fg_color;
if (fg_color == INVALCOLOR)
fg_color = gui.norm_pixel;
bg_color = aep->ae_u.gui.bg_color;
if (bg_color == INVALCOLOR)
bg_color = gui.back_pixel;
sp_color = aep->ae_u.gui.sp_color;
if (sp_color == INVALCOLOR)
sp_color = fg_color;
}
else
{
fg_color = gui.norm_pixel;
sp_color = fg_color;
}
if (highlight_mask & (HL_INVERSE | HL_STANDOUT))
{
gui_mch_set_fg_color(bg_color);
gui_mch_set_bg_color(fg_color);
}
else
{
gui_mch_set_fg_color(fg_color);
gui_mch_set_bg_color(bg_color);
}
gui_mch_set_sp_color(sp_color);
// Clear the selection if we are about to write over it
if (!(flags & GUI_MON_NOCLEAR))
clip_may_clear_selection(gui.row, gui.row);
// If there's no bold font, then fake it
if (hl_mask_todo & (HL_BOLD | HL_STANDOUT))
draw_flags |= DRAW_BOLD;
/*
* When drawing bold or italic characters the spill-over from the left
* neighbor may be destroyed. Let the caller backup to start redrawing
* just after a blank.
*/
if (back != 0 && ((draw_flags & DRAW_BOLD) || (highlight_mask & HL_ITALIC)))
return FAIL;
#if defined(FEAT_GUI_GTK)
// If there's no italic font, then fake it.
// For GTK2, we don't need a different font for italic style.
if (hl_mask_todo & HL_ITALIC)
draw_flags |= DRAW_ITALIC;
// Do we underline the text?
if (hl_mask_todo & HL_UNDERLINE)
draw_flags |= DRAW_UNDERL;
#else
// Do we underline the text?
if ((hl_mask_todo & HL_UNDERLINE) || (hl_mask_todo & HL_ITALIC))
draw_flags |= DRAW_UNDERL;
#endif
// Do we undercurl the text?
if (hl_mask_todo & HL_UNDERCURL)
draw_flags |= DRAW_UNDERC;
// TODO: HL_UNDERDOUBLE, HL_UNDERDOTTED, HL_UNDERDASHED
// Do we strikethrough the text?
if (hl_mask_todo & HL_STRIKETHROUGH)
draw_flags |= DRAW_STRIKE;
// Do we draw transparently?
if (flags & GUI_MON_TRS_CURSOR)
draw_flags |= DRAW_TRANSP;
/*
* Draw the text.
*/
#ifdef FEAT_GUI_GTK
// The value returned is the length in display cells
len = gui_gtk2_draw_string(gui.row, col, s, len, draw_flags);
#else
if (enc_utf8)
{
int start; // index of bytes to be drawn
int cells; // cellwidth of bytes to be drawn
int thislen; // length of bytes to be drawn
int cn; // cellwidth of current char
int i; // index of current char
int c; // current char value
int cl; // byte length of current char
int comping; // current char is composing
int scol = col; // screen column
int curr_wide = FALSE; // use 'guifontwide'
int prev_wide = FALSE;
int wide_changed;
# ifdef MSWIN
int sep_comp = FALSE; // Don't separate composing chars.
# else
int sep_comp = TRUE; // Separate composing chars.
# endif
// Break the string at a composing character, it has to be drawn on
// top of the previous character.
start = 0;
cells = 0;
for (i = 0; i < len; i += cl)
{
c = utf_ptr2char(s + i);
cn = utf_char2cells(c);
comping = utf_iscomposing(c);
if (!comping) // count cells from non-composing chars
cells += cn;
if (!comping || sep_comp)
{
if (cn > 1
# ifdef FEAT_XFONTSET
&& fontset == NOFONTSET
# endif
&& wide_font != NOFONT)
curr_wide = TRUE;
else
curr_wide = FALSE;
}
cl = utf_ptr2len(s + i);
if (cl == 0) // hit end of string
len = i + cl; // len must be wrong "cannot happen"
wide_changed = curr_wide != prev_wide;
// Print the string so far if it's the last character or there is
// a composing character.
if (i + cl >= len || (comping && sep_comp && i > start)
|| wide_changed
# if defined(FEAT_GUI_X11)
|| (cn > 1
# ifdef FEAT_XFONTSET
// No fontset: At least draw char after wide char at
// right position.
&& fontset == NOFONTSET
# endif
)
# endif
)
{
if ((comping && sep_comp) || wide_changed)
thislen = i - start;
else
thislen = i - start + cl;
if (thislen > 0)
{
if (prev_wide)
gui_mch_set_font(wide_font);
gui_mch_draw_string(gui.row, scol, s + start, thislen,
draw_flags);
if (prev_wide)
gui_mch_set_font(font);
start += thislen;
}
scol += cells;
cells = 0;
// Adjust to not draw a character which width is changed
// against with last one.
if (wide_changed && !(comping && sep_comp))
{
scol -= cn;
cl = 0;
}
# if defined(FEAT_GUI_X11)
// No fontset: draw a space to fill the gap after a wide char
//
if (cn > 1 && (draw_flags & DRAW_TRANSP) == 0
# ifdef FEAT_XFONTSET
&& fontset == NOFONTSET
# endif
&& !wide_changed)
gui_mch_draw_string(gui.row, scol - 1, (char_u *)" ",
1, draw_flags);
# endif
}
// Draw a composing char on top of the previous char.
if (comping && sep_comp)
{
# if defined(__APPLE_CC__) && TARGET_API_MAC_CARBON
// Carbon ATSUI autodraws composing char over previous char
gui_mch_draw_string(gui.row, scol, s + i, cl,
draw_flags | DRAW_TRANSP);
# else
gui_mch_draw_string(gui.row, scol - cn, s + i, cl,
draw_flags | DRAW_TRANSP);
# endif
start = i + cl;
}
prev_wide = curr_wide;
}
// The stuff below assumes "len" is the length in screen columns.
len = scol - col;
}
else
{
gui_mch_draw_string(gui.row, col, s, len, draw_flags);
if (enc_dbcs == DBCS_JPNU)
{
// Get the length in display cells, this can be different from the
// number of bytes for "euc-jp".
len = mb_string2cells(s, len);
}
}
#endif // !FEAT_GUI_GTK
if (!(flags & (GUI_MON_IS_CURSOR | GUI_MON_TRS_CURSOR)))
gui.col = col + len;
// May need to invert it when it's part of the selection.
if (flags & GUI_MON_NOCLEAR)
clip_may_redraw_selection(gui.row, col, len);
if (!(flags & (GUI_MON_IS_CURSOR | GUI_MON_TRS_CURSOR)))
{
// Invalidate the old physical cursor position if we wrote over it
if (gui.cursor_row == gui.row
&& gui.cursor_col >= col
&& gui.cursor_col < col + len)
gui.cursor_is_valid = FALSE;
}
#ifdef FEAT_SIGN_ICONS
if (draw_sign)
// Draw the sign on top of the spaces.
gui_mch_drawsign(gui.row, signcol, gui.highlight_mask);
# if defined(FEAT_NETBEANS_INTG) && (defined(FEAT_GUI_X11) \
|| defined(FEAT_GUI_GTK) || defined(FEAT_GUI_MSWIN))
if (multi_sign)
netbeans_draw_multisign_indicator(gui.row);
# endif
#endif
return OK;
}
/*
* Undraw the cursor. This actually redraws the character at the cursor
* position, plus some more characters when needed.
*/
void
gui_undraw_cursor(void)
{
if (!gui.cursor_is_valid)
return;
// Always redraw the character just before if there is one, because
// with some fonts and characters there can be a one pixel overlap.
int startcol = gui.cursor_col > 0 ? gui.cursor_col - 1 : gui.cursor_col;
int endcol = gui.cursor_col;
#if defined(FEAT_GUI_GTK) || defined(FEAT_GUI_MSWIN)
gui_adjust_undraw_cursor_for_ligatures(&startcol, &endcol);
#endif
gui_redraw_block(gui.cursor_row, startcol,
gui.cursor_row, endcol, GUI_MON_NOCLEAR);
// Cursor_is_valid is reset when the cursor is undrawn, also reset it
// here in case it wasn't needed to undraw it.
gui.cursor_is_valid = FALSE;
}
void
gui_redraw(
int x,
int y,
int w,
int h)
{
int row1, col1, row2, col2;
row1 = Y_2_ROW(y);
col1 = X_2_COL(x);
row2 = Y_2_ROW(y + h - 1);
col2 = X_2_COL(x + w - 1);
gui_redraw_block(row1, col1, row2, col2, GUI_MON_NOCLEAR);
/*
* We may need to redraw the cursor, but don't take it upon us to change
* its location after a scroll.
* (maybe be more strict even and test col too?)
* These things may be outside the update/clipping region and reality may
* not reflect Vims internal ideas if these operations are clipped away.
*/
if (gui.row == gui.cursor_row)
gui_update_cursor(TRUE, TRUE);
}
/*
* Draw a rectangular block of characters, from row1 to row2 (inclusive) and
* from col1 to col2 (inclusive).
*/
void
gui_redraw_block(
int row1,
int col1,
int row2,
int col2,
int flags) // flags for gui_outstr_nowrap()
{
int old_row, old_col;
long_u old_hl_mask;
int off;
sattr_T first_attr;
int idx, len;
int back, nback;
int orig_col1, orig_col2;
// Don't try to update when ScreenLines is not valid
if (!screen_cleared || ScreenLines == NULL)
return;
// Don't try to draw outside the shell!
// Check everything, strange values may be caused by a big border width
col1 = check_col(col1);
col2 = check_col(col2);
row1 = check_row(row1);
row2 = check_row(row2);
// Remember where our cursor was
old_row = gui.row;
old_col = gui.col;
old_hl_mask = gui.highlight_mask;
orig_col1 = col1;
orig_col2 = col2;
for (gui.row = row1; gui.row <= row2; gui.row++)
{
// When only half of a double-wide character is in the block, include
// the other half.
col1 = orig_col1;
col2 = orig_col2;
off = LineOffset[gui.row];
if (enc_dbcs != 0)
{
if (col1 > 0)
col1 -= dbcs_screen_head_off(ScreenLines + off,
ScreenLines + off + col1);
col2 += dbcs_screen_tail_off(ScreenLines + off,
ScreenLines + off + col2);
}
else if (enc_utf8)
{
if (ScreenLines[off + col1] == 0)
{
if (col1 > 0)
--col1;
else
// FIXME: how can the first character ever be zero?
siemsg("NUL in ScreenLines in row %ld", (long)gui.row);
}
#ifdef FEAT_GUI_GTK
if (col2 + 1 < Columns && ScreenLines[off + col2 + 1] == 0)
++col2;
#endif
}
gui.col = col1;
off = LineOffset[gui.row] + gui.col;
len = col2 - col1 + 1;
// Find how many chars back this highlighting starts, or where a space
// is. Needed for when the bold trick is used
for (back = 0; back < col1; ++back)
if (ScreenAttrs[off - 1 - back] != ScreenAttrs[off]
|| ScreenLines[off - 1 - back] == ' ')
break;
// Break it up in strings of characters with the same attributes.
// Print UTF-8 characters individually.
while (len > 0)
{
first_attr = ScreenAttrs[off];
gui.highlight_mask = first_attr;
#if !defined(FEAT_GUI_GTK)
if (enc_utf8 && ScreenLinesUC[off] != 0)
{
// output multi-byte character separately
nback = gui_screenchar(off, flags,
(guicolor_T)0, (guicolor_T)0, back);
if (gui.col < Columns && ScreenLines[off + 1] == 0)
idx = 2;
else
idx = 1;
}
else if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e)
{
// output double-byte, single-width character separately
nback = gui_screenchar(off, flags,
(guicolor_T)0, (guicolor_T)0, back);
idx = 1;
}
else
#endif
{
#ifdef FEAT_GUI_GTK
for (idx = 0; idx < len; ++idx)
{
if (enc_utf8 && ScreenLines[off + idx] == 0)
continue; // skip second half of double-width char
if (ScreenAttrs[off + idx] != first_attr)
break;
}
// gui_screenstr() takes care of multibyte chars
nback = gui_screenstr(off, idx, flags,
(guicolor_T)0, (guicolor_T)0, back);
#else
for (idx = 0; idx < len && ScreenAttrs[off + idx] == first_attr;
idx++)
{
// Stop at a multi-byte Unicode character.
if (enc_utf8 && ScreenLinesUC[off + idx] != 0)
break;
if (enc_dbcs == DBCS_JPNU)
{
// Stop at a double-byte single-width char.
if (ScreenLines[off + idx] == 0x8e)
break;
if (len > 1 && (*mb_ptr2len)(ScreenLines
+ off + idx) == 2)
++idx; // skip second byte of double-byte char
}
}
nback = gui_outstr_nowrap(ScreenLines + off, idx, flags,
(guicolor_T)0, (guicolor_T)0, back);
#endif
}
if (nback == FAIL)
{
// Must back up to start drawing where a bold or italic word
// starts.
off -= back;
len += back;
gui.col -= back;
}
else
{
off += idx;
len -= idx;
}
back = 0;
}
}
// Put the cursor back where it was
gui.row = old_row;
gui.col = old_col;
gui.highlight_mask = (int)old_hl_mask;
}
static void
gui_delete_lines(int row, int count)
{
if (count <= 0)
return;
if (row + count > gui.scroll_region_bot)
// Scrolled out of region, just blank the lines out
gui_clear_block(row, gui.scroll_region_left,
gui.scroll_region_bot, gui.scroll_region_right);
else
{
gui_mch_delete_lines(row, count);
// If the cursor was in the deleted lines it's now gone. If the
// cursor was in the scrolled lines adjust its position.
if (gui.cursor_row >= row
&& gui.cursor_col >= gui.scroll_region_left
&& gui.cursor_col <= gui.scroll_region_right)
{
if (gui.cursor_row < row + count)
gui.cursor_is_valid = FALSE;
else if (gui.cursor_row <= gui.scroll_region_bot)
gui.cursor_row -= count;
}
}
}
static void
gui_insert_lines(int row, int count)
{
if (count <= 0)
return;
if (row + count > gui.scroll_region_bot)
// Scrolled out of region, just blank the lines out
gui_clear_block(row, gui.scroll_region_left,
gui.scroll_region_bot, gui.scroll_region_right);
else
{
gui_mch_insert_lines(row, count);
if (gui.cursor_row >= gui.row
&& gui.cursor_col >= gui.scroll_region_left
&& gui.cursor_col <= gui.scroll_region_right)
{
if (gui.cursor_row <= gui.scroll_region_bot - count)
gui.cursor_row += count;
else if (gui.cursor_row <= gui.scroll_region_bot)
gui.cursor_is_valid = FALSE;
}
}
}
#ifdef FEAT_TIMERS
/*
* Passed to ui_wait_for_chars_or_timer(), ignoring extra arguments.
*/
static int
gui_wait_for_chars_3(
long wtime,
int *interrupted UNUSED,
int ignore_input UNUSED)
{
return gui_mch_wait_for_chars(wtime);
}
#endif
/*
* Returns OK if a character was found to be available within the given time,
* or FAIL otherwise.
*/
static int
gui_wait_for_chars_or_timer(
long wtime,
int *interrupted UNUSED,
int ignore_input UNUSED)
{
#ifdef FEAT_TIMERS
return ui_wait_for_chars_or_timer(wtime, gui_wait_for_chars_3,
interrupted, ignore_input);
#else
return gui_mch_wait_for_chars(wtime);
#endif
}
/*
* The main GUI input routine. Waits for a character from the keyboard.
* "wtime" == -1 Wait forever.
* "wtime" == 0 Don't wait.
* "wtime" > 0 Wait wtime milliseconds for a character.
*
* Returns the number of characters read or zero when timed out or interrupted.
* "buf" may be NULL, in which case a non-zero number is returned if characters
* are available.
*/
static int
gui_wait_for_chars_buf(
char_u *buf,
int maxlen,
long wtime, // don't use "time", MIPS cannot handle it
int tb_change_cnt)
{
int retval;
#ifdef FEAT_MENU
// If we're going to wait a bit, update the menus and mouse shape for the
// current State.
if (wtime != 0)
gui_update_menus(0);
#endif
gui_mch_update();
if (input_available()) // Got char, return immediately
{
if (buf != NULL && !typebuf_changed(tb_change_cnt))
return read_from_input_buf(buf, (long)maxlen);
return 0;
}
if (wtime == 0) // Don't wait for char
return FAIL;
// Before waiting, flush any output to the screen.
gui_mch_flush();
// Blink while waiting for a character.
gui_mch_start_blink();
// Common function to loop until "wtime" is met, while handling timers and
// other callbacks.
retval = inchar_loop(buf, maxlen, wtime, tb_change_cnt,
gui_wait_for_chars_or_timer, NULL);
gui_mch_stop_blink(TRUE);
return retval;
}
/*
* Wait for a character from the keyboard without actually reading it.
* Also deals with timers.
* wtime == -1 Wait forever.
* wtime == 0 Don't wait.
* wtime > 0 Wait wtime milliseconds for a character.
* Returns OK if a character was found to be available within the given time,
* or FAIL otherwise.
*/
int
gui_wait_for_chars(long wtime, int tb_change_cnt)
{
return gui_wait_for_chars_buf(NULL, 0, wtime, tb_change_cnt);
}
/*
* Equivalent of mch_inchar() for the GUI.
*/
int
gui_inchar(
char_u *buf,
int maxlen,
long wtime, // milliseconds
int tb_change_cnt)
{
return gui_wait_for_chars_buf(buf, maxlen, wtime, tb_change_cnt);
}
/*
* Fill p[4] with mouse coordinates encoded for check_termcode().
*/
static void
fill_mouse_coord(char_u *p, int col, int row)
{
p[0] = (char_u)(col / 128 + ' ' + 1);
p[1] = (char_u)(col % 128 + ' ' + 1);
p[2] = (char_u)(row / 128 + ' ' + 1);
p[3] = (char_u)(row % 128 + ' ' + 1);
}
/*
* Generic mouse support function. Add a mouse event to the input buffer with
* the given properties.
* button --- may be any of MOUSE_LEFT, MOUSE_MIDDLE, MOUSE_RIGHT,
* MOUSE_X1, MOUSE_X2
* MOUSE_DRAG, or MOUSE_RELEASE.
* MOUSE_4 and MOUSE_5 are used for vertical scroll wheel,
* MOUSE_6 and MOUSE_7 for horizontal scroll wheel.
* x, y --- Coordinates of mouse in pixels.
* repeated_click --- TRUE if this click comes only a short time after a
* previous click.
* modifiers --- Bit field which may be any of the following modifiers
* or'ed together: MOUSE_SHIFT | MOUSE_CTRL | MOUSE_ALT.
* This function will ignore drag events where the mouse has not moved to a new
* character.
*/
void
gui_send_mouse_event(
int button,
int x,
int y,
int repeated_click,
int_u modifiers)
{
static int prev_row = 0, prev_col = 0;
static int prev_button = -1;
static int num_clicks = 1;
char_u string[10];
enum key_extra button_char;
int row, col;
#ifdef FEAT_CLIPBOARD
int checkfor;
int did_clip = FALSE;
#endif
/*
* Scrolling may happen at any time, also while a selection is present.
*/
switch (button)
{
case MOUSE_MOVE:
button_char = KE_MOUSEMOVE_XY;
goto button_set;
case MOUSE_X1:
button_char = KE_X1MOUSE;
goto button_set;
case MOUSE_X2:
button_char = KE_X2MOUSE;
goto button_set;
case MOUSE_4:
button_char = KE_MOUSEDOWN;
goto button_set;
case MOUSE_5:
button_char = KE_MOUSEUP;
goto button_set;
case MOUSE_6:
button_char = KE_MOUSELEFT;
goto button_set;
case MOUSE_7:
button_char = KE_MOUSERIGHT;
button_set:
{
// Don't put events in the input queue now.
if (hold_gui_events)
return;
row = gui_xy2colrow(x, y, &col);
// Don't report a mouse move unless moved to a
// different character position.
if (button == MOUSE_MOVE)
{
if (row == prev_row && col == prev_col)
return;
else
{
prev_row = row >= 0 ? row : 0;
prev_col = col;
}
}
string[3] = CSI;
string[4] = KS_EXTRA;
string[5] = (int)button_char;
// Pass the pointer coordinates of the scroll event so that we
// know which window to scroll.
string[6] = (char_u)(col / 128 + ' ' + 1);
string[7] = (char_u)(col % 128 + ' ' + 1);
string[8] = (char_u)(row / 128 + ' ' + 1);
string[9] = (char_u)(row % 128 + ' ' + 1);
if (modifiers == 0)
add_to_input_buf(string + 3, 7);
else
{
string[0] = CSI;
string[1] = KS_MODIFIER;
string[2] = 0;
if (modifiers & MOUSE_SHIFT)
string[2] |= MOD_MASK_SHIFT;
if (modifiers & MOUSE_CTRL)
string[2] |= MOD_MASK_CTRL;
if (modifiers & MOUSE_ALT)
string[2] |= MOD_MASK_ALT;
add_to_input_buf(string, 10);
}
return;
}
}
#ifdef FEAT_CLIPBOARD
// If a clipboard selection is in progress, handle it
if (clip_star.state == SELECT_IN_PROGRESS)
{
clip_process_selection(button, X_2_COL(x), Y_2_ROW(y), repeated_click);
// A release event may still need to be sent if the position is equal.
row = gui_xy2colrow(x, y, &col);
if (button != MOUSE_RELEASE || row != prev_row || col != prev_col)
return;
}
// Determine which mouse settings to look for based on the current mode
switch (get_real_state())
{
case MODE_NORMAL_BUSY:
case MODE_OP_PENDING:
# ifdef FEAT_TERMINAL
case MODE_TERMINAL:
# endif
case MODE_NORMAL: checkfor = MOUSE_NORMAL; break;
case MODE_VISUAL: checkfor = MOUSE_VISUAL; break;
case MODE_SELECT: checkfor = MOUSE_VISUAL; break;
case MODE_REPLACE:
case MODE_REPLACE | MODE_LANGMAP:
case MODE_VREPLACE:
case MODE_VREPLACE | MODE_LANGMAP:
case MODE_INSERT:
case MODE_INSERT | MODE_LANGMAP:
checkfor = MOUSE_INSERT; break;
case MODE_ASKMORE:
case MODE_HITRETURN: // At the more- and hit-enter prompt pass the
// mouse event for a click on or below the
// message line.
if (Y_2_ROW(y) >= msg_row)
checkfor = MOUSE_NORMAL;
else
checkfor = MOUSE_RETURN;
break;
/*
* On the command line, use the clipboard selection on all lines
* but the command line. But not when pasting.
*/
case MODE_CMDLINE:
case MODE_CMDLINE | MODE_LANGMAP:
if (Y_2_ROW(y) < cmdline_row && button != MOUSE_MIDDLE)
checkfor = MOUSE_NONE;
else
checkfor = MOUSE_COMMAND;
break;
default:
checkfor = MOUSE_NONE;
break;
};
/*
* Allow clipboard selection of text on the command line in "normal"
* modes. Don't do this when dragging the status line, or extending a
* Visual selection.
*/
if ((State == MODE_NORMAL || State == MODE_NORMAL_BUSY
|| (State & MODE_INSERT))
&& Y_2_ROW(y) >= topframe->fr_height + firstwin->w_winrow
&& button != MOUSE_DRAG
# ifdef FEAT_MOUSESHAPE
&& !drag_status_line
&& !drag_sep_line
# endif
)
checkfor = MOUSE_NONE;
/*
* Use modeless selection when holding CTRL and SHIFT pressed.
*/
if ((modifiers & MOUSE_CTRL) && (modifiers & MOUSE_SHIFT))
checkfor = MOUSE_NONEF;
/*
* In Ex mode, always use modeless selection.
*/
if (exmode_active)
checkfor = MOUSE_NONE;
/*
* If the mouse settings say to not use the mouse, use the modeless
* selection. But if Visual is active, assume that only the Visual area
* will be selected.
* Exception: On the command line, both the selection is used and a mouse
* key is sent.
*/
if (!mouse_has(checkfor) || checkfor == MOUSE_COMMAND)
{
// Don't do modeless selection in Visual mode.
if (checkfor != MOUSE_NONEF && VIsual_active && (State & MODE_NORMAL))
return;
/*
* When 'mousemodel' is "popup", shift-left is translated to right.
* But not when also using Ctrl.
*/
if (mouse_model_popup() && button == MOUSE_LEFT
&& (modifiers & MOUSE_SHIFT) && !(modifiers & MOUSE_CTRL))
{
button = MOUSE_RIGHT;
modifiers &= ~ MOUSE_SHIFT;
}
// If the selection is done, allow the right button to extend it.
// If the selection is cleared, allow the right button to start it
// from the cursor position.
if (button == MOUSE_RIGHT)
{
if (clip_star.state == SELECT_CLEARED)
{
if (State & MODE_CMDLINE)
{
col = msg_col;
row = msg_row;
}
else
{
col = curwin->w_wcol;
row = curwin->w_wrow + W_WINROW(curwin);
}
clip_start_selection(col, row, FALSE);
}
clip_process_selection(button, X_2_COL(x), Y_2_ROW(y),
repeated_click);
did_clip = TRUE;
}
// Allow the left button to start the selection
else if (button == MOUSE_LEFT)
{
clip_start_selection(X_2_COL(x), Y_2_ROW(y), repeated_click);
did_clip = TRUE;
}
// Always allow pasting
if (button != MOUSE_MIDDLE)
{
if (!mouse_has(checkfor) || button == MOUSE_RELEASE)
return;
if (checkfor != MOUSE_COMMAND)
button = MOUSE_LEFT;
}
repeated_click = FALSE;
}
if (clip_star.state != SELECT_CLEARED && !did_clip)
clip_clear_selection(&clip_star);
#endif
// Don't put events in the input queue now.
if (hold_gui_events)
return;
row = gui_xy2colrow(x, y, &col);
/*
* If we are dragging and the mouse hasn't moved far enough to be on a
* different character, then don't send an event to vim.
*/
if (button == MOUSE_DRAG)
{
if (row == prev_row && col == prev_col)
return;
// Dragging above the window, set "row" to -1 to cause a scroll.
if (y < 0)
row = -1;
}
/*
* If topline has changed (window scrolled) since the last click, reset
* repeated_click, because we don't want starting Visual mode when
* clicking on a different character in the text.
*/
if (curwin->w_topline != gui_prev_topline
#ifdef FEAT_DIFF
|| curwin->w_topfill != gui_prev_topfill
#endif
)
repeated_click = FALSE;
string[0] = CSI; // this sequence is recognized by check_termcode()
string[1] = KS_MOUSE;
string[2] = KE_FILLER;
if (button != MOUSE_DRAG && button != MOUSE_RELEASE)
{
if (repeated_click)
{
/*
* Handle multiple clicks. They only count if the mouse is still
* pointing at the same character.
*/
if (button != prev_button || row != prev_row || col != prev_col)
num_clicks = 1;
else if (++num_clicks > 4)
num_clicks = 1;
}
else
num_clicks = 1;
prev_button = button;
gui_prev_topline = curwin->w_topline;
#ifdef FEAT_DIFF
gui_prev_topfill = curwin->w_topfill;
#endif
string[3] = (char_u)(button | 0x20);
SET_NUM_MOUSE_CLICKS(string[3], num_clicks);
}
else
string[3] = (char_u)button;
string[3] |= modifiers;
fill_mouse_coord(string + 4, col, row);
add_to_input_buf(string, 8);
if (row < 0)
prev_row = 0;
else
prev_row = row;
prev_col = col;
/*
* We need to make sure this is cleared since GTK doesn't tell us when
* the user is done dragging.
*/
#if defined(FEAT_GUI_GTK)
gui.dragged_sb = SBAR_NONE;
#endif
}
/*
* Convert x and y coordinate to column and row in text window.
* Corrects for multi-byte character.
* returns column in "*colp" and row as return value;
*/
static int
gui_xy2colrow(int x, int y, int *colp)
{
int col = check_col(X_2_COL(x));
int row = check_row(Y_2_ROW(y));
*colp = mb_fix_col(col, row);
return row;
}
#if defined(FEAT_MENU) || defined(PROTO)
/*
* Callback function for when a menu entry has been selected.
*/
void
gui_menu_cb(vimmenu_T *menu)
{
char_u bytes[sizeof(long_u)];
// Don't put events in the input queue now.
if (hold_gui_events)
return;
bytes[0] = CSI;
bytes[1] = KS_MENU;
bytes[2] = KE_FILLER;
add_to_input_buf(bytes, 3);
add_long_to_buf((long_u)menu, bytes);
add_to_input_buf_csi(bytes, sizeof(long_u));
}
#endif
static int prev_which_scrollbars[3];
/*
* Set which components are present.
* If "oldval" is not NULL, "oldval" is the previous value, the new value is
* in p_go.
*/
void
gui_init_which_components(char_u *oldval UNUSED)
{
#ifdef FEAT_GUI_DARKTHEME
static int prev_dark_theme = -1;
int using_dark_theme = FALSE;
#endif
#ifdef FEAT_MENU
static int prev_menu_is_active = -1;
#endif
#ifdef FEAT_TOOLBAR
static int prev_toolbar = -1;
int using_toolbar = FALSE;
#endif
#ifdef FEAT_GUI_TABLINE
int using_tabline;
#endif
#if defined(FEAT_MENU)
static int prev_tearoff = -1;
int using_tearoff = FALSE;
#endif
char_u *p;
int i;
#ifdef FEAT_MENU
int grey_old, grey_new;
char_u *temp;
#endif
win_T *wp;
int need_set_size;
int fix_size;
#ifdef FEAT_MENU
if (oldval != NULL && gui.in_use)
{
/*
* Check if the menus go from grey to non-grey or vice versa.
*/
grey_old = (vim_strchr(oldval, GO_GREY) != NULL);
grey_new = (vim_strchr(p_go, GO_GREY) != NULL);
if (grey_old != grey_new)
{
temp = p_go;
p_go = oldval;
gui_update_menus(MENU_ALL_MODES);
p_go = temp;
}
}
gui.menu_is_active = FALSE;
#endif
for (i = 0; i < 3; i++)
gui.which_scrollbars[i] = FALSE;
for (p = p_go; *p; p++)
switch (*p)
{
case GO_LEFT:
gui.which_scrollbars[SBAR_LEFT] = TRUE;
break;
case GO_RIGHT:
gui.which_scrollbars[SBAR_RIGHT] = TRUE;
break;
case GO_VLEFT:
if (win_hasvertsplit())
gui.which_scrollbars[SBAR_LEFT] = TRUE;
break;
case GO_VRIGHT:
if (win_hasvertsplit())
gui.which_scrollbars[SBAR_RIGHT] = TRUE;
break;
case GO_BOT:
gui.which_scrollbars[SBAR_BOTTOM] = TRUE;
break;
#ifdef FEAT_GUI_DARKTHEME
case GO_DARKTHEME:
using_dark_theme = TRUE;
break;
#endif
#ifdef FEAT_MENU
case GO_MENUS:
gui.menu_is_active = TRUE;
break;
#endif
case GO_GREY:
// make menu's have grey items, ignored here
break;
#ifdef FEAT_TOOLBAR
case GO_TOOLBAR:
using_toolbar = TRUE;
break;
#endif
case GO_TEAROFF:
#if defined(FEAT_MENU)
using_tearoff = TRUE;
#endif
break;
default:
// Ignore options that are not supported
break;
}
if (!gui.in_use)
return;
need_set_size = 0;
fix_size = FALSE;
#ifdef FEAT_GUI_DARKTHEME
if (using_dark_theme != prev_dark_theme)
{
gui_mch_set_dark_theme(using_dark_theme);
prev_dark_theme = using_dark_theme;
}
#endif
#ifdef FEAT_GUI_TABLINE
// Update the GUI tab line, it may appear or disappear. This may
// cause the non-GUI tab line to disappear or appear.
using_tabline = gui_has_tabline();
if (!gui_mch_showing_tabline() != !using_tabline)
{
// We don't want a resize event change "Rows" here, save and
// restore it. Resizing is handled below.
i = Rows;
gui_update_tabline();
Rows = i;
need_set_size |= RESIZE_VERT;
if (using_tabline)
fix_size = TRUE;
if (!gui_use_tabline())
redraw_tabline = TRUE; // may draw non-GUI tab line
}
#endif
for (i = 0; i < 3; i++)
{
// The scrollbar needs to be updated when it is shown/unshown and
// when switching tab pages. But the size only changes when it's
// shown/unshown. Thus we need two places to remember whether a
// scrollbar is there or not.
if (gui.which_scrollbars[i] != prev_which_scrollbars[i]
|| gui.which_scrollbars[i]
!= curtab->tp_prev_which_scrollbars[i])
{
if (i == SBAR_BOTTOM)
gui_mch_enable_scrollbar(&gui.bottom_sbar,
gui.which_scrollbars[i]);
else
{
FOR_ALL_WINDOWS(wp)
gui_do_scrollbar(wp, i, gui.which_scrollbars[i]);
}
if (gui.which_scrollbars[i] != prev_which_scrollbars[i])
{
if (i == SBAR_BOTTOM)
need_set_size |= RESIZE_VERT;
else
need_set_size |= RESIZE_HOR;
if (gui.which_scrollbars[i])
fix_size = TRUE;
}
}
curtab->tp_prev_which_scrollbars[i] = gui.which_scrollbars[i];
prev_which_scrollbars[i] = gui.which_scrollbars[i];
}
#ifdef FEAT_MENU
if (gui.menu_is_active != prev_menu_is_active)
{
// We don't want a resize event change "Rows" here, save and
// restore it. Resizing is handled below.
i = Rows;
gui_mch_enable_menu(gui.menu_is_active);
Rows = i;
prev_menu_is_active = gui.menu_is_active;
need_set_size |= RESIZE_VERT;
if (gui.menu_is_active)
fix_size = TRUE;
}
#endif
#ifdef FEAT_TOOLBAR
if (using_toolbar != prev_toolbar)
{
gui_mch_show_toolbar(using_toolbar);
prev_toolbar = using_toolbar;
need_set_size |= RESIZE_VERT;
if (using_toolbar)
fix_size = TRUE;
}
#endif
#if defined(FEAT_MENU) && !(defined(MSWIN) && !defined(FEAT_TEAROFF))
if (using_tearoff != prev_tearoff)
{
gui_mch_toggle_tearoffs(using_tearoff);
prev_tearoff = using_tearoff;
}
#endif
if (need_set_size != 0)
{
#ifdef FEAT_GUI_GTK
long prev_Columns = Columns;
long prev_Rows = Rows;
#endif
// Adjust the size of the window to make the text area keep the
// same size and to avoid that part of our window is off-screen
// and a scrollbar can't be used, for example.
gui_set_shellsize(FALSE, fix_size, need_set_size);
#ifdef FEAT_GUI_GTK
// GTK has the annoying habit of sending us resize events when
// changing the window size ourselves. This mostly happens when
// waiting for a character to arrive, quite unpredictably, and may
// change Columns and Rows when we don't want it. Wait for a
// character here to avoid this effect.
// If you remove this, please test this command for resizing
// effects (with optional left scrollbar): ":vsp|q|vsp|q|vsp|q".
// Don't do this while starting up though.
// Don't change Rows when adding menu/toolbar/tabline.
// Don't change Columns when adding vertical toolbar.
if (!gui.starting && need_set_size != (RESIZE_VERT | RESIZE_HOR))
(void)char_avail();
if ((need_set_size & RESIZE_VERT) == 0)
Rows = prev_Rows;
if ((need_set_size & RESIZE_HOR) == 0)
Columns = prev_Columns;
#endif
}
// When the console tabline appears or disappears the window positions
// change.
if (firstwin->w_winrow != tabline_height())
shell_new_rows(); // recompute window positions and heights
}
#if defined(FEAT_GUI_TABLINE) || defined(PROTO)
/*
* Return TRUE if the GUI is taking care of the tabline.
* It may still be hidden if 'showtabline' is zero.
*/
int
gui_use_tabline(void)
{
return gui.in_use && vim_strchr(p_go, GO_TABLINE) != NULL;
}
/*
* Return TRUE if the GUI is showing the tabline.
* This uses 'showtabline'.
*/
static int
gui_has_tabline(void)
{
if (!gui_use_tabline()
|| p_stal == 0
|| (p_stal == 1 && first_tabpage->tp_next == NULL))
return FALSE;
return TRUE;
}
/*
* Update the tabline.
* This may display/undisplay the tabline and update the labels.
*/
void
gui_update_tabline(void)
{
int showit = gui_has_tabline();
int shown = gui_mch_showing_tabline();
if (!gui.starting && starting == 0)
{
// Updating the tabline uses direct GUI commands, flush
// outstanding instructions first. (esp. clear screen)
out_flush();
if (!showit != !shown)
gui_mch_show_tabline(showit);
if (showit != 0)
gui_mch_update_tabline();
// When the tabs change from hidden to shown or from shown to
// hidden the size of the text area should remain the same.
if (!showit != !shown)
gui_set_shellsize(FALSE, showit, RESIZE_VERT);
}
}
/*
* Get the label or tooltip for tab page "tp" into NameBuff[].
*/
void
get_tabline_label(
tabpage_T *tp,
int tooltip) // TRUE: get tooltip
{
int modified = FALSE;
char_u buf[40];
int wincount;
win_T *wp;
char_u **opt;
// Use 'guitablabel' or 'guitabtooltip' if it's set.
opt = (tooltip ? &p_gtt : &p_gtl);
if (**opt != NUL)
{
char_u res[MAXPATHL];
tabpage_T *save_curtab;
char_u *opt_name = (char_u *)(tooltip ? "guitabtooltip"
: "guitablabel");
printer_page_num = tabpage_index(tp);
# ifdef FEAT_EVAL
set_vim_var_nr(VV_LNUM, printer_page_num);
# endif
// It's almost as going to the tabpage, but without autocommands.
curtab->tp_firstwin = firstwin;
curtab->tp_lastwin = lastwin;
curtab->tp_curwin = curwin;
save_curtab = curtab;
curtab = tp;
topframe = curtab->tp_topframe;
firstwin = curtab->tp_firstwin;
lastwin = curtab->tp_lastwin;
curwin = curtab->tp_curwin;
curbuf = curwin->w_buffer;
// Can't use NameBuff directly, build_stl_str_hl() uses it.
build_stl_str_hl(curwin, res, MAXPATHL, *opt, opt_name, 0,
0, (int)Columns, NULL, NULL);
STRCPY(NameBuff, res);
// Back to the original curtab.
curtab = save_curtab;
topframe = curtab->tp_topframe;
firstwin = curtab->tp_firstwin;
lastwin = curtab->tp_lastwin;
curwin = curtab->tp_curwin;
curbuf = curwin->w_buffer;
}
// If 'guitablabel'/'guitabtooltip' is not set or the result is empty then
// use a default label.
if (**opt == NUL || *NameBuff == NUL)
{
// Get the buffer name into NameBuff[] and shorten it.
get_trans_bufname(tp == curtab ? curbuf : tp->tp_curwin->w_buffer);
if (!tooltip)
shorten_dir(NameBuff);
wp = (tp == curtab) ? firstwin : tp->tp_firstwin;
for (wincount = 0; wp != NULL; wp = wp->w_next, ++wincount)
if (bufIsChanged(wp->w_buffer))
modified = TRUE;
if (modified || wincount > 1)
{
if (wincount > 1)
vim_snprintf((char *)buf, sizeof(buf), "%d", wincount);
else
buf[0] = NUL;
if (modified)
STRCAT(buf, "+");
STRCAT(buf, " ");
STRMOVE(NameBuff + STRLEN(buf), NameBuff);
mch_memmove(NameBuff, buf, STRLEN(buf));
}
}
}
/*
* Send the event for clicking to select tab page "nr".
* Returns TRUE if it was done, FALSE when skipped because we are already at
* that tab page or the cmdline window is open.
*/
int
send_tabline_event(int nr)
{
char_u string[3];
if (nr == tabpage_index(curtab))
return FALSE;
// Don't put events in the input queue now.
if (hold_gui_events || cmdwin_type != 0)
{
// Set it back to the current tab page.
gui_mch_set_curtab(tabpage_index(curtab));
return FALSE;
}
string[0] = CSI;
string[1] = KS_TABLINE;
string[2] = KE_FILLER;
add_to_input_buf(string, 3);
string[0] = nr;
add_to_input_buf_csi(string, 1);
return TRUE;
}
/*
* Send a tabline menu event
*/
void
send_tabline_menu_event(int tabidx, int event)
{
char_u string[3];
// Don't put events in the input queue now.
if (hold_gui_events)
return;
// Cannot close the last tabpage.
if (event == TABLINE_MENU_CLOSE && first_tabpage->tp_next == NULL)
return;
string[0] = CSI;
string[1] = KS_TABMENU;
string[2] = KE_FILLER;
add_to_input_buf(string, 3);
string[0] = tabidx;
string[1] = (char_u)(long)event;
add_to_input_buf_csi(string, 2);
}
#endif
/*
* Scrollbar stuff:
*/
/*
* Remove all scrollbars. Used before switching to another tab page.
*/
void
gui_remove_scrollbars(void)
{
int i;
win_T *wp;
for (i = 0; i < 3; i++)
{
if (i == SBAR_BOTTOM)
gui_mch_enable_scrollbar(&gui.bottom_sbar, FALSE);
else
{
FOR_ALL_WINDOWS(wp)
gui_do_scrollbar(wp, i, FALSE);
}
curtab->tp_prev_which_scrollbars[i] = -1;
}
}
void
gui_create_scrollbar(scrollbar_T *sb, int type, win_T *wp)
{
static int sbar_ident = 0;
sb->ident = sbar_ident++; // No check for too big, but would it happen?
sb->wp = wp;
sb->type = type;
sb->value = 0;
sb->size = 1;
sb->max = 1;
sb->top = 0;
sb->height = 0;
sb->width = 0;
sb->status_height = 0;
gui_mch_create_scrollbar(sb, (wp == NULL) ? SBAR_HORIZ : SBAR_VERT);
}
/*
* Find the scrollbar with the given index.
*/
scrollbar_T *
gui_find_scrollbar(long ident)
{
win_T *wp;
if (gui.bottom_sbar.ident == ident)
return &gui.bottom_sbar;
FOR_ALL_WINDOWS(wp)
{
if (wp->w_scrollbars[SBAR_LEFT].ident == ident)
return &wp->w_scrollbars[SBAR_LEFT];
if (wp->w_scrollbars[SBAR_RIGHT].ident == ident)
return &wp->w_scrollbars[SBAR_RIGHT];
}
return NULL;
}
/*
* For most systems: Put a code in the input buffer for a dragged scrollbar.
*
* For Win32, Macintosh and GTK+ 2:
* Scrollbars seem to grab focus and vim doesn't read the input queue until
* you stop dragging the scrollbar. We get here each time the scrollbar is
* dragged another pixel, but as far as the rest of vim goes, it thinks
* we're just hanging in the call to DispatchMessage() in
* process_message(). The DispatchMessage() call that hangs was passed a
* mouse button click event in the scrollbar window. -- webb.
*
* Solution: Do the scrolling right here. But only when allowed.
* Ignore the scrollbars while executing an external command or when there
* are still characters to be processed.
*/
void
gui_drag_scrollbar(scrollbar_T *sb, long value, int still_dragging)
{
win_T *wp;
int sb_num;
#ifdef USE_ON_FLY_SCROLL
colnr_T old_leftcol = curwin->w_leftcol;
linenr_T old_topline = curwin->w_topline;
# ifdef FEAT_DIFF
int old_topfill = curwin->w_topfill;
# endif
#else
char_u bytes[sizeof(long_u)];
int byte_count;
#endif
if (sb == NULL)
return;
// Don't put events in the input queue now.
if (hold_gui_events)
return;
if (cmdwin_type != 0 && sb->wp != cmdwin_win)
return;
if (still_dragging)
{
if (sb->wp == NULL)
gui.dragged_sb = SBAR_BOTTOM;
else if (sb == &sb->wp->w_scrollbars[SBAR_LEFT])
gui.dragged_sb = SBAR_LEFT;
else
gui.dragged_sb = SBAR_RIGHT;
gui.dragged_wp = sb->wp;
}
else
{
gui.dragged_sb = SBAR_NONE;
#ifdef FEAT_GUI_GTK
// Keep the "dragged_wp" value until after the scrolling, for when the
// mouse button is released. GTK2 doesn't send the button-up event.
gui.dragged_wp = NULL;
#endif
}
// Vertical sbar info is kept in the first sbar (the left one)
if (sb->wp != NULL)
sb = &sb->wp->w_scrollbars[0];
/*
* Check validity of value
*/
if (value < 0)
value = 0;
#ifdef SCROLL_PAST_END
else if (value > sb->max)
value = sb->max;
#else
if (value > sb->max - sb->size + 1)
value = sb->max - sb->size + 1;
#endif
sb->value = value;
#ifdef USE_ON_FLY_SCROLL
// When not allowed to do the scrolling right now, return.
// This also checked input_available(), but that causes the first click in
// a scrollbar to be ignored when Vim doesn't have focus.
if (dont_scroll)
return;
#endif
// Disallow scrolling the current window when the completion popup menu is
// visible.
if ((sb->wp == NULL || sb->wp == curwin) && pum_visible())
return;
#ifdef FEAT_RIGHTLEFT
if (sb->wp == NULL && curwin->w_p_rl)
{
value = sb->max + 1 - sb->size - value;
if (value < 0)
value = 0;
}
#endif
if (sb->wp != NULL) // vertical scrollbar
{
sb_num = 0;
for (wp = firstwin; wp != sb->wp && wp != NULL; wp = wp->w_next)
sb_num++;
if (wp == NULL)
return;
#ifdef USE_ON_FLY_SCROLL
current_scrollbar = sb_num;
scrollbar_value = value;
if (State & MODE_NORMAL)
{
gui_do_scroll();
setcursor();
}
else if (State & MODE_INSERT)
{
ins_scroll();
setcursor();
}
else if (State & MODE_CMDLINE)
{
if (msg_scrolled == 0)
{
gui_do_scroll();
redrawcmdline();
}
}
# ifdef FEAT_FOLDING
// Value may have been changed for closed fold.
sb->value = sb->wp->w_topline - 1;
# endif
// When dragging one scrollbar and there is another one at the other
// side move the thumb of that one too.
if (gui.which_scrollbars[SBAR_RIGHT] && gui.which_scrollbars[SBAR_LEFT])
gui_mch_set_scrollbar_thumb(
&sb->wp->w_scrollbars[
sb == &sb->wp->w_scrollbars[SBAR_RIGHT]
? SBAR_LEFT : SBAR_RIGHT],
sb->value, sb->size, sb->max);
#else
bytes[0] = CSI;
bytes[1] = KS_VER_SCROLLBAR;
bytes[2] = KE_FILLER;
bytes[3] = (char_u)sb_num;
byte_count = 4;
#endif
}
else
{
#ifdef USE_ON_FLY_SCROLL
scrollbar_value = value;
if (State & MODE_NORMAL)
do_mousescroll_horiz(scrollbar_value);
else if (State & MODE_INSERT)
ins_horscroll();
else if (State & MODE_CMDLINE)
{
if (msg_scrolled == 0)
{
do_mousescroll_horiz(scrollbar_value);
redrawcmdline();
}
}
if (old_leftcol != curwin->w_leftcol)
{
updateWindow(curwin); // update window, status and cmdline
setcursor();
}
#else
bytes[0] = CSI;
bytes[1] = KS_HOR_SCROLLBAR;
bytes[2] = KE_FILLER;
byte_count = 3;
#endif
}
#ifdef USE_ON_FLY_SCROLL
/*
* synchronize other windows, as necessary according to 'scrollbind'
*/
if (curwin->w_p_scb
&& ((sb->wp == NULL && curwin->w_leftcol != old_leftcol)
|| (sb->wp == curwin && (curwin->w_topline != old_topline
# ifdef FEAT_DIFF
|| curwin->w_topfill != old_topfill
# endif
))))
{
do_check_scrollbind(TRUE);
// need to update the window right here
FOR_ALL_WINDOWS(wp)
if (wp->w_redr_type > 0)
updateWindow(wp);
setcursor();
}
out_flush_cursor(FALSE, TRUE);
#else
add_to_input_buf(bytes, byte_count);
add_long_to_buf((long_u)value, bytes);
add_to_input_buf_csi(bytes, sizeof(long_u));
#endif
}
/*
* Scrollbar stuff:
*/
/*
* Called when something in the window layout has changed.
*/
void
gui_may_update_scrollbars(void)
{
if (gui.in_use && starting == 0)
{
out_flush();
gui_init_which_components(NULL);
gui_update_scrollbars(TRUE);
}
need_mouse_correct = TRUE;
}
void
gui_update_scrollbars(
int force) // Force all scrollbars to get updated
{
win_T *wp;
scrollbar_T *sb;
long val, size, max; // need 32 bits here
int which_sb;
int h, y;
static win_T *prev_curwin = NULL;
// Update the horizontal scrollbar
gui_update_horiz_scrollbar(force);
#ifndef MSWIN
// Return straight away if there is neither a left nor right scrollbar.
// On MS-Windows this is required anyway for scrollwheel messages.
if (!gui.which_scrollbars[SBAR_LEFT] && !gui.which_scrollbars[SBAR_RIGHT])
return;
#endif
/*
* Don't want to update a scrollbar while we're dragging it. But if we
* have both a left and right scrollbar, and we drag one of them, we still
* need to update the other one.
*/
if (!force && (gui.dragged_sb == SBAR_LEFT || gui.dragged_sb == SBAR_RIGHT)
&& gui.which_scrollbars[SBAR_LEFT]
&& gui.which_scrollbars[SBAR_RIGHT])
{
/*
* If we have two scrollbars and one of them is being dragged, just
* copy the scrollbar position from the dragged one to the other one.
*/
which_sb = SBAR_LEFT + SBAR_RIGHT - gui.dragged_sb;
if (gui.dragged_wp != NULL)
gui_mch_set_scrollbar_thumb(
&gui.dragged_wp->w_scrollbars[which_sb],
gui.dragged_wp->w_scrollbars[0].value,
gui.dragged_wp->w_scrollbars[0].size,
gui.dragged_wp->w_scrollbars[0].max);
}
// avoid that moving components around generates events
++hold_gui_events;
FOR_ALL_WINDOWS(wp)
{
if (wp->w_buffer == NULL) // just in case
continue;
// Skip a scrollbar that is being dragged.
if (!force && (gui.dragged_sb == SBAR_LEFT
|| gui.dragged_sb == SBAR_RIGHT)
&& gui.dragged_wp == wp)
continue;
#ifdef SCROLL_PAST_END
max = wp->w_buffer->b_ml.ml_line_count - 1;
#else
max = wp->w_buffer->b_ml.ml_line_count + wp->w_height - 2;
#endif
if (max < 0) // empty buffer
max = 0;
val = wp->w_topline - 1;
size = wp->w_height;
#ifdef SCROLL_PAST_END
if (val > max) // just in case
val = max;
#else
if (size > max + 1) // just in case
size = max + 1;
if (val > max - size + 1)
val = max - size + 1;
#endif
if (val < 0) // minimal value is 0
val = 0;
/*
* Scrollbar at index 0 (the left one) contains all the information.
* It would be the same info for left and right so we just store it for
* one of them.
*/
sb = &wp->w_scrollbars[0];
/*
* Note: no check for valid w_botline. If it's not valid the
* scrollbars will be updated later anyway.
*/
if (size < 1 || wp->w_botline - 2 > max)
{
/*
* This can happen during changing files. Just don't update the
* scrollbar for now.
*/
sb->height = 0; // Force update next time
if (gui.which_scrollbars[SBAR_LEFT])
gui_do_scrollbar(wp, SBAR_LEFT, FALSE);
if (gui.which_scrollbars[SBAR_RIGHT])
gui_do_scrollbar(wp, SBAR_RIGHT, FALSE);
continue;
}
if (force || sb->height != wp->w_height
|| sb->top != wp->w_winrow
|| sb->status_height != wp->w_status_height
|| sb->width != wp->w_width
|| prev_curwin != curwin)
{
// Height, width or position of scrollbar has changed. For
// vertical split: curwin changed.
sb->height = wp->w_height;
sb->top = wp->w_winrow;
sb->status_height = wp->w_status_height;
sb->width = wp->w_width;
// Calculate height and position in pixels
h = (sb->height + sb->status_height) * gui.char_height;
y = sb->top * gui.char_height + gui.border_offset;
#if defined(FEAT_MENU) && !defined(FEAT_GUI_GTK) && !defined(FEAT_GUI_MOTIF) && !defined(FEAT_GUI_PHOTON)
if (gui.menu_is_active)
y += gui.menu_height;
#endif
#if defined(FEAT_TOOLBAR) && (defined(FEAT_GUI_MSWIN) \
|| defined(FEAT_GUI_HAIKU))
if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
y += gui.toolbar_height;
#endif
#if defined(FEAT_GUI_TABLINE) && defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_HAIKU)
if (gui_has_tabline())
y += gui.tabline_height;
#endif
if (wp->w_winrow == 0)
{
// Height of top scrollbar includes width of top border
h += gui.border_offset;
y -= gui.border_offset;
}
if (gui.which_scrollbars[SBAR_LEFT])
{
gui_mch_set_scrollbar_pos(&wp->w_scrollbars[SBAR_LEFT],
gui.left_sbar_x, y,
gui.scrollbar_width, h);
gui_do_scrollbar(wp, SBAR_LEFT, TRUE);
}
if (gui.which_scrollbars[SBAR_RIGHT])
{
gui_mch_set_scrollbar_pos(&wp->w_scrollbars[SBAR_RIGHT],
gui.right_sbar_x, y,
gui.scrollbar_width, h);
gui_do_scrollbar(wp, SBAR_RIGHT, TRUE);
}
}
if (force || sb->value != val || sb->size != size || sb->max != max)
{
// Thumb of scrollbar has moved
sb->value = val;
sb->size = size;
sb->max = max;
if (gui.which_scrollbars[SBAR_LEFT]
&& (gui.dragged_sb != SBAR_LEFT || gui.dragged_wp != wp))
gui_mch_set_scrollbar_thumb(&wp->w_scrollbars[SBAR_LEFT],
val, size, max);
if (gui.which_scrollbars[SBAR_RIGHT]
&& (gui.dragged_sb != SBAR_RIGHT || gui.dragged_wp != wp))
gui_mch_set_scrollbar_thumb(&wp->w_scrollbars[SBAR_RIGHT],
val, size, max);
}
}
// update the title, it may show the scroll position
maketitle();
prev_curwin = curwin;
--hold_gui_events;
}
/*
* Enable or disable a scrollbar.
* Check for scrollbars for vertically split windows which are not enabled
* sometimes.
*/
static void
gui_do_scrollbar(
win_T *wp,
int which, // SBAR_LEFT or SBAR_RIGHT
int enable) // TRUE to enable scrollbar
{
int midcol = curwin->w_wincol + curwin->w_width / 2;
int has_midcol = (wp->w_wincol <= midcol
&& wp->w_wincol + wp->w_width >= midcol);
// Only enable scrollbars that contain the middle column of the current
// window.
if (gui.which_scrollbars[SBAR_RIGHT] != gui.which_scrollbars[SBAR_LEFT])
{
// Scrollbars only on one side. Don't enable scrollbars that don't
// contain the middle column of the current window.
if (!has_midcol)
enable = FALSE;
}
else
{
// Scrollbars on both sides. Don't enable scrollbars that neither
// contain the middle column of the current window nor are on the far
// side.
if (midcol > Columns / 2)
{
if (which == SBAR_LEFT ? wp->w_wincol != 0 : !has_midcol)
enable = FALSE;
}
else
{
if (which == SBAR_RIGHT ? wp->w_wincol + wp->w_width != Columns
: !has_midcol)
enable = FALSE;
}
}
gui_mch_enable_scrollbar(&wp->w_scrollbars[which], enable);
}
/*
* Scroll a window according to the values set in the globals
* "current_scrollbar" and "scrollbar_value".
* Return TRUE if the cursor in the current window moved or FALSE otherwise.
* may eventually cause a redraw using updateWindow
*/
int
gui_do_scroll(void)
{
win_T *wp, *save_wp;
int i;
long nlines;
pos_T old_cursor;
linenr_T old_topline;
#ifdef FEAT_DIFF
int old_topfill;
#endif
for (wp = firstwin, i = 0; i < current_scrollbar; wp = W_NEXT(wp), i++)
if (wp == NULL)
break;
if (wp == NULL)
// Couldn't find window
return FALSE;
// don't redraw, LineOffset and similar are not valid!
if (exmode_active)
return FALSE;
/*
* Compute number of lines to scroll. If zero, nothing to do.
*/
nlines = (long)scrollbar_value + 1 - (long)wp->w_topline;
if (nlines == 0)
return FALSE;
save_wp = curwin;
old_topline = wp->w_topline;
#ifdef FEAT_DIFF
old_topfill = wp->w_topfill;
#endif
old_cursor = wp->w_cursor;
curwin = wp;
curbuf = wp->w_buffer;
if (nlines < 0)
scrolldown(-nlines, gui.dragged_wp == NULL);
else
scrollup(nlines, gui.dragged_wp == NULL);
// Reset dragged_wp after using it. "dragged_sb" will have been reset for
// the mouse-up event already, but we still want it to behave like when
// dragging. But not the next click in an arrow.
if (gui.dragged_sb == SBAR_NONE)
gui.dragged_wp = NULL;
if (old_topline != wp->w_topline
#ifdef FEAT_DIFF
|| old_topfill != wp->w_topfill
#endif
)
{
if (get_scrolloff_value() != 0)
{
cursor_correct(); // fix window for 'so'
update_topline(); // avoid up/down jump
}
if (old_cursor.lnum != wp->w_cursor.lnum)
coladvance(wp->w_curswant);
wp->w_scbind_pos = wp->w_topline;
}
// Make sure wp->w_leftcol and wp->w_skipcol are correct.
validate_cursor();
curwin = save_wp;
curbuf = save_wp->w_buffer;
/*
* Don't call updateWindow() when nothing has changed (it will overwrite
* the status line!).
*
* Check for ScreenLines, because in ex-mode, we don't have a valid display.
*/
if (ScreenLines != NULL && (old_topline != wp->w_topline
|| wp->w_redr_type != 0
#ifdef FEAT_DIFF
|| old_topfill != wp->w_topfill
#endif
))
{
int type = UPD_VALID;
if (pum_visible())
{
type = UPD_NOT_VALID;
wp->w_lines_valid = 0;
}
// Don't set must_redraw here, it may cause the popup menu to
// disappear when losing focus after a scrollbar drag.
if (wp->w_redr_type < type)
wp->w_redr_type = type;
mch_disable_flush();
updateWindow(wp); // update window, status line, and cmdline
mch_enable_flush();
}
// May need to redraw the popup menu.
if (pum_visible())
pum_redraw();
return (wp == curwin && !EQUAL_POS(curwin->w_cursor, old_cursor));
}
/*
* Horizontal scrollbar stuff:
*/
static void
gui_update_horiz_scrollbar(int force)
{
long value, size, max;
if (!gui.which_scrollbars[SBAR_BOTTOM])
return;
if (!force && gui.dragged_sb == SBAR_BOTTOM)
return;
if (!force && curwin->w_p_wrap && gui.prev_wrap)
return;
/*
* It is possible for the cursor to be invalid if we're in the middle of
* something (like changing files). If so, don't do anything for now.
*/
if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
{
gui.bottom_sbar.value = -1;
return;
}
size = curwin->w_width;
if (curwin->w_p_wrap)
{
value = 0;
#ifdef SCROLL_PAST_END
max = 0;
#else
max = curwin->w_width - 1;
#endif
}
else
{
value = curwin->w_leftcol;
max = scroll_line_len(ui_find_longest_lnum());
if (virtual_active())
{
// May move the cursor even further to the right.
if (curwin->w_virtcol >= (colnr_T)max)
max = curwin->w_virtcol;
}
#ifndef SCROLL_PAST_END
max += curwin->w_width - 1;
#endif
// The line number isn't scrolled, thus there is less space when
// 'number' or 'relativenumber' is set (also for 'foldcolumn').
size -= curwin_col_off();
#ifndef SCROLL_PAST_END
max -= curwin_col_off();
#endif
}
#ifndef SCROLL_PAST_END
if (value > max - size + 1)
value = max - size + 1; // limit the value to allowable range
#endif
#ifdef FEAT_RIGHTLEFT
if (curwin->w_p_rl)
{
value = max + 1 - size - value;
if (value < 0)
{
size += value;
value = 0;
}
}
#endif
if (!force && value == gui.bottom_sbar.value && size == gui.bottom_sbar.size
&& max == gui.bottom_sbar.max)
return;
gui.bottom_sbar.value = value;
gui.bottom_sbar.size = size;
gui.bottom_sbar.max = max;
gui.prev_wrap = curwin->w_p_wrap;
gui_mch_set_scrollbar_thumb(&gui.bottom_sbar, value, size, max);
}
/*
* Check that none of the colors are the same as the background color
*/
void
gui_check_colors(void)
{
if (gui.norm_pixel == gui.back_pixel || gui.norm_pixel == INVALCOLOR)
{
gui_set_bg_color((char_u *)"White");
if (gui.norm_pixel == gui.back_pixel || gui.norm_pixel == INVALCOLOR)
gui_set_fg_color((char_u *)"Black");
}
}
static void
gui_set_fg_color(char_u *name)
{
gui.norm_pixel = gui_get_color(name);
hl_set_fg_color_name(vim_strsave(name));
}
static void
gui_set_bg_color(char_u *name)
{
gui.back_pixel = gui_get_color(name);
hl_set_bg_color_name(vim_strsave(name));
}
/*
* Allocate a color by name.
* Returns INVALCOLOR and gives an error message when failed.
*/
guicolor_T
gui_get_color(char_u *name)
{
guicolor_T t;
if (*name == NUL)
return INVALCOLOR;
t = gui_mch_get_color(name);
int is_none = STRCMP(name, "none") == 0;
if (t == INVALCOLOR
#if defined(FEAT_GUI_X11) || defined(FEAT_GUI_GTK)
&& (gui.in_use || is_none)
#endif
)
{
if (is_none)
emsg(_(e_cannot_use_color_none_did_you_mean_none));
else
semsg(_(e_cannot_allocate_color_str), name);
}
return t;
}
/*
* Return the grey value of a color (range 0-255).
*/
int
gui_get_lightness(guicolor_T pixel)
{
long_u rgb = (long_u)gui_mch_get_rgb(pixel);
return (int)( (((rgb >> 16) & 0xff) * 299)
+ (((rgb >> 8) & 0xff) * 587)
+ ((rgb & 0xff) * 114)) / 1000;
}
char_u *
gui_bg_default(void)
{
if (gui_get_lightness(gui.back_pixel) < 127)
return (char_u *)"dark";
return (char_u *)"light";
}
/*
* Option initializations that can only be done after opening the GUI window.
*/
static void
init_gui_options(void)
{
// Set the 'background' option according to the lightness of the
// background color, unless the user has set it already.
if (!option_was_set((char_u *)"bg") && STRCMP(p_bg, gui_bg_default()) != 0)
{
set_option_value_give_err((char_u *)"bg", 0L, gui_bg_default(), 0);
highlight_changed();
}
}
#if defined(FEAT_GUI_X11) || defined(PROTO)
void
gui_new_scrollbar_colors(void)
{
win_T *wp;
// Nothing to do if GUI hasn't started yet.
if (!gui.in_use)
return;
FOR_ALL_WINDOWS(wp)
{
gui_mch_set_scrollbar_colors(&(wp->w_scrollbars[SBAR_LEFT]));
gui_mch_set_scrollbar_colors(&(wp->w_scrollbars[SBAR_RIGHT]));
}
gui_mch_set_scrollbar_colors(&gui.bottom_sbar);
}
#endif
/*
* Call this when focus has changed.
*/
void
gui_focus_change(int in_focus)
{
/*
* Skip this code to avoid drawing the cursor when debugging and switching
* between the debugger window and gvim.
*/
#if 1
gui.in_focus = in_focus;
out_flush_cursor(TRUE, FALSE);
# ifdef FEAT_XIM
xim_set_focus(in_focus);
# endif
// Put events in the input queue only when allowed.
// ui_focus_change() isn't called directly, because it invokes
// autocommands and that must not happen asynchronously.
if (!hold_gui_events)
{
char_u bytes[3];
bytes[0] = CSI;
bytes[1] = KS_EXTRA;
bytes[2] = in_focus ? (int)KE_FOCUSGAINED : (int)KE_FOCUSLOST;
add_to_input_buf(bytes, 3);
}
#endif
}
/*
* When mouse moved: apply 'mousefocus'.
* Also updates the mouse pointer shape.
*/
static void
gui_mouse_focus(int x, int y)
{
win_T *wp;
char_u st[8];
#ifdef FEAT_MOUSESHAPE
// Get window pointer, and update mouse shape as well.
wp = xy2win(x, y, IGNORE_POPUP);
#endif
// Only handle this when 'mousefocus' set and ...
if (p_mousef
&& !hold_gui_events // not holding events
&& (State & (MODE_NORMAL | MODE_INSERT))// Normal/Visual/Insert mode
&& State != MODE_HITRETURN // but not hit-return prompt
&& msg_scrolled == 0 // no scrolled message
&& !need_mouse_correct // not moving the pointer
&& gui.in_focus) // gvim in focus
{
// Don't move the mouse when it's left or right of the Vim window
if (x < 0 || x > Columns * gui.char_width)
return;
#ifndef FEAT_MOUSESHAPE
wp = xy2win(x, y, IGNORE_POPUP);
#endif
if (wp == curwin || wp == NULL)
return; // still in the same old window, or none at all
// Ignore position in the tab pages line.
if (Y_2_ROW(y) < tabline_height())
return;
/*
* Format a mouse click on status line input,
* ala gui_send_mouse_event(0, x, y, 0, 0);
* Trick: Use a column number -1, so that get_pseudo_mouse_code() will
* generate a K_LEFTMOUSE_NM key code.
*/
if (finish_op)
{
// abort the current operator first
st[0] = ESC;
add_to_input_buf(st, 1);
}
st[0] = CSI;
st[1] = KS_MOUSE;
st[2] = KE_FILLER;
st[3] = (char_u)MOUSE_LEFT;
fill_mouse_coord(st + 4,
wp->w_wincol == 0 ? -1 : wp->w_wincol + MOUSE_COLOFF,
wp->w_height + W_WINROW(wp));
add_to_input_buf(st, 8);
st[3] = (char_u)MOUSE_RELEASE;
add_to_input_buf(st, 8);
#ifdef FEAT_GUI_GTK
// Need to wake up the main loop
if (gtk_main_level() > 0)
gtk_main_quit();
#endif
}
}
/*
* Called when the mouse moved (but not when dragging).
*/
void
gui_mouse_moved(int x, int y)
{
// Ignore this while still starting up.
if (!gui.in_use || gui.starting)
return;
// apply 'mousefocus' and pointer shape
gui_mouse_focus(x, y);
if (p_mousemev
#ifdef FEAT_PROP_POPUP
|| popup_uses_mouse_move
#endif
)
// Generate a mouse-moved event. For a <MouseMove> mapping. Or so the
// popup can perhaps be closed, just like in the terminal.
gui_send_mouse_event(MOUSE_MOVE, x, y, FALSE, 0);
}
/*
* Get the window where the mouse pointer is on.
* Returns NULL if not found.
*/
win_T *
gui_mouse_window(mouse_find_T popup)
{
int x, y;
if (!(gui.in_use && (p_mousef || popup == FIND_POPUP)))
return NULL;
gui_mch_getmouse(&x, &y);
// Only use the mouse when it's on the Vim window
if (x >= 0 && x <= Columns * gui.char_width
&& y >= 0 && Y_2_ROW(y) >= tabline_height())
return xy2win(x, y, popup);
return NULL;
}
/*
* Called when mouse should be moved to window with focus.
*/
void
gui_mouse_correct(void)
{
win_T *wp = NULL;
need_mouse_correct = FALSE;
wp = gui_mouse_window(IGNORE_POPUP);
if (wp == curwin || wp == NULL)
return;
// If in other than current window
validate_cline_row();
gui_mch_setmouse((int)W_ENDCOL(curwin) * gui.char_width - 3,
(W_WINROW(curwin) + curwin->w_wrow) * gui.char_height
+ (gui.char_height) / 2);
}
/*
* Find window where the mouse pointer "x" / "y" coordinate is in.
* As a side effect update the shape of the mouse pointer.
*/
static win_T *
xy2win(int x, int y, mouse_find_T popup)
{
int row;
int col;
win_T *wp;
row = Y_2_ROW(y);
col = X_2_COL(x);
if (row < 0 || col < 0) // before first window
return NULL;
wp = mouse_find_win(&row, &col, popup);
if (wp == NULL)
return NULL;
#ifdef FEAT_MOUSESHAPE
if (State == MODE_HITRETURN || State == MODE_ASKMORE)
{
if (Y_2_ROW(y) >= msg_row)
update_mouseshape(SHAPE_IDX_MOREL);
else
update_mouseshape(SHAPE_IDX_MORE);
}
else if (row > wp->w_height) // below status line
update_mouseshape(SHAPE_IDX_CLINE);
else if (!(State & MODE_CMDLINE) && wp->w_vsep_width > 0 && col == wp->w_width
&& (row != wp->w_height || !stl_connected(wp)) && msg_scrolled == 0)
update_mouseshape(SHAPE_IDX_VSEP);
else if (!(State & MODE_CMDLINE) && wp->w_status_height > 0
&& row == wp->w_height && msg_scrolled == 0)
update_mouseshape(SHAPE_IDX_STATUS);
else
update_mouseshape(-2);
#endif
return wp;
}
/*
* ":gui" and ":gvim": Change from the terminal version to the GUI version.
* File names may be given to redefine the args list.
*/
void
ex_gui(exarg_T *eap)
{
char_u *arg = eap->arg;
/*
* Check for "-f" argument: foreground, don't fork.
* Also don't fork when started with "gvim -f".
* Do fork when using "gui -b".
*/
if (arg[0] == '-'
&& (arg[1] == 'f' || arg[1] == 'b')
&& (arg[2] == NUL || VIM_ISWHITE(arg[2])))
{
gui.dofork = (arg[1] == 'b');
eap->arg = skipwhite(eap->arg + 2);
}
if (!gui.in_use)
{
#if defined(VIMDLL) && !defined(EXPERIMENTAL_GUI_CMD)
if (!gui.starting)
{
emsg(_(e_gui_cannot_be_used_not_enabled_at_compile_time));
return;
}
#endif
// Clear the command. Needed for when forking+exiting, to avoid part
// of the argument ending up after the shell prompt.
msg_clr_eos_force();
#ifdef GUI_MAY_SPAWN
if (!ends_excmd2(eap->cmd, eap->arg))
gui_start(eap->arg);
else
#endif
gui_start(NULL);
#ifdef FEAT_JOB_CHANNEL
channel_gui_register_all();
#endif
}
if (!ends_excmd2(eap->cmd, eap->arg))
ex_next(eap);
}
#if ((defined(FEAT_GUI_X11) || defined(FEAT_GUI_GTK) \
|| defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_PHOTON) \
|| defined(FEAT_GUI_HAIKU)) \
&& defined(FEAT_TOOLBAR)) || defined(PROTO)
/*
* This is shared between Haiku, Motif, and GTK.
*/
/*
* Callback function for do_in_runtimepath().
*/
static void
gfp_setname(char_u *fname, void *cookie)
{
char_u *gfp_buffer = cookie;
if (STRLEN(fname) >= MAXPATHL)
*gfp_buffer = NUL;
else
STRCPY(gfp_buffer, fname);
}
/*
* Find the path of bitmap "name" with extension "ext" in 'runtimepath'.
* Return FAIL for failure and OK if buffer[MAXPATHL] contains the result.
*/
int
gui_find_bitmap(char_u *name, char_u *buffer, char *ext)
{
if (STRLEN(name) > MAXPATHL - 14)
return FAIL;
vim_snprintf((char *)buffer, MAXPATHL, "bitmaps/%s.%s", name, ext);
if (do_in_runtimepath(buffer, 0, gfp_setname, buffer) == FAIL
|| *buffer == NUL)
return FAIL;
return OK;
}
# if !defined(FEAT_GUI_GTK) || defined(PROTO)
/*
* Given the name of the "icon=" argument, try finding the bitmap file for the
* icon. If it is an absolute path name, use it as it is. Otherwise append
* "ext" and search for it in 'runtimepath'.
* The result is put in "buffer[MAXPATHL]". If something fails "buffer"
* contains "name".
*/
void
gui_find_iconfile(char_u *name, char_u *buffer, char *ext)
{
char_u buf[MAXPATHL + 1];
expand_env(name, buffer, MAXPATHL);
if (!mch_isFullName(buffer) && gui_find_bitmap(buffer, buf, ext) == OK)
STRCPY(buffer, buf);
}
# endif
#endif
#if defined(FEAT_GUI_GTK) || defined(FEAT_GUI_X11)|| defined(FEAT_GUI_HAIKU) \
|| defined(PROTO)
void
display_errors(void)
{
char_u *p;
if (isatty(2))
{
fflush(stderr);
return;
}
if (error_ga.ga_data == NULL)
return;
// avoid putting up a message box with blanks only
for (p = (char_u *)error_ga.ga_data; *p != NUL; ++p)
if (!SAFE_isspace(*p))
{
// Truncate a very long message, it will go off-screen.
if (STRLEN(p) > 2000)
STRCPY(p + 2000 - 14, "...(truncated)");
(void)do_dialog(VIM_ERROR, (char_u *)_("Error"),
p, (char_u *)_("&Ok"), 1, NULL, FALSE);
break;
}
ga_clear(&error_ga);
}
#endif
#if defined(NO_CONSOLE_INPUT) || defined(PROTO)
/*
* Return TRUE if still starting up and there is no place to enter text.
* For GTK and X11 we check if stderr is not a tty, which means we were
* (probably) started from the desktop. Also check stdin, "vim >& file" does
* allow typing on stdin.
*/
int
no_console_input(void)
{
return ((!gui.in_use || gui.starting)
# ifndef NO_CONSOLE
&& !isatty(0) && !isatty(2)
# endif
);
}
#endif
#if defined(FIND_REPLACE_DIALOG) \
|| defined(NEED_GUI_UPDATE_SCREEN) \
|| defined(PROTO)
/*
* Update the current window and the screen.
*/
void
gui_update_screen(void)
{
# ifdef FEAT_CONCEAL
linenr_T conceal_old_cursor_line = 0;
linenr_T conceal_new_cursor_line = 0;
int conceal_update_lines = FALSE;
# endif
update_topline();
validate_cursor();
// Trigger CursorMoved if the cursor moved.
if (!finish_op && (has_cursormoved()
# ifdef FEAT_PROP_POPUP
|| popup_visible
# endif
# ifdef FEAT_CONCEAL
|| curwin->w_p_cole > 0
# endif
) && !EQUAL_POS(last_cursormoved, curwin->w_cursor))
{
if (has_cursormoved())
apply_autocmds(EVENT_CURSORMOVED, NULL, NULL, FALSE, curbuf);
# ifdef FEAT_PROP_POPUP
if (popup_visible)
popup_check_cursor_pos();
# endif
# ifdef FEAT_CONCEAL
if (curwin->w_p_cole > 0)
{
conceal_old_cursor_line = last_cursormoved.lnum;
conceal_new_cursor_line = curwin->w_cursor.lnum;
conceal_update_lines = TRUE;
}
# endif
last_cursormoved = curwin->w_cursor;
}
if (!finish_op)
may_trigger_win_scrolled_resized();
# ifdef FEAT_CONCEAL
if (conceal_update_lines
&& (conceal_old_cursor_line != conceal_new_cursor_line
|| conceal_cursor_line(curwin)
|| need_cursor_line_redraw))
{
if (conceal_old_cursor_line != conceal_new_cursor_line)
redrawWinline(curwin, conceal_old_cursor_line);
redrawWinline(curwin, conceal_new_cursor_line);
curwin->w_valid &= ~VALID_CROW;
need_cursor_line_redraw = FALSE;
}
# endif
update_screen(0); // may need to update the screen
setcursor();
out_flush_cursor(TRUE, FALSE);
}
#endif
#if defined(FIND_REPLACE_DIALOG) || defined(PROTO)
/*
* Get the text to use in a find/replace dialog. Uses the last search pattern
* if the argument is empty.
* Returns an allocated string.
*/
char_u *
get_find_dialog_text(
char_u *arg,
int *wwordp, // return: TRUE if \< \> found
int *mcasep) // return: TRUE if \C found
{
char_u *text;
if (*arg == NUL)
text = last_search_pat();
else
text = arg;
if (text != NULL)
{
text = vim_strsave(text);
if (text != NULL)
{
int len = (int)STRLEN(text);
int i;
// Remove "\V"
if (len >= 2 && STRNCMP(text, "\\V", 2) == 0)
{
mch_memmove(text, text + 2, (size_t)(len - 1));
len -= 2;
}
// Recognize "\c" and "\C" and remove.
if (len >= 2 && *text == '\\' && (text[1] == 'c' || text[1] == 'C'))
{
*mcasep = (text[1] == 'C');
mch_memmove(text, text + 2, (size_t)(len - 1));
len -= 2;
}
// Recognize "\<text\>" and remove.
if (len >= 4
&& STRNCMP(text, "\\<", 2) == 0
&& STRNCMP(text + len - 2, "\\>", 2) == 0)
{
*wwordp = TRUE;
mch_memmove(text, text + 2, (size_t)(len - 4));
text[len - 4] = NUL;
}
// Recognize "\/" or "\?" and remove.
for (i = 0; i + 1 < len; ++i)
if (text[i] == '\\' && (text[i + 1] == '/'
|| text[i + 1] == '?'))
{
mch_memmove(text + i, text + i + 1, (size_t)(len - i));
--len;
}
}
}
return text;
}
/*
* Handle the press of a button in the find-replace dialog.
* Return TRUE when something was added to the input buffer.
*/
int
gui_do_findrepl(
int flags, // one of FRD_REPLACE, FRD_FINDNEXT, etc.
char_u *find_text,
char_u *repl_text,
int down) // Search downwards.
{
garray_T ga;
int i;
int type = (flags & FRD_TYPE_MASK);
char_u *p;
regmatch_T regmatch;
int save_did_emsg = did_emsg;
static int busy = FALSE;
// When the screen is being updated we should not change buffers and
// windows structures, it may cause freed memory to be used. Also don't
// do this recursively (pressing "Find" quickly several times).
if (updating_screen || busy)
return FALSE;
// refuse replace when text cannot be changed
if ((type == FRD_REPLACE || type == FRD_REPLACEALL) && text_locked())
return FALSE;
busy = TRUE;
ga_init2(&ga, 1, 100);
if (type == FRD_REPLACEALL)
ga_concat(&ga, (char_u *)"%s/");
ga_concat(&ga, (char_u *)"\\V");
if (flags & FRD_MATCH_CASE)
ga_concat(&ga, (char_u *)"\\C");
else
ga_concat(&ga, (char_u *)"\\c");
if (flags & FRD_WHOLE_WORD)
ga_concat(&ga, (char_u *)"\\<");
// escape slash and backslash
p = vim_strsave_escaped(find_text, (char_u *)"/\\");
if (p != NULL)
ga_concat(&ga, p);
vim_free(p);
if (flags & FRD_WHOLE_WORD)
ga_concat(&ga, (char_u *)"\\>");
if (type == FRD_REPLACEALL)
{
ga_concat(&ga, (char_u *)"/");
// Escape slash and backslash.
// Also escape tilde and ampersand if 'magic' is set.
p = vim_strsave_escaped(repl_text,
p_magic ? (char_u *)"/\\~&" : (char_u *)"/\\");
if (p != NULL)
ga_concat(&ga, p);
vim_free(p);
ga_concat(&ga, (char_u *)"/g");
}
ga_append(&ga, NUL);
if (type == FRD_REPLACE)
{
// Do the replacement when the text at the cursor matches. Thus no
// replacement is done if the cursor was moved!
regmatch.regprog = vim_regcomp(ga.ga_data, RE_MAGIC + RE_STRING);
regmatch.rm_ic = 0;
if (regmatch.regprog != NULL)
{
p = ml_get_cursor();
if (vim_regexec_nl(&regmatch, p, (colnr_T)0)
&& regmatch.startp[0] == p)
{
// Clear the command line to remove any old "No match"
// error.
msg_end_prompt();
if (u_save_cursor() == OK)
{
// A button was pressed thus undo should be synced.
u_sync(FALSE);
del_bytes((long)(regmatch.endp[0] - regmatch.startp[0]),
FALSE, FALSE);
ins_str(repl_text);
}
}
else
msg(_("No match at cursor, finding next"));
vim_regfree(regmatch.regprog);
}
}
if (type == FRD_REPLACEALL)
{
// A button was pressed, thus undo should be synced.
u_sync(FALSE);
do_cmdline_cmd(ga.ga_data);
}
else
{
int searchflags = SEARCH_MSG + SEARCH_MARK;
// Search for the next match.
// Don't skip text under cursor for single replace.
if (type == FRD_REPLACE)
searchflags += SEARCH_START;
i = msg_scroll;
if (down)
{
(void)do_search(NULL, '/', '/', ga.ga_data, STRLEN(ga.ga_data), 1L, searchflags, NULL);
}
else
{
// We need to escape '?' if and only if we are searching in the up
// direction
p = vim_strsave_escaped(ga.ga_data, (char_u *)"?");
if (p != NULL)
(void)do_search(NULL, '?', '?', p, STRLEN(p), 1L, searchflags, NULL);
vim_free(p);
}
msg_scroll = i; // don't let an error message set msg_scroll
}
// Don't want to pass did_emsg to other code, it may cause disabling
// syntax HL if we were busy redrawing.
did_emsg = save_did_emsg;
if (State & (MODE_NORMAL | MODE_INSERT))
{
gui_update_screen(); // update the screen
msg_didout = 0; // overwrite any message
need_wait_return = FALSE; // don't wait for return
}
vim_free(ga.ga_data);
busy = FALSE;
return (ga.ga_len > 0);
}
#endif
#if defined(HAVE_DROP_FILE) || defined(PROTO)
/*
* Jump to the window at specified point (x, y).
*/
static void
gui_wingoto_xy(int x, int y)
{
int row = Y_2_ROW(y);
int col = X_2_COL(x);
win_T *wp;
if (row < 0 || col < 0)
return;
wp = mouse_find_win(&row, &col, FAIL_POPUP);
if (wp != NULL && wp != curwin)
win_goto(wp);
}
/*
* Function passed to handle_drop() for the actions to be done after the
* argument list has been updated.
*/
static void
drop_callback(void *cookie)
{
char_u *p = cookie;
int do_shorten = FALSE;
// If Shift held down, change to first file's directory. If the first
// item is a directory, change to that directory (and let the explorer
// plugin show the contents).
if (p != NULL)
{
if (mch_isdir(p))
{
if (mch_chdir((char *)p) == 0)
do_shorten = TRUE;
}
else if (vim_chdirfile(p, "drop") == OK)
do_shorten = TRUE;
vim_free(p);
if (do_shorten)
{
shorten_fnames(TRUE);
last_chdir_reason = "drop";
}
}
// Update the screen display
update_screen(UPD_NOT_VALID);
# ifdef FEAT_MENU
gui_update_menus(0);
# endif
maketitle();
setcursor();
out_flush_cursor(FALSE, FALSE);
}
/*
* Process file drop. Mouse cursor position, key modifiers, name of files
* and count of files are given. Argument "fnames[count]" has full pathnames
* of dropped files, they will be freed in this function, and caller can't use
* fnames after call this function.
*/
void
gui_handle_drop(
int x UNUSED,
int y UNUSED,
int_u modifiers,
char_u **fnames,
int count)
{
int i;
char_u *p;
static int entered = FALSE;
/*
* This function is called by event handlers. Just in case we get a
* second event before the first one is handled, ignore the second one.
* Not sure if this can ever happen, just in case.
*/
if (entered)
return;
entered = TRUE;
/*
* When the cursor is at the command line, add the file names to the
* command line, don't edit the files.
*/
if (State & MODE_CMDLINE)
{
shorten_filenames(fnames, count);
for (i = 0; i < count; ++i)
{
if (fnames[i] != NULL)
{
if (i > 0)
add_to_input_buf((char_u*)" ", 1);
// We don't know what command is used thus we can't be sure
// about which characters need to be escaped. Only escape the
// most common ones.
# ifdef BACKSLASH_IN_FILENAME
p = vim_strsave_escaped(fnames[i], (char_u *)" \t\"|");
# else
p = vim_strsave_escaped(fnames[i], (char_u *)"\\ \t\"|");
# endif
if (p != NULL)
add_to_input_buf_csi(p, (int)STRLEN(p));
vim_free(p);
vim_free(fnames[i]);
}
}
vim_free(fnames);
}
else
{
// Go to the window under mouse cursor, then shorten given "fnames" by
// current window, because a window can have local current dir.
gui_wingoto_xy(x, y);
shorten_filenames(fnames, count);
// If Shift held down, remember the first item.
if ((modifiers & MOUSE_SHIFT) != 0)
p = vim_strsave(fnames[0]);
else
p = NULL;
// Handle the drop, :edit or :split to get to the file. This also
// frees fnames[]. Skip this if there is only one item, it's a
// directory and Shift is held down.
if (count == 1 && (modifiers & MOUSE_SHIFT) != 0
&& mch_isdir(fnames[0]))
{
vim_free(fnames[0]);
vim_free(fnames);
vim_free(p);
}
else
handle_drop(count, fnames, (modifiers & MOUSE_CTRL) != 0,
drop_callback, (void *)p);
}
entered = FALSE;
}
#endif
/*
* Check if "key" is to interrupt us. Handles a key that has not had modifiers
* applied yet.
* Return the key with modifiers applied if so, NUL if not.
*/
int
check_for_interrupt(int key, int modifiers_arg)
{
int modifiers = modifiers_arg;
int c = merge_modifyOtherKeys(key, &modifiers);
if ((c == Ctrl_C && ctrl_c_interrupts)
#ifdef UNIX
|| (intr_char != Ctrl_C && c == intr_char)
#endif
)
{
got_int = TRUE;
return c;
}
return NUL;
}
/*
* If the "--gui-log-file fname" argument is given write the dialog title and
* message to a file and return TRUE. Otherwise return FALSE.
* When there is any problem opening the file or writing to the file this is
* ignored, showing the dialog might get the test to get stuck.
*/
int
gui_dialog_log(char_u *title, char_u *message)
{
char_u *fname = get_gui_dialog_file();
FILE *fd;
if (fname == NULL)
return FALSE;
fd = mch_fopen((char *)fname, "a");
if (fd != NULL)
{
fprintf(fd, "%s: %s\n", title, message);
fclose(fd);
}
return TRUE;
}
Reference in a new issue View git blame Copy permalink