blob: f774750f2b89de28b7626fcf5668795df85af9af [file] [log] [blame]
Bram Moolenaaredf3f972016-08-29 22:49:24 +02001/* vi:set ts=8 sts=4 sw=4 noet:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 * GUI/Motif support by Robert Webb
5 *
6 * Do ":help uganda" in Vim to read copying and usage conditions.
7 * Do ":help credits" in Vim to see a list of people who contributed.
8 * See README.txt for an overview of the Vim source code.
9 */
10
11#include "vim.h"
12
13/* Structure containing all the GUI information */
14gui_T gui;
15
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +020016#if defined(FEAT_MBYTE) && !defined(FEAT_GUI_GTK)
Bram Moolenaard25c16e2016-01-29 22:13:30 +010017static void set_guifontwide(char_u *font_name);
Bram Moolenaar071d4272004-06-13 20:20:40 +000018#endif
Bram Moolenaard25c16e2016-01-29 22:13:30 +010019static void gui_check_pos(void);
20static void gui_position_components(int);
21static void gui_outstr(char_u *, int);
22static int gui_screenchar(int off, int flags, guicolor_T fg, guicolor_T bg, int back);
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +020023#ifdef FEAT_GUI_GTK
Bram Moolenaard25c16e2016-01-29 22:13:30 +010024static int gui_screenstr(int off, int len, int flags, guicolor_T fg, guicolor_T bg, int back);
Bram Moolenaar071d4272004-06-13 20:20:40 +000025#endif
Bram Moolenaard25c16e2016-01-29 22:13:30 +010026static void gui_delete_lines(int row, int count);
27static void gui_insert_lines(int row, int count);
28static void fill_mouse_coord(char_u *p, int col, int row);
Bram Moolenaar32466aa2006-02-24 23:53:04 +000029#if defined(FEAT_GUI_TABLINE) || defined(PROTO)
Bram Moolenaard25c16e2016-01-29 22:13:30 +010030static int gui_has_tabline(void);
Bram Moolenaar32466aa2006-02-24 23:53:04 +000031#endif
Bram Moolenaard25c16e2016-01-29 22:13:30 +010032static void gui_do_scrollbar(win_T *wp, int which, int enable);
33static colnr_T scroll_line_len(linenr_T lnum);
34static linenr_T gui_find_longest_lnum(void);
35static void gui_update_horiz_scrollbar(int);
36static void gui_set_fg_color(char_u *name);
37static void gui_set_bg_color(char_u *name);
38static win_T *xy2win(int x, int y);
Bram Moolenaar071d4272004-06-13 20:20:40 +000039
Bram Moolenaar05514102012-08-29 16:34:27 +020040#if defined(UNIX) && !defined(MACOS_X) && !defined(__APPLE__)
Bram Moolenaar7f78bd72011-09-14 19:04:39 +020041# define MAY_FORK
Bram Moolenaard25c16e2016-01-29 22:13:30 +010042static void gui_do_fork(void);
Bram Moolenaar7f78bd72011-09-14 19:04:39 +020043
Bram Moolenaard25c16e2016-01-29 22:13:30 +010044static int gui_read_child_pipe(int fd);
Bram Moolenaar7f78bd72011-09-14 19:04:39 +020045
46/* Return values for gui_read_child_pipe */
47enum {
48 GUI_CHILD_IO_ERROR,
49 GUI_CHILD_OK,
50 GUI_CHILD_FAILED
51};
52
53#endif /* MAY_FORK */
54
Bram Moolenaard25c16e2016-01-29 22:13:30 +010055static void gui_attempt_start(void);
Bram Moolenaar7f78bd72011-09-14 19:04:39 +020056
Bram Moolenaar071d4272004-06-13 20:20:40 +000057static int can_update_cursor = TRUE; /* can display the cursor */
58
59/*
60 * The Athena scrollbars can move the thumb to after the end of the scrollbar,
61 * this makes the thumb indicate the part of the text that is shown. Motif
62 * can't do this.
63 */
64#if defined(FEAT_GUI_ATHENA) || defined(FEAT_GUI_MAC)
65# define SCROLL_PAST_END
66#endif
67
68/*
69 * gui_start -- Called when user wants to start the GUI.
70 *
71 * Careful: This function can be called recursively when there is a ":gui"
72 * command in the .gvimrc file. Only the first call should fork, not the
73 * recursive call.
74 */
75 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +010076gui_start(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +000077{
78 char_u *old_term;
Bram Moolenaar071d4272004-06-13 20:20:40 +000079 static int recursive = 0;
80
81 old_term = vim_strsave(T_NAME);
82
Bram Moolenaar071d4272004-06-13 20:20:40 +000083 settmode(TMODE_COOK); /* stop RAW mode */
84 if (full_screen)
85 cursor_on(); /* needed for ":gui" in .vimrc */
Bram Moolenaar071d4272004-06-13 20:20:40 +000086 full_screen = FALSE;
87
Bram Moolenaar071d4272004-06-13 20:20:40 +000088 ++recursive;
89
Bram Moolenaar7f78bd72011-09-14 19:04:39 +020090#ifdef MAY_FORK
91 /*
92 * Quit the current process and continue in the child.
93 * Makes "gvim file" disconnect from the shell it was started in.
94 * Don't do this when Vim was started with "-f" or the 'f' flag is present
95 * in 'guioptions'.
96 */
97 if (gui.dofork && !vim_strchr(p_go, GO_FORG) && recursive <= 1)
98 {
99 gui_do_fork();
100 }
101 else
102#endif
103 {
Bram Moolenaarae084bb2012-05-27 00:37:51 +0200104#ifdef FEAT_GUI_GTK
Bram Moolenaar6a3c1b42012-05-25 14:06:36 +0200105 /* If there is 'f' in 'guioptions' and specify -g argument,
106 * gui_mch_init_check() was not called yet. */
107 if (gui_mch_init_check() != OK)
Bram Moolenaar6d8d8492016-03-19 14:48:31 +0100108 getout_preserve_modified(1);
Bram Moolenaarae084bb2012-05-27 00:37:51 +0200109#endif
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200110 gui_attempt_start();
111 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000112
113 if (!gui.in_use) /* failed to start GUI */
114 {
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200115 /* Back to old term settings
116 *
117 * FIXME: If we got here because a child process failed and flagged to
118 * the parent to resume, and X11 is enabled with FEAT_TITLE, this will
119 * hit an X11 I/O error and do a longjmp(), leaving recursive
120 * permanently set to 1. This is probably not as big a problem as it
121 * sounds, because gui_mch_init() in both gui_x11.c and gui_gtk_x11.c
122 * return "OK" unconditionally, so it would be very difficult to
123 * actually hit this case.
124 */
125 termcapinit(old_term);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000126 settmode(TMODE_RAW); /* restart RAW mode */
127#ifdef FEAT_TITLE
128 set_title_defaults(); /* set 'title' and 'icon' again */
129#endif
130 }
131
132 vim_free(old_term);
133
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200134#ifdef FEAT_AUTOCMD
135 /* If the GUI started successfully, trigger the GUIEnter event, otherwise
136 * the GUIFailed event. */
137 gui_mch_update();
138 apply_autocmds(gui.in_use ? EVENT_GUIENTER : EVENT_GUIFAILED,
139 NULL, NULL, FALSE, curbuf);
140#endif
141 --recursive;
142}
143
144/*
145 * Set_termname() will call gui_init() to start the GUI.
146 * Set the "starting" flag, to indicate that the GUI will start.
147 *
148 * We don't want to open the GUI shell until after we've read .gvimrc,
149 * otherwise we don't know what font we will use, and hence we don't know
150 * what size the shell should be. So if there are errors in the .gvimrc
151 * file, they will have to go to the terminal: Set full_screen to FALSE.
152 * full_screen will be set to TRUE again by a successful termcapinit().
153 */
154 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +0100155gui_attempt_start(void)
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200156{
157 static int recursive = 0;
158
159 ++recursive;
160 gui.starting = TRUE;
161
162#ifdef FEAT_GUI_GTK
163 gui.event_time = GDK_CURRENT_TIME;
164#endif
165
166 termcapinit((char_u *)"builtin_gui");
167 gui.starting = recursive - 1;
168
Bram Moolenaar9372a112005-12-06 19:59:18 +0000169#if defined(FEAT_GUI_GTK) || defined(FEAT_GUI_X11)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000170 if (gui.in_use)
Bram Moolenaar727c8762010-10-20 19:17:48 +0200171 {
172# ifdef FEAT_EVAL
173 Window x11_window;
174 Display *x11_display;
175
176 if (gui_get_x11_windis(&x11_window, &x11_display) == OK)
177 set_vim_var_nr(VV_WINDOWID, (long)x11_window);
178# endif
179
Bram Moolenaar071d4272004-06-13 20:20:40 +0000180 /* Display error messages in a dialog now. */
181 display_errors();
Bram Moolenaar727c8762010-10-20 19:17:48 +0200182 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000183#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000184 --recursive;
185}
186
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200187#ifdef MAY_FORK
188
189/* for waitpid() */
190# if defined(HAVE_SYS_WAIT_H) || defined(HAVE_UNION_WAIT)
191# include <sys/wait.h>
192# endif
193
194/*
195 * Create a new process, by forking. In the child, start the GUI, and in
196 * the parent, exit.
197 *
198 * If something goes wrong, this will return with gui.in_use still set
199 * to FALSE, in which case the caller should continue execution without
200 * the GUI.
201 *
202 * If the child fails to start the GUI, then the child will exit and the
203 * parent will return. If the child succeeds, then the parent will exit
204 * and the child will return.
205 */
206 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +0100207gui_do_fork(void)
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200208{
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200209 int pipefd[2]; /* pipe between parent and child */
210 int pipe_error;
211 int status;
212 int exit_status;
213 pid_t pid = -1;
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200214
215 /* Setup a pipe between the child and the parent, so that the parent
216 * knows when the child has done the setsid() call and is allowed to
217 * exit. */
218 pipe_error = (pipe(pipefd) < 0);
219 pid = fork();
220 if (pid < 0) /* Fork error */
221 {
222 EMSG(_("E851: Failed to create a new process for the GUI"));
223 return;
224 }
225 else if (pid > 0) /* Parent */
226 {
227 /* Give the child some time to do the setsid(), otherwise the
228 * exit() may kill the child too (when starting gvim from inside a
229 * gvim). */
230 if (!pipe_error)
231 {
232 /* The read returns when the child closes the pipe (or when
233 * the child dies for some reason). */
234 close(pipefd[1]);
235 status = gui_read_child_pipe(pipefd[0]);
236 if (status == GUI_CHILD_FAILED)
237 {
238 /* The child failed to start the GUI, so the caller must
239 * continue. There may be more error information written
240 * to stderr by the child. */
241# ifdef __NeXT__
242 wait4(pid, &exit_status, 0, (struct rusage *)0);
243# else
244 waitpid(pid, &exit_status, 0);
245# endif
246 EMSG(_("E852: The child process failed to start the GUI"));
247 return;
248 }
249 else if (status == GUI_CHILD_IO_ERROR)
250 {
251 pipe_error = TRUE;
252 }
253 /* else GUI_CHILD_OK: parent exit */
254 }
255
256 if (pipe_error)
257 ui_delay(300L, TRUE);
258
259 /* When swapping screens we may need to go to the next line, e.g.,
260 * after a hit-enter prompt and using ":gui". */
261 if (newline_on_exit)
262 mch_errmsg("\r\n");
263
264 /*
265 * The parent must skip the normal exit() processing, the child
266 * will do it. For example, GTK messes up signals when exiting.
267 */
268 _exit(0);
269 }
270 /* Child */
271
Bram Moolenaar29695702012-05-18 17:03:18 +0200272#ifdef FEAT_GUI_GTK
273 /* Call gtk_init_check() here after fork(). See gui_init_check(). */
274 if (gui_mch_init_check() != OK)
Bram Moolenaar6d8d8492016-03-19 14:48:31 +0100275 getout_preserve_modified(1);
Bram Moolenaar29695702012-05-18 17:03:18 +0200276#endif
277
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200278# if defined(HAVE_SETSID) || defined(HAVE_SETPGID)
279 /*
280 * Change our process group. On some systems/shells a CTRL-C in the
281 * shell where Vim was started would otherwise kill gvim!
282 */
283# if defined(HAVE_SETSID)
284 (void)setsid();
285# else
286 (void)setpgid(0, 0);
287# endif
288# endif
289 if (!pipe_error)
290 close(pipefd[0]);
291
292# if defined(FEAT_GUI_GNOME) && defined(FEAT_SESSION)
293 /* Tell the session manager our new PID */
294 gui_mch_forked();
295# endif
296
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200297 /* Try to start the GUI */
298 gui_attempt_start();
299
300 /* Notify the parent */
Bram Moolenaarcd6fe972011-10-20 21:28:01 +0200301 if (!pipe_error)
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200302 {
Bram Moolenaarcd6fe972011-10-20 21:28:01 +0200303 if (gui.in_use)
304 write_eintr(pipefd[1], "ok", 3);
305 else
306 write_eintr(pipefd[1], "fail", 5);
307 close(pipefd[1]);
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200308 }
309
310 /* If we failed to start the GUI, exit now. */
311 if (!gui.in_use)
Bram Moolenaar6d8d8492016-03-19 14:48:31 +0100312 getout_preserve_modified(1);
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200313}
314
315/*
316 * Read from a pipe assumed to be connected to the child process (this
317 * function is called from the parent).
318 * Return GUI_CHILD_OK if the child successfully started the GUI,
319 * GUY_CHILD_FAILED if the child failed, or GUI_CHILD_IO_ERROR if there was
320 * some other error.
321 *
322 * The file descriptor will be closed before the function returns.
323 */
324 static int
325gui_read_child_pipe(int fd)
326{
Bram Moolenaarcd6fe972011-10-20 21:28:01 +0200327 long bytes_read;
328#define READ_BUFFER_SIZE 10
329 char buffer[READ_BUFFER_SIZE];
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200330
Bram Moolenaarcd6fe972011-10-20 21:28:01 +0200331 bytes_read = read_eintr(fd, buffer, READ_BUFFER_SIZE - 1);
332#undef READ_BUFFER_SIZE
333 close(fd);
334 if (bytes_read < 0)
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200335 return GUI_CHILD_IO_ERROR;
Bram Moolenaarcd6fe972011-10-20 21:28:01 +0200336 buffer[bytes_read] = NUL;
Bram Moolenaar7f78bd72011-09-14 19:04:39 +0200337 if (strcmp(buffer, "ok") == 0)
338 return GUI_CHILD_OK;
339 return GUI_CHILD_FAILED;
340}
341
342#endif /* MAY_FORK */
343
Bram Moolenaar071d4272004-06-13 20:20:40 +0000344/*
345 * Call this when vim starts up, whether or not the GUI is started
346 */
347 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +0100348gui_prepare(int *argc, char **argv)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000349{
350 gui.in_use = FALSE; /* No GUI yet (maybe later) */
351 gui.starting = FALSE; /* No GUI yet (maybe later) */
352 gui_mch_prepare(argc, argv);
353}
354
355/*
356 * Try initializing the GUI and check if it can be started.
357 * Used from main() to check early if "vim -g" can start the GUI.
358 * Used from gui_init() to prepare for starting the GUI.
359 * Returns FAIL or OK.
360 */
361 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +0100362gui_init_check(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000363{
364 static int result = MAYBE;
365
366 if (result != MAYBE)
367 {
368 if (result == FAIL)
369 EMSG(_("E229: Cannot start the GUI"));
370 return result;
371 }
372
373 gui.shell_created = FALSE;
374 gui.dying = FALSE;
375 gui.in_focus = TRUE; /* so the guicursor setting works */
376 gui.dragged_sb = SBAR_NONE;
377 gui.dragged_wp = NULL;
378 gui.pointer_hidden = FALSE;
379 gui.col = 0;
380 gui.row = 0;
381 gui.num_cols = Columns;
382 gui.num_rows = Rows;
383
384 gui.cursor_is_valid = FALSE;
385 gui.scroll_region_top = 0;
386 gui.scroll_region_bot = Rows - 1;
387 gui.scroll_region_left = 0;
388 gui.scroll_region_right = Columns - 1;
389 gui.highlight_mask = HL_NORMAL;
390 gui.char_width = 1;
391 gui.char_height = 1;
392 gui.char_ascent = 0;
393 gui.border_width = 0;
394
395 gui.norm_font = NOFONT;
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +0200396#ifndef FEAT_GUI_GTK
Bram Moolenaar071d4272004-06-13 20:20:40 +0000397 gui.bold_font = NOFONT;
398 gui.ital_font = NOFONT;
399 gui.boldital_font = NOFONT;
400# ifdef FEAT_XFONTSET
401 gui.fontset = NOFONTSET;
402# endif
403#endif
Bram Moolenaardb250522013-06-17 22:43:25 +0200404#ifdef FEAT_MBYTE
405 gui.wide_font = NOFONT;
406# ifndef FEAT_GUI_GTK
407 gui.wide_bold_font = NOFONT;
408 gui.wide_ital_font = NOFONT;
409 gui.wide_boldital_font = NOFONT;
410# endif
411#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000412
413#ifdef FEAT_MENU
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +0200414# ifndef FEAT_GUI_GTK
Bram Moolenaar071d4272004-06-13 20:20:40 +0000415# ifdef FONTSET_ALWAYS
416 gui.menu_fontset = NOFONTSET;
417# else
418 gui.menu_font = NOFONT;
419# endif
420# endif
421 gui.menu_is_active = TRUE; /* default: include menu */
422# ifndef FEAT_GUI_GTK
423 gui.menu_height = MENU_DEFAULT_HEIGHT;
424 gui.menu_width = 0;
425# endif
426#endif
427#if defined(FEAT_TOOLBAR) && (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA))
428 gui.toolbar_height = 0;
429#endif
430#if defined(FEAT_FOOTER) && defined(FEAT_GUI_MOTIF)
431 gui.footer_height = 0;
432#endif
433#ifdef FEAT_BEVAL_TIP
434 gui.tooltip_fontset = NOFONTSET;
435#endif
436
437 gui.scrollbar_width = gui.scrollbar_height = SB_DEFAULT_WIDTH;
438 gui.prev_wrap = -1;
439
440#ifdef ALWAYS_USE_GUI
441 result = OK;
442#else
Bram Moolenaar29695702012-05-18 17:03:18 +0200443# ifdef FEAT_GUI_GTK
444 /*
445 * Note: Don't call gtk_init_check() before fork, it will be called after
446 * the fork. When calling it before fork, it make vim hang for a while.
447 * See gui_do_fork().
448 * Use a simpler check if the GUI window can probably be opened.
449 */
Bram Moolenaar717e1962016-08-10 21:28:44 +0200450 result = gui.dofork ? gui_mch_early_init_check(TRUE) : gui_mch_init_check();
Bram Moolenaar29695702012-05-18 17:03:18 +0200451# else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000452 result = gui_mch_init_check();
Bram Moolenaar29695702012-05-18 17:03:18 +0200453# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000454#endif
455 return result;
456}
457
458/*
459 * This is the call which starts the GUI.
460 */
461 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +0100462gui_init(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000463{
464 win_T *wp;
465 static int recursive = 0;
466
467 /*
468 * It's possible to use ":gui" in a .gvimrc file. The first halve of this
469 * function will then be executed at the first call, the rest by the
470 * recursive call. This allow the shell to be opened halfway reading a
471 * gvimrc file.
472 */
473 if (!recursive)
474 {
475 ++recursive;
476
477 clip_init(TRUE);
478
479 /* If can't initialize, don't try doing the rest */
480 if (gui_init_check() == FAIL)
481 {
482 --recursive;
483 clip_init(FALSE);
484 return;
485 }
486
487 /*
Bram Moolenaarb23c3382005-01-31 19:09:12 +0000488 * Reset 'paste'. It's useful in the terminal, but not in the GUI. It
489 * breaks the Paste toolbar button.
490 */
491 set_option_value((char_u *)"paste", 0L, NULL, 0);
492
493 /*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000494 * Set up system-wide default menus.
495 */
496#if defined(SYS_MENU_FILE) && defined(FEAT_MENU)
497 if (vim_strchr(p_go, GO_NOSYSMENU) == NULL)
498 {
499 sys_menu = TRUE;
Bram Moolenaar910f66f2006-04-05 20:41:53 +0000500 do_source((char_u *)SYS_MENU_FILE, FALSE, DOSO_NONE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000501 sys_menu = FALSE;
502 }
503#endif
504
505 /*
506 * Switch on the mouse by default, unless the user changed it already.
507 * This can then be changed in the .gvimrc.
508 */
509 if (!option_was_set((char_u *)"mouse"))
510 set_string_option_direct((char_u *)"mouse", -1,
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +0000511 (char_u *)"a", OPT_FREE, SID_NONE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000512
513 /*
514 * If -U option given, use only the initializations from that file and
515 * nothing else. Skip all initializations for "-U NONE" or "-u NORC".
516 */
517 if (use_gvimrc != NULL)
518 {
519 if (STRCMP(use_gvimrc, "NONE") != 0
520 && STRCMP(use_gvimrc, "NORC") != 0
Bram Moolenaar910f66f2006-04-05 20:41:53 +0000521 && do_source(use_gvimrc, FALSE, DOSO_NONE) != OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000522 EMSG2(_("E230: Cannot read from \"%s\""), use_gvimrc);
523 }
524 else
525 {
526 /*
527 * Get system wide defaults for gvim, only when file name defined.
528 */
529#ifdef SYS_GVIMRC_FILE
Bram Moolenaar910f66f2006-04-05 20:41:53 +0000530 do_source((char_u *)SYS_GVIMRC_FILE, FALSE, DOSO_NONE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000531#endif
532
533 /*
534 * Try to read GUI initialization commands from the following
535 * places:
536 * - environment variable GVIMINIT
537 * - the user gvimrc file (~/.gvimrc)
538 * - the second user gvimrc file ($VIM/.gvimrc for Dos)
539 * - the third user gvimrc file ($VIM/.gvimrc for Amiga)
540 * The first that exists is used, the rest is ignored.
541 */
542 if (process_env((char_u *)"GVIMINIT", FALSE) == FAIL
Bram Moolenaar910f66f2006-04-05 20:41:53 +0000543 && do_source((char_u *)USR_GVIMRC_FILE, TRUE,
544 DOSO_GVIMRC) == FAIL
Bram Moolenaar071d4272004-06-13 20:20:40 +0000545#ifdef USR_GVIMRC_FILE2
Bram Moolenaar910f66f2006-04-05 20:41:53 +0000546 && do_source((char_u *)USR_GVIMRC_FILE2, TRUE,
547 DOSO_GVIMRC) == FAIL
Bram Moolenaar071d4272004-06-13 20:20:40 +0000548#endif
Bram Moolenaar22971aa2013-06-12 20:35:58 +0200549#ifdef USR_GVIMRC_FILE3
550 && do_source((char_u *)USR_GVIMRC_FILE3, TRUE,
551 DOSO_GVIMRC) == FAIL
552#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000553 )
554 {
Bram Moolenaar22971aa2013-06-12 20:35:58 +0200555#ifdef USR_GVIMRC_FILE4
556 (void)do_source((char_u *)USR_GVIMRC_FILE4, TRUE, DOSO_GVIMRC);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000557#endif
558 }
559
560 /*
561 * Read initialization commands from ".gvimrc" in current
562 * directory. This is only done if the 'exrc' option is set.
563 * Because of security reasons we disallow shell and write
564 * commands now, except for unix if the file is owned by the user
565 * or 'secure' option has been reset in environment of global
566 * ".gvimrc".
567 * Only do this if GVIMRC_FILE is not the same as USR_GVIMRC_FILE,
568 * USR_GVIMRC_FILE2, USR_GVIMRC_FILE3 or SYS_GVIMRC_FILE.
569 */
570 if (p_exrc)
571 {
572#ifdef UNIX
573 {
Bram Moolenaar8767f522016-07-01 17:17:39 +0200574 stat_T s;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000575
576 /* if ".gvimrc" file is not owned by user, set 'secure'
577 * mode */
578 if (mch_stat(GVIMRC_FILE, &s) || s.st_uid != getuid())
579 secure = p_secure;
580 }
581#else
582 secure = p_secure;
583#endif
584
585 if ( fullpathcmp((char_u *)USR_GVIMRC_FILE,
586 (char_u *)GVIMRC_FILE, FALSE) != FPC_SAME
587#ifdef SYS_GVIMRC_FILE
588 && fullpathcmp((char_u *)SYS_GVIMRC_FILE,
589 (char_u *)GVIMRC_FILE, FALSE) != FPC_SAME
590#endif
591#ifdef USR_GVIMRC_FILE2
592 && fullpathcmp((char_u *)USR_GVIMRC_FILE2,
593 (char_u *)GVIMRC_FILE, FALSE) != FPC_SAME
594#endif
595#ifdef USR_GVIMRC_FILE3
596 && fullpathcmp((char_u *)USR_GVIMRC_FILE3,
597 (char_u *)GVIMRC_FILE, FALSE) != FPC_SAME
598#endif
Bram Moolenaar22971aa2013-06-12 20:35:58 +0200599#ifdef USR_GVIMRC_FILE4
600 && fullpathcmp((char_u *)USR_GVIMRC_FILE4,
601 (char_u *)GVIMRC_FILE, FALSE) != FPC_SAME
602#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000603 )
Bram Moolenaar910f66f2006-04-05 20:41:53 +0000604 do_source((char_u *)GVIMRC_FILE, TRUE, DOSO_GVIMRC);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000605
606 if (secure == 2)
607 need_wait_return = TRUE;
608 secure = 0;
609 }
610 }
611
612 if (need_wait_return || msg_didany)
613 wait_return(TRUE);
614
615 --recursive;
616 }
617
618 /* If recursive call opened the shell, return here from the first call */
619 if (gui.in_use)
620 return;
621
622 /*
623 * Create the GUI shell.
624 */
625 gui.in_use = TRUE; /* Must be set after menus have been set up */
626 if (gui_mch_init() == FAIL)
627 goto error;
628
629 /* Avoid a delay for an error message that was printed in the terminal
630 * where Vim was started. */
631 emsg_on_display = FALSE;
632 msg_scrolled = 0;
Bram Moolenaarf2405ed2017-03-16 19:58:25 +0100633 clear_sb_text(TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000634 need_wait_return = FALSE;
635 msg_didany = FALSE;
636
637 /*
638 * Check validity of any generic resources that may have been loaded.
639 */
640 if (gui.border_width < 0)
641 gui.border_width = 0;
642
643 /*
644 * Set up the fonts. First use a font specified with "-fn" or "-font".
645 */
646 if (font_argument != NULL)
647 set_option_value((char_u *)"gfn", 0L, (char_u *)font_argument, 0);
648 if (
649#ifdef FEAT_XFONTSET
650 (*p_guifontset == NUL
651 || gui_init_font(p_guifontset, TRUE) == FAIL) &&
652#endif
653 gui_init_font(*p_guifont == NUL ? hl_get_font_name()
654 : p_guifont, FALSE) == FAIL)
655 {
656 EMSG(_("E665: Cannot start GUI, no valid font found"));
657 goto error2;
658 }
659#ifdef FEAT_MBYTE
660 if (gui_get_wide_font() == FAIL)
661 EMSG(_("E231: 'guifontwide' invalid"));
662#endif
663
664 gui.num_cols = Columns;
665 gui.num_rows = Rows;
666 gui_reset_scroll_region();
667
668 /* Create initial scrollbars */
669 FOR_ALL_WINDOWS(wp)
670 {
671 gui_create_scrollbar(&wp->w_scrollbars[SBAR_LEFT], SBAR_LEFT, wp);
672 gui_create_scrollbar(&wp->w_scrollbars[SBAR_RIGHT], SBAR_RIGHT, wp);
673 }
674 gui_create_scrollbar(&gui.bottom_sbar, SBAR_BOTTOM, NULL);
675
676#ifdef FEAT_MENU
677 gui_create_initial_menus(root_menu);
678#endif
679#ifdef FEAT_SUN_WORKSHOP
680 if (usingSunWorkShop)
681 workshop_init();
682#endif
683#ifdef FEAT_SIGN_ICONS
684 sign_gui_started();
685#endif
686
687 /* Configure the desired menu and scrollbars */
688 gui_init_which_components(NULL);
689
690 /* All components of the GUI have been created now */
691 gui.shell_created = TRUE;
692
693#ifndef FEAT_GUI_GTK
694 /* Set the shell size, adjusted for the screen size. For GTK this only
695 * works after the shell has been opened, thus it is further down. */
Bram Moolenaar2e2a2812006-03-27 20:55:21 +0000696 gui_set_shellsize(FALSE, TRUE, RESIZE_BOTH);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000697#endif
698#if defined(FEAT_GUI_MOTIF) && defined(FEAT_MENU)
699 /* Need to set the size of the menubar after all the menus have been
700 * created. */
701 gui_mch_compute_menu_height((Widget)0);
702#endif
703
704 /*
705 * Actually open the GUI shell.
706 */
707 if (gui_mch_open() != FAIL)
708 {
709#ifdef FEAT_TITLE
710 maketitle();
711 resettitle();
712#endif
713 init_gui_options();
714#ifdef FEAT_ARABIC
715 /* Our GUI can't do bidi. */
716 p_tbidi = FALSE;
717#endif
Bram Moolenaar9372a112005-12-06 19:59:18 +0000718#if defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000719 /* Give GTK+ a chance to put all widget's into place. */
720 gui_mch_update();
Bram Moolenaar18144c82006-04-12 21:52:12 +0000721
722# ifdef FEAT_MENU
723 /* If there is no 'm' in 'guioptions' we need to remove the menu now.
724 * It was still there to make F10 work. */
725 if (vim_strchr(p_go, GO_MENUS) == NULL)
726 {
727 --gui.starting;
728 gui_mch_enable_menu(FALSE);
729 ++gui.starting;
730 gui_mch_update();
731 }
732# endif
733
Bram Moolenaar071d4272004-06-13 20:20:40 +0000734 /* Now make sure the shell fits on the screen. */
Bram Moolenaar2e2a2812006-03-27 20:55:21 +0000735 gui_set_shellsize(FALSE, TRUE, RESIZE_BOTH);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000736#endif
Bram Moolenaar41bfd302005-04-24 21:59:46 +0000737 /* When 'lines' was set while starting up the topframe may have to be
738 * resized. */
739 win_new_shellsize();
Bram Moolenaarfd91ecb2005-03-07 23:06:25 +0000740
741#ifdef FEAT_BEVAL
742 /* Always create the Balloon Evaluation area, but disable it when
743 * 'ballooneval' is off */
744# ifdef FEAT_GUI_GTK
745 balloonEval = gui_mch_create_beval_area(gui.drawarea, NULL,
746 &general_beval_cb, NULL);
747# else
Bram Moolenaar4317d9b2005-03-18 20:25:31 +0000748# if defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA)
Bram Moolenaarfd91ecb2005-03-07 23:06:25 +0000749 {
750 extern Widget textArea;
751 balloonEval = gui_mch_create_beval_area(textArea, NULL,
Bram Moolenaar4317d9b2005-03-18 20:25:31 +0000752 &general_beval_cb, NULL);
Bram Moolenaarfd91ecb2005-03-07 23:06:25 +0000753 }
754# else
755# ifdef FEAT_GUI_W32
756 balloonEval = gui_mch_create_beval_area(NULL, NULL,
757 &general_beval_cb, NULL);
758# endif
759# endif
760# endif
761 if (!p_beval)
762 gui_mch_disable_beval_area(balloonEval);
763#endif
764
Bram Moolenaar071d4272004-06-13 20:20:40 +0000765#if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
766 if (!im_xim_isvalid_imactivate())
767 EMSG(_("E599: Value of 'imactivatekey' is invalid"));
768#endif
Bram Moolenaard8b0cf12004-12-12 11:33:30 +0000769 /* When 'cmdheight' was set during startup it may not have taken
770 * effect yet. */
771 if (p_ch != 1L)
Bram Moolenaarc6fe9192006-04-09 21:54:49 +0000772 command_height();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000773
774 return;
775 }
776
777error2:
778#ifdef FEAT_GUI_X11
779 /* undo gui_mch_init() */
780 gui_mch_uninit();
781#endif
782
783error:
784 gui.in_use = FALSE;
785 clip_init(FALSE);
786}
787
788
789 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +0100790gui_exit(int rc)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000791{
Bram Moolenaar071d4272004-06-13 20:20:40 +0000792 /* don't free the fonts, it leads to a BUS error
793 * richard@whitequeen.com Jul 99 */
794 free_highlight_fonts();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000795 gui.in_use = FALSE;
796 gui_mch_exit(rc);
797}
798
Bram Moolenaar9372a112005-12-06 19:59:18 +0000799#if defined(FEAT_GUI_GTK) || defined(FEAT_GUI_X11) || defined(FEAT_GUI_MSWIN) \
Bram Moolenaar071d4272004-06-13 20:20:40 +0000800 || defined(FEAT_GUI_PHOTON) || defined(FEAT_GUI_MAC) || defined(PROTO)
Bram Moolenaarda68cf32006-10-10 15:35:57 +0000801# define NEED_GUI_UPDATE_SCREEN 1
Bram Moolenaar071d4272004-06-13 20:20:40 +0000802/*
803 * Called when the GUI shell is closed by the user. If there are no changed
804 * files Vim exits, otherwise there will be a dialog to ask the user what to
805 * do.
806 * When this function returns, Vim should NOT exit!
807 */
808 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +0100809gui_shell_closed(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000810{
811 cmdmod_T save_cmdmod;
812
813 save_cmdmod = cmdmod;
814
815 /* Only exit when there are no changed files */
816 exiting = TRUE;
817# ifdef FEAT_BROWSE
818 cmdmod.browse = TRUE;
819# endif
820# if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
821 cmdmod.confirm = TRUE;
822# endif
823 /* If there are changed buffers, present the user with a dialog if
824 * possible, otherwise give an error message. */
Bram Moolenaar027387f2016-01-02 22:25:52 +0100825 if (!check_changed_any(FALSE, FALSE))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000826 getout(0);
827
828 exiting = FALSE;
829 cmdmod = save_cmdmod;
Bram Moolenaarda68cf32006-10-10 15:35:57 +0000830 gui_update_screen(); /* redraw, window may show changed buffer */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000831}
832#endif
833
834/*
Bram Moolenaar84a05ac2013-05-06 04:24:17 +0200835 * Set the font. "font_list" is a comma separated list of font names. The
Bram Moolenaar071d4272004-06-13 20:20:40 +0000836 * first font name that works is used. If none is found, use the default
837 * font.
838 * If "fontset" is TRUE, the "font_list" is used as one name for the fontset.
839 * Return OK when able to set the font. When it failed FAIL is returned and
840 * the fonts are unchanged.
841 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000842 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +0100843gui_init_font(char_u *font_list, int fontset UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000844{
845#define FONTLEN 320
846 char_u font_name[FONTLEN];
847 int font_list_empty = FALSE;
848 int ret = FAIL;
849
850 if (!gui.in_use)
851 return FAIL;
852
853 font_name[0] = NUL;
854 if (*font_list == NUL)
855 font_list_empty = TRUE;
856 else
857 {
858#ifdef FEAT_XFONTSET
859 /* When using a fontset, the whole list of fonts is one name. */
860 if (fontset)
861 ret = gui_mch_init_font(font_list, TRUE);
862 else
863#endif
864 while (*font_list != NUL)
865 {
866 /* Isolate one comma separated font name. */
867 (void)copy_option_part(&font_list, font_name, FONTLEN, ",");
868
869 /* Careful!!! The Win32 version of gui_mch_init_font(), when
870 * called with "*" will change p_guifont to the selected font
871 * name, which frees the old value. This makes font_list
872 * invalid. Thus when OK is returned here, font_list must no
873 * longer be used! */
874 if (gui_mch_init_font(font_name, FALSE) == OK)
875 {
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +0200876#if defined(FEAT_MBYTE) && !defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000877 /* If it's a Unicode font, try setting 'guifontwide' to a
878 * similar double-width font. */
879 if ((p_guifontwide == NULL || *p_guifontwide == NUL)
880 && strstr((char *)font_name, "10646") != NULL)
881 set_guifontwide(font_name);
882#endif
883 ret = OK;
884 break;
885 }
886 }
887 }
888
889 if (ret != OK
890 && STRCMP(font_list, "*") != 0
891 && (font_list_empty || gui.norm_font == NOFONT))
892 {
893 /*
894 * Couldn't load any font in 'font_list', keep the current font if
895 * there is one. If 'font_list' is empty, or if there is no current
896 * font, tell gui_mch_init_font() to try to find a font we can load.
897 */
898 ret = gui_mch_init_font(NULL, FALSE);
899 }
900
901 if (ret == OK)
902 {
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +0200903#ifndef FEAT_GUI_GTK
Bram Moolenaar071d4272004-06-13 20:20:40 +0000904 /* Set normal font as current font */
905# ifdef FEAT_XFONTSET
906 if (gui.fontset != NOFONTSET)
907 gui_mch_set_fontset(gui.fontset);
908 else
909# endif
910 gui_mch_set_font(gui.norm_font);
911#endif
Bram Moolenaarb0316262012-11-20 12:03:06 +0100912 gui_set_shellsize(FALSE, TRUE, RESIZE_BOTH);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000913 }
914
915 return ret;
916}
917
918#if defined(FEAT_MBYTE) || defined(PROTO)
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +0200919# ifndef FEAT_GUI_GTK
Bram Moolenaar071d4272004-06-13 20:20:40 +0000920/*
921 * Try setting 'guifontwide' to a font twice as wide as "name".
922 */
923 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +0100924set_guifontwide(char_u *name)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000925{
926 int i = 0;
927 char_u wide_name[FONTLEN + 10]; /* room for 2 * width and '*' */
928 char_u *wp = NULL;
929 char_u *p;
930 GuiFont font;
931
932 wp = wide_name;
933 for (p = name; *p != NUL; ++p)
934 {
935 *wp++ = *p;
936 if (*p == '-')
937 {
938 ++i;
939 if (i == 6) /* font type: change "--" to "-*-" */
940 {
941 if (p[1] == '-')
942 *wp++ = '*';
943 }
944 else if (i == 12) /* found the width */
945 {
946 ++p;
947 i = getdigits(&p);
948 if (i != 0)
949 {
950 /* Double the width specification. */
951 sprintf((char *)wp, "%d%s", i * 2, p);
952 font = gui_mch_get_font(wide_name, FALSE);
953 if (font != NOFONT)
954 {
Bram Moolenaard8b0cf12004-12-12 11:33:30 +0000955 gui_mch_free_font(gui.wide_font);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000956 gui.wide_font = font;
957 set_string_option_direct((char_u *)"gfw", -1,
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +0000958 wide_name, OPT_FREE, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000959 }
960 }
961 break;
962 }
963 }
964 }
965}
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +0200966# endif /* !FEAT_GUI_GTK */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000967
968/*
969 * Get the font for 'guifontwide'.
970 * Return FAIL for an invalid font name.
971 */
972 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +0100973gui_get_wide_font(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000974{
975 GuiFont font = NOFONT;
976 char_u font_name[FONTLEN];
977 char_u *p;
978
979 if (!gui.in_use) /* Can't allocate font yet, assume it's OK. */
980 return OK; /* Will give an error message later. */
981
982 if (p_guifontwide != NULL && *p_guifontwide != NUL)
983 {
984 for (p = p_guifontwide; *p != NUL; )
985 {
986 /* Isolate one comma separated font name. */
987 (void)copy_option_part(&p, font_name, FONTLEN, ",");
988 font = gui_mch_get_font(font_name, FALSE);
989 if (font != NOFONT)
990 break;
991 }
992 if (font == NOFONT)
993 return FAIL;
994 }
995
996 gui_mch_free_font(gui.wide_font);
Bram Moolenaarcdffbea2013-04-03 21:11:39 +0200997# ifdef FEAT_GUI_GTK
Bram Moolenaar071d4272004-06-13 20:20:40 +0000998 /* Avoid unnecessary overhead if 'guifontwide' is equal to 'guifont'. */
999 if (font != NOFONT && gui.norm_font != NOFONT
1000 && pango_font_description_equal(font, gui.norm_font))
1001 {
1002 gui.wide_font = NOFONT;
1003 gui_mch_free_font(font);
1004 }
1005 else
Bram Moolenaarcdffbea2013-04-03 21:11:39 +02001006# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001007 gui.wide_font = font;
Bram Moolenaarcdffbea2013-04-03 21:11:39 +02001008# ifdef FEAT_GUI_MSWIN
Bram Moolenaar0f272122013-01-23 18:37:40 +01001009 gui_mch_wide_font_changed();
Bram Moolenaardb250522013-06-17 22:43:25 +02001010# else
1011 /*
1012 * TODO: setup wide_bold_font, wide_ital_font and wide_boldital_font to
1013 * support those fonts for 'guifontwide'.
1014 */
Bram Moolenaarcdffbea2013-04-03 21:11:39 +02001015# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001016 return OK;
1017}
1018#endif
1019
1020 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001021gui_set_cursor(int row, int col)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001022{
1023 gui.row = row;
1024 gui.col = col;
1025}
1026
1027/*
1028 * gui_check_pos - check if the cursor is on the screen.
1029 */
1030 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001031gui_check_pos(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001032{
1033 if (gui.row >= screen_Rows)
1034 gui.row = screen_Rows - 1;
1035 if (gui.col >= screen_Columns)
1036 gui.col = screen_Columns - 1;
1037 if (gui.cursor_row >= screen_Rows || gui.cursor_col >= screen_Columns)
1038 gui.cursor_is_valid = FALSE;
1039}
1040
1041/*
1042 * Redraw the cursor if necessary or when forced.
1043 * Careful: The contents of ScreenLines[] must match what is on the screen,
1044 * otherwise this goes wrong. May need to call out_flush() first.
1045 */
1046 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001047gui_update_cursor(
1048 int force, /* when TRUE, update even when not moved */
1049 int clear_selection)/* clear selection under cursor */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001050{
1051 int cur_width = 0;
1052 int cur_height = 0;
1053 int old_hl_mask;
Bram Moolenaar3d9bdfe2017-08-12 22:55:58 +02001054 cursorentry_T *shape;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001055 int id;
Bram Moolenaar3d9bdfe2017-08-12 22:55:58 +02001056#ifdef FEAT_TERMINAL
1057 guicolor_T shape_fg = INVALCOLOR;
1058 guicolor_T shape_bg = INVALCOLOR;
1059#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001060 guicolor_T cfg, cbg, cc; /* cursor fore-/background color */
1061 int cattr; /* cursor attributes */
1062 int attr;
1063 attrentry_T *aep = NULL;
1064
Bram Moolenaar1b8d33b2008-08-06 12:37:44 +00001065 /* Don't update the cursor when halfway busy scrolling or the screen size
1066 * doesn't match 'columns' and 'lines. ScreenLines[] isn't valid then. */
1067 if (!can_update_cursor || screen_Columns != gui.num_cols
1068 || screen_Rows != gui.num_rows)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001069 return;
1070
1071 gui_check_pos();
1072 if (!gui.cursor_is_valid || force
1073 || gui.row != gui.cursor_row || gui.col != gui.cursor_col)
1074 {
1075 gui_undraw_cursor();
1076 if (gui.row < 0)
1077 return;
1078#ifdef USE_IM_CONTROL
1079 if (gui.row != gui.cursor_row || gui.col != gui.cursor_col)
1080 im_set_position(gui.row, gui.col);
1081#endif
1082 gui.cursor_row = gui.row;
1083 gui.cursor_col = gui.col;
1084
1085 /* Only write to the screen after ScreenLines[] has been initialized */
1086 if (!screen_cleared || ScreenLines == NULL)
1087 return;
1088
1089 /* Clear the selection if we are about to write over it */
1090 if (clear_selection)
1091 clip_may_clear_selection(gui.row, gui.row);
1092 /* Check that the cursor is inside the shell (resizing may have made
1093 * it invalid) */
1094 if (gui.row >= screen_Rows || gui.col >= screen_Columns)
1095 return;
1096
1097 gui.cursor_is_valid = TRUE;
1098
1099 /*
1100 * How the cursor is drawn depends on the current mode.
Bram Moolenaar3d9bdfe2017-08-12 22:55:58 +02001101 * When in a terminal window use the shape/color specified there.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001102 */
Bram Moolenaar3d9bdfe2017-08-12 22:55:58 +02001103#ifdef FEAT_TERMINAL
1104 if (use_terminal_cursor())
1105 shape = term_get_cursor_shape(&shape_fg, &shape_bg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001106 else
Bram Moolenaar3d9bdfe2017-08-12 22:55:58 +02001107#endif
1108 shape = &shape_table[get_shape_idx(FALSE)];
1109 if (State & LANGMAP)
1110 id = shape->id_lm;
1111 else
1112 id = shape->id;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001113
1114 /* get the colors and attributes for the cursor. Default is inverted */
1115 cfg = INVALCOLOR;
1116 cbg = INVALCOLOR;
1117 cattr = HL_INVERSE;
Bram Moolenaar3d9bdfe2017-08-12 22:55:58 +02001118 gui_mch_set_blinking(shape->blinkwait,
1119 shape->blinkon,
1120 shape->blinkoff);
1121#ifdef FEAT_TERMINAL
1122 if (shape_bg != INVALCOLOR)
1123 {
1124 cattr = 0;
1125 cfg = shape_fg;
1126 cbg = shape_bg;
1127 }
1128 else
1129#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001130 if (id > 0)
1131 {
1132 cattr = syn_id2colors(id, &cfg, &cbg);
1133#if defined(USE_IM_CONTROL) || defined(FEAT_HANGULIN)
1134 {
1135 static int iid;
1136 guicolor_T fg, bg;
1137
Bram Moolenaarc236c162008-07-13 17:41:49 +00001138 if (
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02001139# if defined(FEAT_GUI_GTK) && !defined(FEAT_HANGULIN)
Bram Moolenaarc236c162008-07-13 17:41:49 +00001140 preedit_get_status()
1141# else
1142 im_get_status()
1143# endif
1144 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00001145 {
1146 iid = syn_name2id((char_u *)"CursorIM");
1147 if (iid > 0)
1148 {
1149 syn_id2colors(iid, &fg, &bg);
1150 if (bg != INVALCOLOR)
1151 cbg = bg;
1152 if (fg != INVALCOLOR)
1153 cfg = fg;
1154 }
1155 }
1156 }
1157#endif
1158 }
1159
1160 /*
1161 * Get the attributes for the character under the cursor.
1162 * When no cursor color was given, use the character color.
1163 */
1164 attr = ScreenAttrs[LineOffset[gui.row] + gui.col];
1165 if (attr > HL_ALL)
1166 aep = syn_gui_attr2entry(attr);
1167 if (aep != NULL)
1168 {
1169 attr = aep->ae_attr;
1170 if (cfg == INVALCOLOR)
1171 cfg = ((attr & HL_INVERSE) ? aep->ae_u.gui.bg_color
1172 : aep->ae_u.gui.fg_color);
1173 if (cbg == INVALCOLOR)
1174 cbg = ((attr & HL_INVERSE) ? aep->ae_u.gui.fg_color
1175 : aep->ae_u.gui.bg_color);
1176 }
1177 if (cfg == INVALCOLOR)
1178 cfg = (attr & HL_INVERSE) ? gui.back_pixel : gui.norm_pixel;
1179 if (cbg == INVALCOLOR)
1180 cbg = (attr & HL_INVERSE) ? gui.norm_pixel : gui.back_pixel;
1181
1182#ifdef FEAT_XIM
1183 if (aep != NULL)
1184 {
1185 xim_bg_color = ((attr & HL_INVERSE) ? aep->ae_u.gui.fg_color
1186 : aep->ae_u.gui.bg_color);
1187 xim_fg_color = ((attr & HL_INVERSE) ? aep->ae_u.gui.bg_color
1188 : aep->ae_u.gui.fg_color);
1189 if (xim_bg_color == INVALCOLOR)
1190 xim_bg_color = (attr & HL_INVERSE) ? gui.norm_pixel
1191 : gui.back_pixel;
1192 if (xim_fg_color == INVALCOLOR)
1193 xim_fg_color = (attr & HL_INVERSE) ? gui.back_pixel
1194 : gui.norm_pixel;
1195 }
1196 else
1197 {
1198 xim_bg_color = (attr & HL_INVERSE) ? gui.norm_pixel
1199 : gui.back_pixel;
1200 xim_fg_color = (attr & HL_INVERSE) ? gui.back_pixel
1201 : gui.norm_pixel;
1202 }
1203#endif
1204
1205 attr &= ~HL_INVERSE;
1206 if (cattr & HL_INVERSE)
1207 {
1208 cc = cbg;
1209 cbg = cfg;
1210 cfg = cc;
1211 }
1212 cattr &= ~HL_INVERSE;
1213
1214 /*
1215 * When we don't have window focus, draw a hollow cursor.
1216 */
1217 if (!gui.in_focus)
1218 {
1219 gui_mch_draw_hollow_cursor(cbg);
1220 return;
1221 }
1222
1223 old_hl_mask = gui.highlight_mask;
Bram Moolenaar3d9bdfe2017-08-12 22:55:58 +02001224 if (shape->shape == SHAPE_BLOCK
Bram Moolenaar071d4272004-06-13 20:20:40 +00001225#ifdef FEAT_HANGULIN
1226 || composing_hangul
1227#endif
1228 )
1229 {
1230 /*
1231 * Draw the text character with the cursor colors. Use the
1232 * character attributes plus the cursor attributes.
1233 */
1234 gui.highlight_mask = (cattr | attr);
1235#ifdef FEAT_HANGULIN
1236 if (composing_hangul)
Bram Moolenaar72f4cc42015-11-10 14:35:18 +01001237 {
1238 char_u *comp_buf;
1239 int comp_len;
1240
1241 comp_buf = hangul_composing_buffer_get(&comp_len);
1242 if (comp_buf)
1243 {
1244 (void)gui_outstr_nowrap(comp_buf, comp_len,
1245 GUI_MON_IS_CURSOR | GUI_MON_NOCLEAR,
1246 cfg, cbg, 0);
1247 vim_free(comp_buf);
1248 }
1249 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001250 else
1251#endif
1252 (void)gui_screenchar(LineOffset[gui.row] + gui.col,
1253 GUI_MON_IS_CURSOR | GUI_MON_NOCLEAR, cfg, cbg, 0);
1254 }
1255 else
1256 {
1257#if defined(FEAT_MBYTE) && defined(FEAT_RIGHTLEFT)
1258 int col_off = FALSE;
1259#endif
1260 /*
1261 * First draw the partial cursor, then overwrite with the text
1262 * character, using a transparent background.
1263 */
Bram Moolenaar3d9bdfe2017-08-12 22:55:58 +02001264 if (shape->shape == SHAPE_VER)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001265 {
1266 cur_height = gui.char_height;
Bram Moolenaar3d9bdfe2017-08-12 22:55:58 +02001267 cur_width = (gui.char_width * shape->percentage + 99) / 100;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001268 }
1269 else
1270 {
Bram Moolenaar3d9bdfe2017-08-12 22:55:58 +02001271 cur_height = (gui.char_height * shape->percentage + 99) / 100;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001272 cur_width = gui.char_width;
1273 }
1274#ifdef FEAT_MBYTE
Bram Moolenaar367329b2007-08-30 11:53:22 +00001275 if (has_mbyte && (*mb_off2cells)(LineOffset[gui.row] + gui.col,
1276 LineOffset[gui.row] + screen_Columns) > 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001277 {
1278 /* Double wide character. */
Bram Moolenaar3d9bdfe2017-08-12 22:55:58 +02001279 if (shape->shape != SHAPE_VER)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001280 cur_width += gui.char_width;
1281# ifdef FEAT_RIGHTLEFT
1282 if (CURSOR_BAR_RIGHT)
1283 {
1284 /* gui.col points to the left halve of the character but
1285 * the vertical line needs to be on the right halve.
1286 * A double-wide horizontal line is also drawn from the
1287 * right halve in gui_mch_draw_part_cursor(). */
1288 col_off = TRUE;
1289 ++gui.col;
1290 }
1291# endif
1292 }
1293#endif
1294 gui_mch_draw_part_cursor(cur_width, cur_height, cbg);
1295#if defined(FEAT_MBYTE) && defined(FEAT_RIGHTLEFT)
1296 if (col_off)
1297 --gui.col;
1298#endif
1299
1300#ifndef FEAT_GUI_MSWIN /* doesn't seem to work for MSWindows */
1301 gui.highlight_mask = ScreenAttrs[LineOffset[gui.row] + gui.col];
1302 (void)gui_screenchar(LineOffset[gui.row] + gui.col,
1303 GUI_MON_TRS_CURSOR | GUI_MON_NOCLEAR,
1304 (guicolor_T)0, (guicolor_T)0, 0);
1305#endif
1306 }
1307 gui.highlight_mask = old_hl_mask;
1308 }
1309}
1310
1311#if defined(FEAT_MENU) || defined(PROTO)
1312 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001313gui_position_menu(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001314{
Bram Moolenaar9372a112005-12-06 19:59:18 +00001315# if !defined(FEAT_GUI_GTK) && !defined(FEAT_GUI_MOTIF)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001316 if (gui.menu_is_active && gui.in_use)
1317 gui_mch_set_menu_pos(0, 0, gui.menu_width, gui.menu_height);
1318# endif
1319}
1320#endif
1321
1322/*
1323 * Position the various GUI components (text area, menu). The vertical
1324 * scrollbars are NOT handled here. See gui_update_scrollbars().
1325 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001326 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001327gui_position_components(int total_width UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001328{
1329 int text_area_x;
1330 int text_area_y;
1331 int text_area_width;
1332 int text_area_height;
1333
1334 /* avoid that moving components around generates events */
1335 ++hold_gui_events;
1336
1337 text_area_x = 0;
1338 if (gui.which_scrollbars[SBAR_LEFT])
1339 text_area_x += gui.scrollbar_width;
1340
1341 text_area_y = 0;
1342#if defined(FEAT_MENU) && !(defined(FEAT_GUI_GTK) || defined(FEAT_GUI_PHOTON))
1343 gui.menu_width = total_width;
1344 if (gui.menu_is_active)
1345 text_area_y += gui.menu_height;
1346#endif
1347#if defined(FEAT_TOOLBAR) && defined(FEAT_GUI_MSWIN)
1348 if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
1349 text_area_y = TOOLBAR_BUTTON_HEIGHT + TOOLBAR_BORDER_HEIGHT;
1350#endif
1351
Bram Moolenaar910f66f2006-04-05 20:41:53 +00001352# if defined(FEAT_GUI_TABLINE) && (defined(FEAT_GUI_MSWIN) \
Bram Moolenaar367329b2007-08-30 11:53:22 +00001353 || defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_MAC))
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001354 if (gui_has_tabline())
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001355 text_area_y += gui.tabline_height;
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001356#endif
1357
Bram Moolenaar071d4272004-06-13 20:20:40 +00001358#if defined(FEAT_TOOLBAR) && (defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA))
1359 if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
1360 {
1361# ifdef FEAT_GUI_ATHENA
1362 gui_mch_set_toolbar_pos(0, text_area_y,
1363 gui.menu_width, gui.toolbar_height);
1364# endif
1365 text_area_y += gui.toolbar_height;
1366 }
1367#endif
1368
1369 text_area_width = gui.num_cols * gui.char_width + gui.border_offset * 2;
1370 text_area_height = gui.num_rows * gui.char_height + gui.border_offset * 2;
1371
1372 gui_mch_set_text_area_pos(text_area_x,
1373 text_area_y,
1374 text_area_width,
1375 text_area_height
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02001376#if defined(FEAT_XIM) && !defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001377 + xim_get_status_area_height()
1378#endif
1379 );
1380#ifdef FEAT_MENU
1381 gui_position_menu();
1382#endif
1383 if (gui.which_scrollbars[SBAR_BOTTOM])
1384 gui_mch_set_scrollbar_pos(&gui.bottom_sbar,
1385 text_area_x,
1386 text_area_y + text_area_height,
1387 text_area_width,
1388 gui.scrollbar_height);
1389 gui.left_sbar_x = 0;
1390 gui.right_sbar_x = text_area_x + text_area_width;
1391
1392 --hold_gui_events;
1393}
1394
Bram Moolenaar02743632005-07-25 20:42:36 +00001395/*
1396 * Get the width of the widgets and decorations to the side of the text area.
1397 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001398 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001399gui_get_base_width(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001400{
1401 int base_width;
1402
1403 base_width = 2 * gui.border_offset;
1404 if (gui.which_scrollbars[SBAR_LEFT])
1405 base_width += gui.scrollbar_width;
1406 if (gui.which_scrollbars[SBAR_RIGHT])
1407 base_width += gui.scrollbar_width;
1408 return base_width;
1409}
1410
Bram Moolenaar02743632005-07-25 20:42:36 +00001411/*
1412 * Get the height of the widgets and decorations above and below the text area.
1413 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001414 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001415gui_get_base_height(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001416{
1417 int base_height;
1418
1419 base_height = 2 * gui.border_offset;
1420 if (gui.which_scrollbars[SBAR_BOTTOM])
1421 base_height += gui.scrollbar_height;
1422#ifdef FEAT_GUI_GTK
1423 /* We can't take the sizes properly into account until anything is
1424 * realized. Therefore we recalculate all the values here just before
1425 * setting the size. (--mdcki) */
1426#else
1427# ifdef FEAT_MENU
1428 if (gui.menu_is_active)
1429 base_height += gui.menu_height;
1430# endif
1431# ifdef FEAT_TOOLBAR
1432 if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
1433# if defined(FEAT_GUI_MSWIN) && defined(FEAT_TOOLBAR)
1434 base_height += (TOOLBAR_BUTTON_HEIGHT + TOOLBAR_BORDER_HEIGHT);
1435# else
1436 base_height += gui.toolbar_height;
1437# endif
1438# endif
Bram Moolenaar910f66f2006-04-05 20:41:53 +00001439# if defined(FEAT_GUI_TABLINE) && (defined(FEAT_GUI_MSWIN) \
1440 || defined(FEAT_GUI_MOTIF))
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001441 if (gui_has_tabline())
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00001442 base_height += gui.tabline_height;
Bram Moolenaar3991dab2006-03-27 17:01:56 +00001443# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001444# ifdef FEAT_FOOTER
1445 if (vim_strchr(p_go, GO_FOOTER) != NULL)
1446 base_height += gui.footer_height;
1447# endif
1448# if defined(FEAT_GUI_MOTIF) && defined(FEAT_MENU)
1449 base_height += gui_mch_text_area_extra_height();
1450# endif
1451#endif
1452 return base_height;
1453}
1454
1455/*
1456 * Should be called after the GUI shell has been resized. Its arguments are
1457 * the new width and height of the shell in pixels.
1458 */
1459 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001460gui_resize_shell(int pixel_width, int pixel_height)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001461{
1462 static int busy = FALSE;
1463
1464 if (!gui.shell_created) /* ignore when still initializing */
1465 return;
1466
1467 /*
1468 * Can't resize the screen while it is being redrawn. Remember the new
1469 * size and handle it later.
1470 */
1471 if (updating_screen || busy)
1472 {
1473 new_pixel_width = pixel_width;
1474 new_pixel_height = pixel_height;
1475 return;
1476 }
1477
1478again:
Bram Moolenaar6b40f302017-02-03 22:01:47 +01001479 new_pixel_width = 0;
1480 new_pixel_height = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001481 busy = TRUE;
1482
Bram Moolenaar071d4272004-06-13 20:20:40 +00001483 /* Flush pending output before redrawing */
1484 out_flush();
1485
1486 gui.num_cols = (pixel_width - gui_get_base_width()) / gui.char_width;
Bram Moolenaar6f7743e2008-02-06 16:33:58 +00001487 gui.num_rows = (pixel_height - gui_get_base_height()) / gui.char_height;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001488
1489 gui_position_components(pixel_width);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001490 gui_reset_scroll_region();
Bram Moolenaar6b40f302017-02-03 22:01:47 +01001491
Bram Moolenaar071d4272004-06-13 20:20:40 +00001492 /*
1493 * At the "more" and ":confirm" prompt there is no redraw, put the cursor
1494 * at the last line here (why does it have to be one row too low?).
1495 */
1496 if (State == ASKMORE || State == CONFIRM)
1497 gui.row = gui.num_rows;
1498
1499 /* Only comparing Rows and Columns may be sufficient, but let's stay on
1500 * the safe side. */
1501 if (gui.num_rows != screen_Rows || gui.num_cols != screen_Columns
1502 || gui.num_rows != Rows || gui.num_cols != Columns)
1503 shell_resized();
1504
Bram Moolenaar071d4272004-06-13 20:20:40 +00001505 gui_update_scrollbars(TRUE);
1506 gui_update_cursor(FALSE, TRUE);
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02001507#if defined(FEAT_XIM) && !defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001508 xim_set_status_area();
1509#endif
1510
1511 busy = FALSE;
Bram Moolenaare45828b2006-02-15 22:12:56 +00001512
Bram Moolenaar6b40f302017-02-03 22:01:47 +01001513 /* We may have been called again while redrawing the screen.
1514 * Need to do it all again with the latest size then. But only if the size
1515 * actually changed. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001516 if (new_pixel_height)
1517 {
Bram Moolenaar6b40f302017-02-03 22:01:47 +01001518 if (pixel_width == new_pixel_width && pixel_height == new_pixel_height)
1519 {
1520 new_pixel_width = 0;
1521 new_pixel_height = 0;
1522 }
1523 else
1524 {
1525 pixel_width = new_pixel_width;
1526 pixel_height = new_pixel_height;
1527 goto again;
1528 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001529 }
1530}
1531
1532/*
1533 * Check if gui_resize_shell() must be called.
1534 */
1535 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001536gui_may_resize_shell(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001537{
Bram Moolenaar071d4272004-06-13 20:20:40 +00001538 if (new_pixel_height)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001539 /* careful: gui_resize_shell() may postpone the resize again if we
1540 * were called indirectly by it */
Bram Moolenaar6b40f302017-02-03 22:01:47 +01001541 gui_resize_shell(new_pixel_width, new_pixel_height);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001542}
1543
1544 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001545gui_get_shellsize(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001546{
1547 Rows = gui.num_rows;
1548 Columns = gui.num_cols;
1549 return OK;
1550}
1551
1552/*
1553 * Set the size of the Vim shell according to Rows and Columns.
Bram Moolenaar02743632005-07-25 20:42:36 +00001554 * If "fit_to_display" is TRUE then the size may be reduced to fit the window
1555 * on the screen.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001556 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001557 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001558gui_set_shellsize(
1559 int mustset UNUSED, /* set by the user */
1560 int fit_to_display,
1561 int direction) /* RESIZE_HOR, RESIZE_VER */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001562{
1563 int base_width;
1564 int base_height;
1565 int width;
1566 int height;
1567 int min_width;
1568 int min_height;
1569 int screen_w;
1570 int screen_h;
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02001571#ifdef FEAT_GUI_GTK
Bram Moolenaar09736232009-09-23 16:14:49 +00001572 int un_maximize = mustset;
Bram Moolenaarcc448b32010-07-14 16:52:17 +02001573 int did_adjust = 0;
Bram Moolenaar09736232009-09-23 16:14:49 +00001574#endif
Bram Moolenaarc5d5d012010-01-27 21:05:05 +01001575 int x = -1, y = -1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001576
1577 if (!gui.shell_created)
1578 return;
1579
Bram Moolenaar12bc1b52011-08-10 17:44:45 +02001580#if defined(MSWIN) || defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001581 /* If not setting to a user specified size and maximized, calculate the
1582 * number of characters that fit in the maximized window. */
1583 if (!mustset && gui_mch_maximized())
1584 {
1585 gui_mch_newfont();
1586 return;
1587 }
1588#endif
1589
1590 base_width = gui_get_base_width();
1591 base_height = gui_get_base_height();
Bram Moolenaarc5d5d012010-01-27 21:05:05 +01001592 if (fit_to_display)
1593 /* Remember the original window position. */
Bram Moolenaarcde88542015-08-11 19:14:00 +02001594 (void)gui_mch_get_winpos(&x, &y);
Bram Moolenaarc5d5d012010-01-27 21:05:05 +01001595
Bram Moolenaar071d4272004-06-13 20:20:40 +00001596#ifdef USE_SUN_WORKSHOP
1597 if (!mustset && usingSunWorkShop
1598 && workshop_get_width_height(&width, &height))
1599 {
1600 Columns = (width - base_width + gui.char_width - 1) / gui.char_width;
1601 Rows = (height - base_height + gui.char_height - 1) / gui.char_height;
1602 }
1603 else
1604#endif
1605 {
1606 width = Columns * gui.char_width + base_width;
1607 height = Rows * gui.char_height + base_height;
1608 }
1609
1610 if (fit_to_display)
1611 {
1612 gui_mch_get_screen_dimensions(&screen_w, &screen_h);
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00001613 if ((direction & RESIZE_HOR) && width > screen_w)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001614 {
1615 Columns = (screen_w - base_width) / gui.char_width;
1616 if (Columns < MIN_COLUMNS)
1617 Columns = MIN_COLUMNS;
1618 width = Columns * gui.char_width + base_width;
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02001619#ifdef FEAT_GUI_GTK
Bram Moolenaar09736232009-09-23 16:14:49 +00001620 ++did_adjust;
1621#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001622 }
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00001623 if ((direction & RESIZE_VERT) && height > screen_h)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001624 {
1625 Rows = (screen_h - base_height) / gui.char_height;
1626 check_shellsize();
1627 height = Rows * gui.char_height + base_height;
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02001628#ifdef FEAT_GUI_GTK
Bram Moolenaar09736232009-09-23 16:14:49 +00001629 ++did_adjust;
1630#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001631 }
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02001632#ifdef FEAT_GUI_GTK
Bram Moolenaar09736232009-09-23 16:14:49 +00001633 if (did_adjust == 2 || (width + gui.char_width >= screen_w
1634 && height + gui.char_height >= screen_h))
1635 /* don't unmaximize if at maximum size */
1636 un_maximize = FALSE;
1637#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001638 }
Bram Moolenaare057d402013-06-30 17:51:51 +02001639 limit_screen_size();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001640 gui.num_cols = Columns;
1641 gui.num_rows = Rows;
1642
1643 min_width = base_width + MIN_COLUMNS * gui.char_width;
1644 min_height = base_height + MIN_LINES * gui.char_height;
Bram Moolenaar09736232009-09-23 16:14:49 +00001645#ifdef FEAT_WINDOWS
Bram Moolenaar32466aa2006-02-24 23:53:04 +00001646 min_height += tabline_height() * gui.char_height;
Bram Moolenaar09736232009-09-23 16:14:49 +00001647#endif
1648
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02001649#ifdef FEAT_GUI_GTK
Bram Moolenaar09736232009-09-23 16:14:49 +00001650 if (un_maximize)
1651 {
1652 /* If the window size is smaller than the screen unmaximize the
1653 * window, otherwise resizing won't work. */
1654 gui_mch_get_screen_dimensions(&screen_w, &screen_h);
1655 if ((width + gui.char_width < screen_w
1656 || height + gui.char_height * 2 < screen_h)
1657 && gui_mch_maximized())
1658 gui_mch_unmaximize();
1659 }
1660#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001661
1662 gui_mch_set_shellsize(width, height, min_width, min_height,
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00001663 base_width, base_height, direction);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001664
Bram Moolenaarc5d5d012010-01-27 21:05:05 +01001665 if (fit_to_display && x >= 0 && y >= 0)
1666 {
1667 /* Some window managers put the Vim window left of/above the screen.
1668 * Only change the position if it wasn't already negative before
1669 * (happens on MS-Windows with a secondary monitor). */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001670 gui_mch_update();
1671 if (gui_mch_get_winpos(&x, &y) == OK && (x < 0 || y < 0))
1672 gui_mch_set_winpos(x < 0 ? 0 : x, y < 0 ? 0 : y);
1673 }
1674
1675 gui_position_components(width);
1676 gui_update_scrollbars(TRUE);
1677 gui_reset_scroll_region();
1678}
1679
1680/*
1681 * Called when Rows and/or Columns has changed.
1682 */
1683 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001684gui_new_shellsize(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001685{
1686 gui_reset_scroll_region();
1687}
1688
1689/*
1690 * Make scroll region cover whole screen.
1691 */
1692 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001693gui_reset_scroll_region(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001694{
1695 gui.scroll_region_top = 0;
1696 gui.scroll_region_bot = gui.num_rows - 1;
1697 gui.scroll_region_left = 0;
1698 gui.scroll_region_right = gui.num_cols - 1;
1699}
1700
1701 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001702gui_start_highlight(int mask)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001703{
1704 if (mask > HL_ALL) /* highlight code */
1705 gui.highlight_mask = mask;
1706 else /* mask */
1707 gui.highlight_mask |= mask;
1708}
1709
1710 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001711gui_stop_highlight(int mask)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001712{
1713 if (mask > HL_ALL) /* highlight code */
1714 gui.highlight_mask = HL_NORMAL;
1715 else /* mask */
1716 gui.highlight_mask &= ~mask;
1717}
1718
1719/*
1720 * Clear a rectangular region of the screen from text pos (row1, col1) to
1721 * (row2, col2) inclusive.
1722 */
1723 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001724gui_clear_block(
1725 int row1,
1726 int col1,
1727 int row2,
1728 int col2)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001729{
1730 /* Clear the selection if we are about to write over it */
1731 clip_may_clear_selection(row1, row2);
1732
1733 gui_mch_clear_block(row1, col1, row2, col2);
1734
1735 /* Invalidate cursor if it was in this block */
1736 if ( gui.cursor_row >= row1 && gui.cursor_row <= row2
1737 && gui.cursor_col >= col1 && gui.cursor_col <= col2)
1738 gui.cursor_is_valid = FALSE;
1739}
1740
1741/*
1742 * Write code to update the cursor later. This avoids the need to flush the
1743 * output buffer before calling gui_update_cursor().
1744 */
1745 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001746gui_update_cursor_later(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001747{
Bram Moolenaar3d9bdfe2017-08-12 22:55:58 +02001748 OUT_STR(IF_EB("\033|s", ESC_STR "|s"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001749}
1750
1751 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001752gui_write(
1753 char_u *s,
1754 int len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001755{
1756 char_u *p;
1757 int arg1 = 0, arg2 = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001758 int force_cursor = FALSE; /* force cursor update */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001759 int force_scrollbar = FALSE;
1760 static win_T *old_curwin = NULL;
1761
1762/* #define DEBUG_GUI_WRITE */
1763#ifdef DEBUG_GUI_WRITE
1764 {
1765 int i;
1766 char_u *str;
1767
1768 printf("gui_write(%d):\n ", len);
1769 for (i = 0; i < len; i++)
1770 if (s[i] == ESC)
1771 {
1772 if (i != 0)
1773 printf("\n ");
1774 printf("<ESC>");
1775 }
1776 else
1777 {
1778 str = transchar_byte(s[i]);
1779 if (str[0] && str[1])
1780 printf("<%s>", (char *)str);
1781 else
1782 printf("%s", (char *)str);
1783 }
1784 printf("\n");
1785 }
1786#endif
1787 while (len)
1788 {
1789 if (s[0] == ESC && s[1] == '|')
1790 {
1791 p = s + 2;
Bram Moolenaar4a6c6702016-07-01 15:48:05 +02001792 if (VIM_ISDIGIT(*p) || (*p == '-' && VIM_ISDIGIT(*(p + 1))))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001793 {
1794 arg1 = getdigits(&p);
1795 if (p > s + len)
1796 break;
1797 if (*p == ';')
1798 {
1799 ++p;
1800 arg2 = getdigits(&p);
1801 if (p > s + len)
1802 break;
1803 }
1804 }
1805 switch (*p)
1806 {
1807 case 'C': /* Clear screen */
1808 clip_scroll_selection(9999);
1809 gui_mch_clear_all();
1810 gui.cursor_is_valid = FALSE;
1811 force_scrollbar = TRUE;
1812 break;
1813 case 'M': /* Move cursor */
1814 gui_set_cursor(arg1, arg2);
1815 break;
1816 case 's': /* force cursor (shape) update */
1817 force_cursor = TRUE;
1818 break;
1819 case 'R': /* Set scroll region */
1820 if (arg1 < arg2)
1821 {
1822 gui.scroll_region_top = arg1;
1823 gui.scroll_region_bot = arg2;
1824 }
1825 else
1826 {
1827 gui.scroll_region_top = arg2;
1828 gui.scroll_region_bot = arg1;
1829 }
1830 break;
Bram Moolenaar44a2f922016-03-19 22:11:51 +01001831#ifdef FEAT_WINDOWS
Bram Moolenaar071d4272004-06-13 20:20:40 +00001832 case 'V': /* Set vertical scroll region */
1833 if (arg1 < arg2)
1834 {
1835 gui.scroll_region_left = arg1;
1836 gui.scroll_region_right = arg2;
1837 }
1838 else
1839 {
1840 gui.scroll_region_left = arg2;
1841 gui.scroll_region_right = arg1;
1842 }
1843 break;
1844#endif
1845 case 'd': /* Delete line */
1846 gui_delete_lines(gui.row, 1);
1847 break;
1848 case 'D': /* Delete lines */
1849 gui_delete_lines(gui.row, arg1);
1850 break;
1851 case 'i': /* Insert line */
1852 gui_insert_lines(gui.row, 1);
1853 break;
1854 case 'I': /* Insert lines */
1855 gui_insert_lines(gui.row, arg1);
1856 break;
1857 case '$': /* Clear to end-of-line */
1858 gui_clear_block(gui.row, gui.col, gui.row,
1859 (int)Columns - 1);
1860 break;
1861 case 'h': /* Turn on highlighting */
1862 gui_start_highlight(arg1);
1863 break;
1864 case 'H': /* Turn off highlighting */
1865 gui_stop_highlight(arg1);
1866 break;
1867 case 'f': /* flash the window (visual bell) */
1868 gui_mch_flash(arg1 == 0 ? 20 : arg1);
1869 break;
1870 default:
1871 p = s + 1; /* Skip the ESC */
1872 break;
1873 }
1874 len -= (int)(++p - s);
1875 s = p;
1876 }
1877 else if (
1878#ifdef EBCDIC
1879 CtrlChar(s[0]) != 0 /* Ctrl character */
1880#else
1881 s[0] < 0x20 /* Ctrl character */
1882#endif
1883#ifdef FEAT_SIGN_ICONS
1884 && s[0] != SIGN_BYTE
1885# ifdef FEAT_NETBEANS_INTG
1886 && s[0] != MULTISIGN_BYTE
1887# endif
1888#endif
1889 )
1890 {
1891 if (s[0] == '\n') /* NL */
1892 {
1893 gui.col = 0;
1894 if (gui.row < gui.scroll_region_bot)
1895 gui.row++;
1896 else
1897 gui_delete_lines(gui.scroll_region_top, 1);
1898 }
1899 else if (s[0] == '\r') /* CR */
1900 {
1901 gui.col = 0;
1902 }
1903 else if (s[0] == '\b') /* Backspace */
1904 {
1905 if (gui.col)
1906 --gui.col;
1907 }
1908 else if (s[0] == Ctrl_L) /* cursor-right */
1909 {
1910 ++gui.col;
1911 }
1912 else if (s[0] == Ctrl_G) /* Beep */
1913 {
1914 gui_mch_beep();
1915 }
1916 /* Other Ctrl character: shouldn't happen! */
1917
1918 --len; /* Skip this char */
1919 ++s;
1920 }
1921 else
1922 {
1923 p = s;
1924 while (len > 0 && (
1925#ifdef EBCDIC
1926 CtrlChar(*p) == 0
1927#else
1928 *p >= 0x20
1929#endif
1930#ifdef FEAT_SIGN_ICONS
1931 || *p == SIGN_BYTE
1932# ifdef FEAT_NETBEANS_INTG
1933 || *p == MULTISIGN_BYTE
1934# endif
1935#endif
1936 ))
1937 {
1938 len--;
1939 p++;
1940 }
1941 gui_outstr(s, (int)(p - s));
1942 s = p;
1943 }
1944 }
1945
1946 /* Postponed update of the cursor (won't work if "can_update_cursor" isn't
1947 * set). */
1948 if (force_cursor)
1949 gui_update_cursor(TRUE, TRUE);
1950
1951 /* When switching to another window the dragging must have stopped.
1952 * Required for GTK, dragged_sb isn't reset. */
1953 if (old_curwin != curwin)
1954 gui.dragged_sb = SBAR_NONE;
1955
1956 /* Update the scrollbars after clearing the screen or when switched
1957 * to another window.
1958 * Update the horizontal scrollbar always, it's difficult to check all
1959 * situations where it might change. */
1960 if (force_scrollbar || old_curwin != curwin)
1961 gui_update_scrollbars(force_scrollbar);
1962 else
1963 gui_update_horiz_scrollbar(FALSE);
1964 old_curwin = curwin;
1965
1966 /*
1967 * We need to make sure this is cleared since Athena doesn't tell us when
1968 * he is done dragging. Do the same for GTK.
1969 */
Bram Moolenaar9372a112005-12-06 19:59:18 +00001970#if defined(FEAT_GUI_ATHENA) || defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001971 gui.dragged_sb = SBAR_NONE;
1972#endif
1973
1974 gui_mch_flush(); /* In case vim decides to take a nap */
1975}
1976
1977/*
1978 * When ScreenLines[] is invalid, updating the cursor should not be done, it
1979 * produces wrong results. Call gui_dont_update_cursor() before that code and
1980 * gui_can_update_cursor() afterwards.
1981 */
1982 void
Bram Moolenaar107abd22016-08-12 14:08:25 +02001983gui_dont_update_cursor(int undraw)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001984{
1985 if (gui.in_use)
1986 {
1987 /* Undraw the cursor now, we probably can't do it after the change. */
Bram Moolenaar107abd22016-08-12 14:08:25 +02001988 if (undraw)
1989 gui_undraw_cursor();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001990 can_update_cursor = FALSE;
1991 }
1992}
1993
1994 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01001995gui_can_update_cursor(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001996{
1997 can_update_cursor = TRUE;
1998 /* No need to update the cursor right now, there is always more output
1999 * after scrolling. */
2000}
2001
2002 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01002003gui_outstr(char_u *s, int len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002004{
2005 int this_len;
2006#ifdef FEAT_MBYTE
2007 int cells;
2008#endif
2009
2010 if (len == 0)
2011 return;
2012
2013 if (len < 0)
2014 len = (int)STRLEN(s);
2015
2016 while (len > 0)
2017 {
2018#ifdef FEAT_MBYTE
2019 if (has_mbyte)
2020 {
2021 /* Find out how many chars fit in the current line. */
2022 cells = 0;
2023 for (this_len = 0; this_len < len; )
2024 {
2025 cells += (*mb_ptr2cells)(s + this_len);
2026 if (gui.col + cells > Columns)
2027 break;
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00002028 this_len += (*mb_ptr2len)(s + this_len);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002029 }
2030 if (this_len > len)
2031 this_len = len; /* don't include following composing char */
2032 }
2033 else
2034#endif
2035 if (gui.col + len > Columns)
2036 this_len = Columns - gui.col;
2037 else
2038 this_len = len;
2039
2040 (void)gui_outstr_nowrap(s, this_len,
2041 0, (guicolor_T)0, (guicolor_T)0, 0);
2042 s += this_len;
2043 len -= this_len;
2044#ifdef FEAT_MBYTE
2045 /* fill up for a double-width char that doesn't fit. */
2046 if (len > 0 && gui.col < Columns)
2047 (void)gui_outstr_nowrap((char_u *)" ", 1,
2048 0, (guicolor_T)0, (guicolor_T)0, 0);
2049#endif
2050 /* The cursor may wrap to the next line. */
2051 if (gui.col >= Columns)
2052 {
2053 gui.col = 0;
2054 gui.row++;
2055 }
2056 }
2057}
2058
2059/*
2060 * Output one character (may be one or two display cells).
2061 * Caller must check for valid "off".
2062 * Returns FAIL or OK, just like gui_outstr_nowrap().
2063 */
2064 static int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01002065gui_screenchar(
2066 int off, /* Offset from start of screen */
2067 int flags,
2068 guicolor_T fg, /* colors for cursor */
2069 guicolor_T bg, /* colors for cursor */
2070 int back) /* backup this many chars when using bold trick */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002071{
2072#ifdef FEAT_MBYTE
2073 char_u buf[MB_MAXBYTES + 1];
2074
2075 /* Don't draw right halve of a double-width UTF-8 char. "cannot happen" */
2076 if (enc_utf8 && ScreenLines[off] == 0)
2077 return OK;
2078
2079 if (enc_utf8 && ScreenLinesUC[off] != 0)
2080 /* Draw UTF-8 multi-byte character. */
2081 return gui_outstr_nowrap(buf, utfc_char2bytes(off, buf),
2082 flags, fg, bg, back);
2083
2084 if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e)
2085 {
2086 buf[0] = ScreenLines[off];
2087 buf[1] = ScreenLines2[off];
2088 return gui_outstr_nowrap(buf, 2, flags, fg, bg, back);
2089 }
2090
2091 /* Draw non-multi-byte character or DBCS character. */
2092 return gui_outstr_nowrap(ScreenLines + off,
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00002093 enc_dbcs ? (*mb_ptr2len)(ScreenLines + off) : 1,
Bram Moolenaar071d4272004-06-13 20:20:40 +00002094 flags, fg, bg, back);
2095#else
2096 return gui_outstr_nowrap(ScreenLines + off, 1, flags, fg, bg, back);
2097#endif
2098}
2099
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02002100#ifdef FEAT_GUI_GTK
Bram Moolenaar071d4272004-06-13 20:20:40 +00002101/*
2102 * Output the string at the given screen position. This is used in place
2103 * of gui_screenchar() where possible because Pango needs as much context
2104 * as possible to work nicely. It's a lot faster as well.
2105 */
2106 static int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01002107gui_screenstr(
2108 int off, /* Offset from start of screen */
2109 int len, /* string length in screen cells */
2110 int flags,
2111 guicolor_T fg, /* colors for cursor */
2112 guicolor_T bg, /* colors for cursor */
2113 int back) /* backup this many chars when using bold trick */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002114{
2115 char_u *buf;
2116 int outlen = 0;
2117 int i;
2118 int retval;
2119
2120 if (len <= 0) /* "cannot happen"? */
2121 return OK;
2122
2123 if (enc_utf8)
2124 {
2125 buf = alloc((unsigned)(len * MB_MAXBYTES + 1));
2126 if (buf == NULL)
2127 return OK; /* not much we could do here... */
2128
2129 for (i = off; i < off + len; ++i)
2130 {
2131 if (ScreenLines[i] == 0)
2132 continue; /* skip second half of double-width char */
2133
2134 if (ScreenLinesUC[i] == 0)
2135 buf[outlen++] = ScreenLines[i];
2136 else
2137 outlen += utfc_char2bytes(i, buf + outlen);
2138 }
2139
2140 buf[outlen] = NUL; /* only to aid debugging */
2141 retval = gui_outstr_nowrap(buf, outlen, flags, fg, bg, back);
2142 vim_free(buf);
2143
2144 return retval;
2145 }
2146 else if (enc_dbcs == DBCS_JPNU)
2147 {
2148 buf = alloc((unsigned)(len * 2 + 1));
2149 if (buf == NULL)
2150 return OK; /* not much we could do here... */
2151
2152 for (i = off; i < off + len; ++i)
2153 {
2154 buf[outlen++] = ScreenLines[i];
2155
2156 /* handle double-byte single-width char */
2157 if (ScreenLines[i] == 0x8e)
2158 buf[outlen++] = ScreenLines2[i];
2159 else if (MB_BYTE2LEN(ScreenLines[i]) == 2)
2160 buf[outlen++] = ScreenLines[++i];
2161 }
2162
2163 buf[outlen] = NUL; /* only to aid debugging */
2164 retval = gui_outstr_nowrap(buf, outlen, flags, fg, bg, back);
2165 vim_free(buf);
2166
2167 return retval;
2168 }
2169 else
2170 {
2171 return gui_outstr_nowrap(&ScreenLines[off], len,
2172 flags, fg, bg, back);
2173 }
2174}
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02002175#endif /* FEAT_GUI_GTK */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002176
2177/*
2178 * Output the given string at the current cursor position. If the string is
2179 * too long to fit on the line, then it is truncated.
2180 * "flags":
2181 * GUI_MON_IS_CURSOR should only be used when this function is being called to
2182 * actually draw (an inverted) cursor.
Bram Moolenaarff1d0d42007-05-10 17:24:16 +00002183 * GUI_MON_TRS_CURSOR is used to draw the cursor text with a transparent
Bram Moolenaar071d4272004-06-13 20:20:40 +00002184 * background.
2185 * GUI_MON_NOCLEAR is used to avoid clearing the selection when drawing over
2186 * it.
2187 * Returns OK, unless "back" is non-zero and using the bold trick, then return
2188 * FAIL (the caller should start drawing "back" chars back).
2189 */
2190 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01002191gui_outstr_nowrap(
2192 char_u *s,
2193 int len,
2194 int flags,
2195 guicolor_T fg, /* colors for cursor */
2196 guicolor_T bg, /* colors for cursor */
2197 int back) /* backup this many chars when using bold trick */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002198{
2199 long_u highlight_mask;
2200 long_u hl_mask_todo;
2201 guicolor_T fg_color;
2202 guicolor_T bg_color;
Bram Moolenaar3918c952005-03-15 22:34:55 +00002203 guicolor_T sp_color;
Bram Moolenaarcf7164a2016-02-20 13:55:06 +01002204#if !defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002205 GuiFont font = NOFONT;
Bram Moolenaardb250522013-06-17 22:43:25 +02002206# ifdef FEAT_MBYTE
2207 GuiFont wide_font = NOFONT;
2208# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002209# ifdef FEAT_XFONTSET
2210 GuiFontset fontset = NOFONTSET;
2211# endif
2212#endif
2213 attrentry_T *aep = NULL;
2214 int draw_flags;
2215 int col = gui.col;
2216#ifdef FEAT_SIGN_ICONS
2217 int draw_sign = FALSE;
2218# ifdef FEAT_NETBEANS_INTG
2219 int multi_sign = FALSE;
2220# endif
2221#endif
2222
2223 if (len < 0)
2224 len = (int)STRLEN(s);
2225 if (len == 0)
2226 return OK;
2227
2228#ifdef FEAT_SIGN_ICONS
2229 if (*s == SIGN_BYTE
2230# ifdef FEAT_NETBEANS_INTG
2231 || *s == MULTISIGN_BYTE
2232# endif
2233 )
2234 {
2235# ifdef FEAT_NETBEANS_INTG
2236 if (*s == MULTISIGN_BYTE)
2237 multi_sign = TRUE;
2238# endif
2239 /* draw spaces instead */
2240 s = (char_u *)" ";
2241 if (len == 1 && col > 0)
2242 --col;
2243 len = 2;
2244 draw_sign = TRUE;
2245 highlight_mask = 0;
2246 }
2247 else
2248#endif
2249 if (gui.highlight_mask > HL_ALL)
2250 {
2251 aep = syn_gui_attr2entry(gui.highlight_mask);
2252 if (aep == NULL) /* highlighting not set */
2253 highlight_mask = 0;
2254 else
2255 highlight_mask = aep->ae_attr;
2256 }
2257 else
2258 highlight_mask = gui.highlight_mask;
2259 hl_mask_todo = highlight_mask;
2260
Bram Moolenaarcf7164a2016-02-20 13:55:06 +01002261#if !defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002262 /* Set the font */
2263 if (aep != NULL && aep->ae_u.gui.font != NOFONT)
2264 font = aep->ae_u.gui.font;
2265# ifdef FEAT_XFONTSET
2266 else if (aep != NULL && aep->ae_u.gui.fontset != NOFONTSET)
2267 fontset = aep->ae_u.gui.fontset;
2268# endif
2269 else
2270 {
2271# ifdef FEAT_XFONTSET
2272 if (gui.fontset != NOFONTSET)
2273 fontset = gui.fontset;
2274 else
2275# endif
2276 if (hl_mask_todo & (HL_BOLD | HL_STANDOUT))
2277 {
2278 if ((hl_mask_todo & HL_ITALIC) && gui.boldital_font != NOFONT)
2279 {
2280 font = gui.boldital_font;
2281 hl_mask_todo &= ~(HL_BOLD | HL_STANDOUT | HL_ITALIC);
2282 }
2283 else if (gui.bold_font != NOFONT)
2284 {
2285 font = gui.bold_font;
2286 hl_mask_todo &= ~(HL_BOLD | HL_STANDOUT);
2287 }
2288 else
2289 font = gui.norm_font;
2290 }
2291 else if ((hl_mask_todo & HL_ITALIC) && gui.ital_font != NOFONT)
2292 {
2293 font = gui.ital_font;
2294 hl_mask_todo &= ~HL_ITALIC;
2295 }
2296 else
2297 font = gui.norm_font;
Bram Moolenaardb250522013-06-17 22:43:25 +02002298
2299# ifdef FEAT_MBYTE
2300 /*
2301 * Choose correct wide_font by font. wide_font should be set with font
2302 * at same time in above block. But it will make many "ifdef" nasty
2303 * blocks. So we do it here.
2304 */
2305 if (font == gui.boldital_font && gui.wide_boldital_font)
2306 wide_font = gui.wide_boldital_font;
2307 else if (font == gui.bold_font && gui.wide_bold_font)
2308 wide_font = gui.wide_bold_font;
2309 else if (font == gui.ital_font && gui.wide_ital_font)
2310 wide_font = gui.wide_ital_font;
2311 else if (font == gui.norm_font && gui.wide_font)
2312 wide_font = gui.wide_font;
2313# endif
2314
Bram Moolenaar071d4272004-06-13 20:20:40 +00002315 }
2316# ifdef FEAT_XFONTSET
2317 if (fontset != NOFONTSET)
2318 gui_mch_set_fontset(fontset);
2319 else
2320# endif
2321 gui_mch_set_font(font);
2322#endif
2323
2324 draw_flags = 0;
2325
2326 /* Set the color */
2327 bg_color = gui.back_pixel;
2328 if ((flags & GUI_MON_IS_CURSOR) && gui.in_focus)
2329 {
2330 draw_flags |= DRAW_CURSOR;
2331 fg_color = fg;
2332 bg_color = bg;
Bram Moolenaar3918c952005-03-15 22:34:55 +00002333 sp_color = fg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002334 }
2335 else if (aep != NULL)
2336 {
2337 fg_color = aep->ae_u.gui.fg_color;
2338 if (fg_color == INVALCOLOR)
2339 fg_color = gui.norm_pixel;
2340 bg_color = aep->ae_u.gui.bg_color;
2341 if (bg_color == INVALCOLOR)
2342 bg_color = gui.back_pixel;
Bram Moolenaar3918c952005-03-15 22:34:55 +00002343 sp_color = aep->ae_u.gui.sp_color;
2344 if (sp_color == INVALCOLOR)
2345 sp_color = fg_color;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002346 }
2347 else
Bram Moolenaar3918c952005-03-15 22:34:55 +00002348 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002349 fg_color = gui.norm_pixel;
Bram Moolenaar3918c952005-03-15 22:34:55 +00002350 sp_color = fg_color;
2351 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002352
2353 if (highlight_mask & (HL_INVERSE | HL_STANDOUT))
2354 {
Bram Moolenaare60acc12011-05-10 16:41:25 +02002355#if defined(AMIGA)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002356 gui_mch_set_colors(bg_color, fg_color);
2357#else
2358 gui_mch_set_fg_color(bg_color);
2359 gui_mch_set_bg_color(fg_color);
2360#endif
2361 }
2362 else
2363 {
Bram Moolenaare60acc12011-05-10 16:41:25 +02002364#if defined(AMIGA)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002365 gui_mch_set_colors(fg_color, bg_color);
2366#else
2367 gui_mch_set_fg_color(fg_color);
2368 gui_mch_set_bg_color(bg_color);
2369#endif
2370 }
Bram Moolenaar3918c952005-03-15 22:34:55 +00002371 gui_mch_set_sp_color(sp_color);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002372
2373 /* Clear the selection if we are about to write over it */
2374 if (!(flags & GUI_MON_NOCLEAR))
2375 clip_may_clear_selection(gui.row, gui.row);
2376
2377
Bram Moolenaar071d4272004-06-13 20:20:40 +00002378 /* If there's no bold font, then fake it */
2379 if (hl_mask_todo & (HL_BOLD | HL_STANDOUT))
2380 draw_flags |= DRAW_BOLD;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002381
2382 /*
2383 * When drawing bold or italic characters the spill-over from the left
2384 * neighbor may be destroyed. Let the caller backup to start redrawing
2385 * just after a blank.
2386 */
2387 if (back != 0 && ((draw_flags & DRAW_BOLD) || (highlight_mask & HL_ITALIC)))
2388 return FAIL;
2389
Bram Moolenaare60acc12011-05-10 16:41:25 +02002390#if defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002391 /* If there's no italic font, then fake it.
2392 * For GTK2, we don't need a different font for italic style. */
2393 if (hl_mask_todo & HL_ITALIC)
2394 draw_flags |= DRAW_ITALIC;
2395
2396 /* Do we underline the text? */
2397 if (hl_mask_todo & HL_UNDERLINE)
2398 draw_flags |= DRAW_UNDERL;
2399#else
2400 /* Do we underline the text? */
Bram Moolenaarcf7164a2016-02-20 13:55:06 +01002401 if ((hl_mask_todo & HL_UNDERLINE) || (hl_mask_todo & HL_ITALIC))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002402 draw_flags |= DRAW_UNDERL;
2403#endif
Bram Moolenaar3918c952005-03-15 22:34:55 +00002404 /* Do we undercurl the text? */
2405 if (hl_mask_todo & HL_UNDERCURL)
2406 draw_flags |= DRAW_UNDERC;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002407
Bram Moolenaarff1d0d42007-05-10 17:24:16 +00002408 /* Do we draw transparently? */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002409 if (flags & GUI_MON_TRS_CURSOR)
2410 draw_flags |= DRAW_TRANSP;
2411
2412 /*
2413 * Draw the text.
2414 */
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02002415#ifdef FEAT_GUI_GTK
Bram Moolenaar071d4272004-06-13 20:20:40 +00002416 /* The value returned is the length in display cells */
2417 len = gui_gtk2_draw_string(gui.row, col, s, len, draw_flags);
2418#else
2419# ifdef FEAT_MBYTE
2420 if (enc_utf8)
2421 {
2422 int start; /* index of bytes to be drawn */
2423 int cells; /* cellwidth of bytes to be drawn */
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02002424 int thislen; /* length of bytes to be drawn */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002425 int cn; /* cellwidth of current char */
2426 int i; /* index of current char */
2427 int c; /* current char value */
2428 int cl; /* byte length of current char */
2429 int comping; /* current char is composing */
2430 int scol = col; /* screen column */
Bram Moolenaar45933962013-01-23 17:43:57 +01002431 int curr_wide; /* use 'guifontwide' */
2432 int prev_wide = FALSE;
2433 int wide_changed;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002434
2435 /* Break the string at a composing character, it has to be drawn on
2436 * top of the previous character. */
2437 start = 0;
2438 cells = 0;
2439 for (i = 0; i < len; i += cl)
2440 {
2441 c = utf_ptr2char(s + i);
2442 cn = utf_char2cells(c);
2443 if (cn > 1
2444# ifdef FEAT_XFONTSET
2445 && fontset == NOFONTSET
2446# endif
Bram Moolenaardb250522013-06-17 22:43:25 +02002447 && wide_font != NOFONT)
Bram Moolenaar45933962013-01-23 17:43:57 +01002448 curr_wide = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002449 else
Bram Moolenaar45933962013-01-23 17:43:57 +01002450 curr_wide = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002451 comping = utf_iscomposing(c);
2452 if (!comping) /* count cells from non-composing chars */
2453 cells += cn;
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00002454 cl = utf_ptr2len(s + i);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002455 if (cl == 0) /* hit end of string */
2456 len = i + cl; /* len must be wrong "cannot happen" */
2457
Bram Moolenaar45933962013-01-23 17:43:57 +01002458 wide_changed = curr_wide != prev_wide;
2459
2460 /* Print the string so far if it's the last character or there is
Bram Moolenaar071d4272004-06-13 20:20:40 +00002461 * a composing character. */
Bram Moolenaar45933962013-01-23 17:43:57 +01002462 if (i + cl >= len || (comping && i > start) || wide_changed
Bram Moolenaar182c5be2010-06-25 05:37:59 +02002463# if defined(FEAT_GUI_X11)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002464 || (cn > 1
2465# ifdef FEAT_XFONTSET
2466 /* No fontset: At least draw char after wide char at
2467 * right position. */
2468 && fontset == NOFONTSET
2469# endif
2470 )
2471# endif
2472 )
2473 {
Bram Moolenaar45933962013-01-23 17:43:57 +01002474 if (comping || wide_changed)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002475 thislen = i - start;
2476 else
2477 thislen = i - start + cl;
2478 if (thislen > 0)
2479 {
Bram Moolenaar45933962013-01-23 17:43:57 +01002480 if (prev_wide)
Bram Moolenaardb250522013-06-17 22:43:25 +02002481 gui_mch_set_font(wide_font);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002482 gui_mch_draw_string(gui.row, scol, s + start, thislen,
2483 draw_flags);
Bram Moolenaar45933962013-01-23 17:43:57 +01002484 if (prev_wide)
2485 gui_mch_set_font(font);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002486 start += thislen;
2487 }
2488 scol += cells;
2489 cells = 0;
Bram Moolenaar45933962013-01-23 17:43:57 +01002490 /* Adjust to not draw a character which width is changed
2491 * against with last one. */
2492 if (wide_changed && !comping)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002493 {
Bram Moolenaar45933962013-01-23 17:43:57 +01002494 scol -= cn;
2495 cl = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002496 }
2497
Bram Moolenaar182c5be2010-06-25 05:37:59 +02002498# if defined(FEAT_GUI_X11)
Bram Moolenaar843ee412004-06-30 16:16:41 +00002499 /* No fontset: draw a space to fill the gap after a wide char
2500 * */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002501 if (cn > 1 && (draw_flags & DRAW_TRANSP) == 0
2502# ifdef FEAT_XFONTSET
2503 && fontset == NOFONTSET
2504# endif
Bram Moolenaar45933962013-01-23 17:43:57 +01002505 && !wide_changed)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002506 gui_mch_draw_string(gui.row, scol - 1, (char_u *)" ",
2507 1, draw_flags);
2508# endif
2509 }
2510 /* Draw a composing char on top of the previous char. */
2511 if (comping)
2512 {
Bram Moolenaarf25fd512005-09-30 21:15:37 +00002513# if (defined(__APPLE_CC__) || defined(__MRC__)) && TARGET_API_MAC_CARBON
Bram Moolenaarfd91ecb2005-03-07 23:06:25 +00002514 /* Carbon ATSUI autodraws composing char over previous char */
2515 gui_mch_draw_string(gui.row, scol, s + i, cl,
2516 draw_flags | DRAW_TRANSP);
Bram Moolenaarf25fd512005-09-30 21:15:37 +00002517# else
2518 gui_mch_draw_string(gui.row, scol - cn, s + i, cl,
2519 draw_flags | DRAW_TRANSP);
Bram Moolenaarfd91ecb2005-03-07 23:06:25 +00002520# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002521 start = i + cl;
2522 }
Bram Moolenaar45933962013-01-23 17:43:57 +01002523 prev_wide = curr_wide;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002524 }
2525 /* The stuff below assumes "len" is the length in screen columns. */
2526 len = scol - col;
2527 }
2528 else
2529# endif
2530 {
2531 gui_mch_draw_string(gui.row, col, s, len, draw_flags);
2532# ifdef FEAT_MBYTE
2533 if (enc_dbcs == DBCS_JPNU)
2534 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002535 /* Get the length in display cells, this can be different from the
2536 * number of bytes for "euc-jp". */
Bram Moolenaar72597a52010-07-18 15:31:08 +02002537 len = mb_string2cells(s, len);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002538 }
2539# endif
2540 }
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02002541#endif /* !FEAT_GUI_GTK */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002542
2543 if (!(flags & (GUI_MON_IS_CURSOR | GUI_MON_TRS_CURSOR)))
2544 gui.col = col + len;
2545
2546 /* May need to invert it when it's part of the selection. */
2547 if (flags & GUI_MON_NOCLEAR)
2548 clip_may_redraw_selection(gui.row, col, len);
2549
2550 if (!(flags & (GUI_MON_IS_CURSOR | GUI_MON_TRS_CURSOR)))
2551 {
2552 /* Invalidate the old physical cursor position if we wrote over it */
2553 if (gui.cursor_row == gui.row
2554 && gui.cursor_col >= col
2555 && gui.cursor_col < col + len)
2556 gui.cursor_is_valid = FALSE;
2557 }
2558
2559#ifdef FEAT_SIGN_ICONS
2560 if (draw_sign)
2561 /* Draw the sign on top of the spaces. */
2562 gui_mch_drawsign(gui.row, col, gui.highlight_mask);
Bram Moolenaar173c9852010-09-29 17:27:01 +02002563# if defined(FEAT_NETBEANS_INTG) && (defined(FEAT_GUI_X11) \
Bram Moolenaar67c53842010-05-22 18:28:27 +02002564 || defined(FEAT_GUI_GTK) || defined(FEAT_GUI_W32))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002565 if (multi_sign)
2566 netbeans_draw_multisign_indicator(gui.row);
2567# endif
2568#endif
2569
2570 return OK;
2571}
2572
2573/*
2574 * Un-draw the cursor. Actually this just redraws the character at the given
2575 * position. The character just before it too, for when it was in bold.
2576 */
2577 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01002578gui_undraw_cursor(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002579{
2580 if (gui.cursor_is_valid)
2581 {
2582#ifdef FEAT_HANGULIN
2583 if (composing_hangul
2584 && gui.col == gui.cursor_col && gui.row == gui.cursor_row)
Bram Moolenaar72f4cc42015-11-10 14:35:18 +01002585 {
2586 char_u *comp_buf;
2587 int comp_len;
2588
2589 comp_buf = hangul_composing_buffer_get(&comp_len);
2590 if (comp_buf)
2591 {
2592 (void)gui_outstr_nowrap(comp_buf, comp_len,
2593 GUI_MON_IS_CURSOR | GUI_MON_NOCLEAR,
2594 gui.norm_pixel, gui.back_pixel, 0);
2595 vim_free(comp_buf);
2596 }
2597 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002598 else
2599 {
2600#endif
2601 if (gui_redraw_block(gui.cursor_row, gui.cursor_col,
2602 gui.cursor_row, gui.cursor_col, GUI_MON_NOCLEAR)
2603 && gui.cursor_col > 0)
2604 (void)gui_redraw_block(gui.cursor_row, gui.cursor_col - 1,
2605 gui.cursor_row, gui.cursor_col - 1, GUI_MON_NOCLEAR);
2606#ifdef FEAT_HANGULIN
2607 if (composing_hangul)
2608 (void)gui_redraw_block(gui.cursor_row, gui.cursor_col + 1,
2609 gui.cursor_row, gui.cursor_col + 1, GUI_MON_NOCLEAR);
2610 }
2611#endif
2612 /* Cursor_is_valid is reset when the cursor is undrawn, also reset it
2613 * here in case it wasn't needed to undraw it. */
2614 gui.cursor_is_valid = FALSE;
2615 }
2616}
2617
2618 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01002619gui_redraw(
2620 int x,
2621 int y,
2622 int w,
2623 int h)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002624{
2625 int row1, col1, row2, col2;
2626
2627 row1 = Y_2_ROW(y);
2628 col1 = X_2_COL(x);
2629 row2 = Y_2_ROW(y + h - 1);
2630 col2 = X_2_COL(x + w - 1);
2631
2632 (void)gui_redraw_block(row1, col1, row2, col2, GUI_MON_NOCLEAR);
2633
2634 /*
2635 * We may need to redraw the cursor, but don't take it upon us to change
2636 * its location after a scroll.
2637 * (maybe be more strict even and test col too?)
2638 * These things may be outside the update/clipping region and reality may
2639 * not reflect Vims internal ideas if these operations are clipped away.
2640 */
2641 if (gui.row == gui.cursor_row)
2642 gui_update_cursor(TRUE, TRUE);
2643}
2644
2645/*
2646 * Draw a rectangular block of characters, from row1 to row2 (inclusive) and
2647 * from col1 to col2 (inclusive).
2648 * Return TRUE when the character before the first drawn character has
2649 * different attributes (may have to be redrawn too).
2650 */
2651 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01002652gui_redraw_block(
2653 int row1,
2654 int col1,
2655 int row2,
2656 int col2,
2657 int flags) /* flags for gui_outstr_nowrap() */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002658{
2659 int old_row, old_col;
2660 long_u old_hl_mask;
2661 int off;
Bram Moolenaar3918c952005-03-15 22:34:55 +00002662 sattr_T first_attr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002663 int idx, len;
2664 int back, nback;
2665 int retval = FALSE;
2666#ifdef FEAT_MBYTE
2667 int orig_col1, orig_col2;
2668#endif
2669
2670 /* Don't try to update when ScreenLines is not valid */
2671 if (!screen_cleared || ScreenLines == NULL)
2672 return retval;
2673
2674 /* Don't try to draw outside the shell! */
2675 /* Check everything, strange values may be caused by a big border width */
2676 col1 = check_col(col1);
2677 col2 = check_col(col2);
2678 row1 = check_row(row1);
2679 row2 = check_row(row2);
2680
2681 /* Remember where our cursor was */
2682 old_row = gui.row;
2683 old_col = gui.col;
2684 old_hl_mask = gui.highlight_mask;
2685#ifdef FEAT_MBYTE
2686 orig_col1 = col1;
2687 orig_col2 = col2;
2688#endif
2689
2690 for (gui.row = row1; gui.row <= row2; gui.row++)
2691 {
2692#ifdef FEAT_MBYTE
2693 /* When only half of a double-wide character is in the block, include
2694 * the other half. */
2695 col1 = orig_col1;
2696 col2 = orig_col2;
2697 off = LineOffset[gui.row];
2698 if (enc_dbcs != 0)
2699 {
2700 if (col1 > 0)
2701 col1 -= dbcs_screen_head_off(ScreenLines + off,
2702 ScreenLines + off + col1);
2703 col2 += dbcs_screen_tail_off(ScreenLines + off,
2704 ScreenLines + off + col2);
2705 }
2706 else if (enc_utf8)
2707 {
2708 if (ScreenLines[off + col1] == 0)
2709 --col1;
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02002710# ifdef FEAT_GUI_GTK
Bram Moolenaar071d4272004-06-13 20:20:40 +00002711 if (col2 + 1 < Columns && ScreenLines[off + col2 + 1] == 0)
2712 ++col2;
2713# endif
2714 }
2715#endif
2716 gui.col = col1;
2717 off = LineOffset[gui.row] + gui.col;
2718 len = col2 - col1 + 1;
2719
2720 /* Find how many chars back this highlighting starts, or where a space
2721 * is. Needed for when the bold trick is used */
2722 for (back = 0; back < col1; ++back)
2723 if (ScreenAttrs[off - 1 - back] != ScreenAttrs[off]
2724 || ScreenLines[off - 1 - back] == ' ')
2725 break;
2726 retval = (col1 > 0 && ScreenAttrs[off - 1] != 0 && back == 0
2727 && ScreenLines[off - 1] != ' ');
2728
2729 /* Break it up in strings of characters with the same attributes. */
2730 /* Print UTF-8 characters individually. */
2731 while (len > 0)
2732 {
2733 first_attr = ScreenAttrs[off];
2734 gui.highlight_mask = first_attr;
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02002735#if defined(FEAT_MBYTE) && !defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002736 if (enc_utf8 && ScreenLinesUC[off] != 0)
2737 {
2738 /* output multi-byte character separately */
2739 nback = gui_screenchar(off, flags,
2740 (guicolor_T)0, (guicolor_T)0, back);
2741 if (gui.col < Columns && ScreenLines[off + 1] == 0)
2742 idx = 2;
2743 else
2744 idx = 1;
2745 }
2746 else if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e)
2747 {
2748 /* output double-byte, single-width character separately */
2749 nback = gui_screenchar(off, flags,
2750 (guicolor_T)0, (guicolor_T)0, back);
2751 idx = 1;
2752 }
2753 else
2754#endif
2755 {
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02002756#ifdef FEAT_GUI_GTK
Bram Moolenaar071d4272004-06-13 20:20:40 +00002757 for (idx = 0; idx < len; ++idx)
2758 {
2759 if (enc_utf8 && ScreenLines[off + idx] == 0)
2760 continue; /* skip second half of double-width char */
2761 if (ScreenAttrs[off + idx] != first_attr)
2762 break;
2763 }
2764 /* gui_screenstr() takes care of multibyte chars */
2765 nback = gui_screenstr(off, idx, flags,
2766 (guicolor_T)0, (guicolor_T)0, back);
2767#else
2768 for (idx = 0; idx < len && ScreenAttrs[off + idx] == first_attr;
2769 idx++)
2770 {
2771# ifdef FEAT_MBYTE
2772 /* Stop at a multi-byte Unicode character. */
2773 if (enc_utf8 && ScreenLinesUC[off + idx] != 0)
2774 break;
2775 if (enc_dbcs == DBCS_JPNU)
2776 {
2777 /* Stop at a double-byte single-width char. */
2778 if (ScreenLines[off + idx] == 0x8e)
2779 break;
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00002780 if (len > 1 && (*mb_ptr2len)(ScreenLines
Bram Moolenaar071d4272004-06-13 20:20:40 +00002781 + off + idx) == 2)
2782 ++idx; /* skip second byte of double-byte char */
2783 }
2784# endif
2785 }
2786 nback = gui_outstr_nowrap(ScreenLines + off, idx, flags,
2787 (guicolor_T)0, (guicolor_T)0, back);
2788#endif
2789 }
2790 if (nback == FAIL)
2791 {
2792 /* Must back up to start drawing where a bold or italic word
2793 * starts. */
2794 off -= back;
2795 len += back;
2796 gui.col -= back;
2797 }
2798 else
2799 {
2800 off += idx;
2801 len -= idx;
2802 }
2803 back = 0;
2804 }
2805 }
2806
2807 /* Put the cursor back where it was */
2808 gui.row = old_row;
2809 gui.col = old_col;
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00002810 gui.highlight_mask = (int)old_hl_mask;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002811
2812 return retval;
2813}
2814
2815 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01002816gui_delete_lines(int row, int count)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002817{
2818 if (count <= 0)
2819 return;
2820
2821 if (row + count > gui.scroll_region_bot)
2822 /* Scrolled out of region, just blank the lines out */
2823 gui_clear_block(row, gui.scroll_region_left,
2824 gui.scroll_region_bot, gui.scroll_region_right);
2825 else
2826 {
2827 gui_mch_delete_lines(row, count);
2828
2829 /* If the cursor was in the deleted lines it's now gone. If the
2830 * cursor was in the scrolled lines adjust its position. */
2831 if (gui.cursor_row >= row
2832 && gui.cursor_col >= gui.scroll_region_left
2833 && gui.cursor_col <= gui.scroll_region_right)
2834 {
2835 if (gui.cursor_row < row + count)
2836 gui.cursor_is_valid = FALSE;
2837 else if (gui.cursor_row <= gui.scroll_region_bot)
2838 gui.cursor_row -= count;
2839 }
2840 }
2841}
2842
2843 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01002844gui_insert_lines(int row, int count)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002845{
2846 if (count <= 0)
2847 return;
2848
2849 if (row + count > gui.scroll_region_bot)
2850 /* Scrolled out of region, just blank the lines out */
2851 gui_clear_block(row, gui.scroll_region_left,
2852 gui.scroll_region_bot, gui.scroll_region_right);
2853 else
2854 {
2855 gui_mch_insert_lines(row, count);
2856
2857 if (gui.cursor_row >= gui.row
2858 && gui.cursor_col >= gui.scroll_region_left
2859 && gui.cursor_col <= gui.scroll_region_right)
2860 {
2861 if (gui.cursor_row <= gui.scroll_region_bot - count)
2862 gui.cursor_row += count;
2863 else if (gui.cursor_row <= gui.scroll_region_bot)
2864 gui.cursor_is_valid = FALSE;
2865 }
2866 }
2867}
2868
Bram Moolenaar9472eec2017-06-05 13:31:56 +02002869/*
2870 * Returns OK if a character was found to be available within the given time,
2871 * or FAIL otherwise.
2872 */
Bram Moolenaar975b5272016-03-15 23:10:59 +01002873 static int
2874gui_wait_for_chars_or_timer(long wtime)
2875{
2876#ifdef FEAT_TIMERS
2877 int due_time;
2878 long remaining = wtime;
Bram Moolenaar40b1b542016-04-20 20:18:23 +02002879 int tb_change_cnt = typebuf.tb_change_cnt;
Bram Moolenaar975b5272016-03-15 23:10:59 +01002880
2881 /* When waiting very briefly don't trigger timers. */
2882 if (wtime >= 0 && wtime < 10L)
2883 return gui_mch_wait_for_chars(wtime);
2884
2885 while (wtime < 0 || remaining > 0)
2886 {
2887 /* Trigger timers and then get the time in wtime until the next one is
2888 * due. Wait up to that time. */
2889 due_time = check_due_timer();
Bram Moolenaar40b1b542016-04-20 20:18:23 +02002890 if (typebuf.tb_change_cnt != tb_change_cnt)
2891 {
2892 /* timer may have used feedkeys() */
Bram Moolenaar9472eec2017-06-05 13:31:56 +02002893 return FAIL;
Bram Moolenaar40b1b542016-04-20 20:18:23 +02002894 }
Bram Moolenaar975b5272016-03-15 23:10:59 +01002895 if (due_time <= 0 || (wtime > 0 && due_time > remaining))
2896 due_time = remaining;
2897 if (gui_mch_wait_for_chars(due_time))
Bram Moolenaar9472eec2017-06-05 13:31:56 +02002898 return OK;
Bram Moolenaar975b5272016-03-15 23:10:59 +01002899 if (wtime > 0)
2900 remaining -= due_time;
2901 }
Bram Moolenaar9472eec2017-06-05 13:31:56 +02002902 return FAIL;
Bram Moolenaar975b5272016-03-15 23:10:59 +01002903#else
2904 return gui_mch_wait_for_chars(wtime);
2905#endif
2906}
2907
Bram Moolenaar071d4272004-06-13 20:20:40 +00002908/*
2909 * The main GUI input routine. Waits for a character from the keyboard.
2910 * wtime == -1 Wait forever.
2911 * wtime == 0 Don't wait.
2912 * wtime > 0 Wait wtime milliseconds for a character.
2913 * Returns OK if a character was found to be available within the given time,
2914 * or FAIL otherwise.
2915 */
2916 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01002917gui_wait_for_chars(long wtime)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002918{
2919 int retval;
Bram Moolenaar9472eec2017-06-05 13:31:56 +02002920 int tb_change_cnt = typebuf.tb_change_cnt;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002921
Bram Moolenaarca7e1f22010-05-22 15:50:12 +02002922#ifdef FEAT_MENU
Bram Moolenaar071d4272004-06-13 20:20:40 +00002923 /*
2924 * If we're going to wait a bit, update the menus and mouse shape for the
2925 * current State.
2926 */
2927 if (wtime != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002928 gui_update_menus(0);
2929#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002930
2931 gui_mch_update();
2932 if (input_available()) /* Got char, return immediately */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002933 return OK;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002934 if (wtime == 0) /* Don't wait for char */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002935 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002936
2937 /* Before waiting, flush any output to the screen. */
2938 gui_mch_flush();
2939
2940 if (wtime > 0)
2941 {
2942 /* Blink when waiting for a character. Probably only does something
2943 * for showmatch() */
2944 gui_mch_start_blink();
Bram Moolenaar975b5272016-03-15 23:10:59 +01002945 retval = gui_wait_for_chars_or_timer(wtime);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002946 gui_mch_stop_blink();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002947 return retval;
2948 }
2949
2950 /*
Bram Moolenaarff1d0d42007-05-10 17:24:16 +00002951 * While we are waiting indefinitely for a character, blink the cursor.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002952 */
2953 gui_mch_start_blink();
2954
Bram Moolenaar3918c952005-03-15 22:34:55 +00002955 retval = FAIL;
2956 /*
2957 * We may want to trigger the CursorHold event. First wait for
2958 * 'updatetime' and if nothing is typed within that time put the
2959 * K_CURSORHOLD key in the input buffer.
2960 */
Bram Moolenaar975b5272016-03-15 23:10:59 +01002961 if (gui_wait_for_chars_or_timer(p_ut) == OK)
Bram Moolenaar3918c952005-03-15 22:34:55 +00002962 retval = OK;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002963#ifdef FEAT_AUTOCMD
Bram Moolenaard35f9712005-12-18 22:02:33 +00002964 else if (trigger_cursorhold())
Bram Moolenaar071d4272004-06-13 20:20:40 +00002965 {
Bram Moolenaar3918c952005-03-15 22:34:55 +00002966 char_u buf[3];
2967
2968 /* Put K_CURSORHOLD in the input buffer. */
2969 buf[0] = CSI;
2970 buf[1] = KS_EXTRA;
2971 buf[2] = (int)KE_CURSORHOLD;
2972 add_to_input_buf(buf, 3);
2973
2974 retval = OK;
2975 }
2976#endif
2977
Bram Moolenaar9472eec2017-06-05 13:31:56 +02002978 if (retval == FAIL && typebuf.tb_change_cnt == tb_change_cnt)
Bram Moolenaar3918c952005-03-15 22:34:55 +00002979 {
2980 /* Blocking wait. */
Bram Moolenaar702517d2005-06-27 22:34:07 +00002981 before_blocking();
Bram Moolenaar975b5272016-03-15 23:10:59 +01002982 retval = gui_wait_for_chars_or_timer(-1L);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002983 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002984
2985 gui_mch_stop_blink();
2986 return retval;
2987}
2988
2989/*
Bram Moolenaarb5dd4242007-05-06 12:28:24 +00002990 * Fill p[4] with mouse coordinates encoded for check_termcode().
Bram Moolenaar071d4272004-06-13 20:20:40 +00002991 */
2992 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01002993fill_mouse_coord(char_u *p, int col, int row)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002994{
2995 p[0] = (char_u)(col / 128 + ' ' + 1);
2996 p[1] = (char_u)(col % 128 + ' ' + 1);
2997 p[2] = (char_u)(row / 128 + ' ' + 1);
2998 p[3] = (char_u)(row % 128 + ' ' + 1);
2999}
3000
3001/*
3002 * Generic mouse support function. Add a mouse event to the input buffer with
3003 * the given properties.
3004 * button --- may be any of MOUSE_LEFT, MOUSE_MIDDLE, MOUSE_RIGHT,
3005 * MOUSE_X1, MOUSE_X2
3006 * MOUSE_DRAG, or MOUSE_RELEASE.
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02003007 * MOUSE_4 and MOUSE_5 are used for vertical scroll wheel,
3008 * MOUSE_6 and MOUSE_7 for horizontal scroll wheel.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003009 * x, y --- Coordinates of mouse in pixels.
3010 * repeated_click --- TRUE if this click comes only a short time after a
3011 * previous click.
3012 * modifiers --- Bit field which may be any of the following modifiers
3013 * or'ed together: MOUSE_SHIFT | MOUSE_CTRL | MOUSE_ALT.
3014 * This function will ignore drag events where the mouse has not moved to a new
3015 * character.
3016 */
3017 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01003018gui_send_mouse_event(
3019 int button,
3020 int x,
3021 int y,
3022 int repeated_click,
3023 int_u modifiers)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003024{
3025 static int prev_row = 0, prev_col = 0;
3026 static int prev_button = -1;
3027 static int num_clicks = 1;
3028 char_u string[10];
3029 enum key_extra button_char;
3030 int row, col;
3031#ifdef FEAT_CLIPBOARD
3032 int checkfor;
3033 int did_clip = FALSE;
3034#endif
3035
3036 /*
3037 * Scrolling may happen at any time, also while a selection is present.
3038 */
3039 switch (button)
3040 {
3041 case MOUSE_X1:
3042 button_char = KE_X1MOUSE;
3043 goto button_set;
3044 case MOUSE_X2:
3045 button_char = KE_X2MOUSE;
3046 goto button_set;
3047 case MOUSE_4:
3048 button_char = KE_MOUSEDOWN;
3049 goto button_set;
3050 case MOUSE_5:
3051 button_char = KE_MOUSEUP;
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02003052 goto button_set;
3053 case MOUSE_6:
3054 button_char = KE_MOUSELEFT;
3055 goto button_set;
3056 case MOUSE_7:
3057 button_char = KE_MOUSERIGHT;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003058button_set:
3059 {
3060 /* Don't put events in the input queue now. */
3061 if (hold_gui_events)
3062 return;
3063
3064 string[3] = CSI;
3065 string[4] = KS_EXTRA;
3066 string[5] = (int)button_char;
3067
3068 /* Pass the pointer coordinates of the scroll event so that we
3069 * know which window to scroll. */
3070 row = gui_xy2colrow(x, y, &col);
3071 string[6] = (char_u)(col / 128 + ' ' + 1);
3072 string[7] = (char_u)(col % 128 + ' ' + 1);
3073 string[8] = (char_u)(row / 128 + ' ' + 1);
3074 string[9] = (char_u)(row % 128 + ' ' + 1);
3075
3076 if (modifiers == 0)
3077 add_to_input_buf(string + 3, 7);
3078 else
3079 {
3080 string[0] = CSI;
3081 string[1] = KS_MODIFIER;
3082 string[2] = 0;
3083 if (modifiers & MOUSE_SHIFT)
3084 string[2] |= MOD_MASK_SHIFT;
3085 if (modifiers & MOUSE_CTRL)
3086 string[2] |= MOD_MASK_CTRL;
3087 if (modifiers & MOUSE_ALT)
3088 string[2] |= MOD_MASK_ALT;
3089 add_to_input_buf(string, 10);
3090 }
3091 return;
3092 }
3093 }
3094
3095#ifdef FEAT_CLIPBOARD
3096 /* If a clipboard selection is in progress, handle it */
3097 if (clip_star.state == SELECT_IN_PROGRESS)
3098 {
3099 clip_process_selection(button, X_2_COL(x), Y_2_ROW(y), repeated_click);
3100 return;
3101 }
3102
3103 /* Determine which mouse settings to look for based on the current mode */
3104 switch (get_real_state())
3105 {
3106 case NORMAL_BUSY:
3107 case OP_PENDING:
3108 case NORMAL: checkfor = MOUSE_NORMAL; break;
3109 case VISUAL: checkfor = MOUSE_VISUAL; break;
Bram Moolenaar371d5402006-03-20 21:47:49 +00003110 case SELECTMODE: checkfor = MOUSE_VISUAL; break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003111 case REPLACE:
3112 case REPLACE+LANGMAP:
3113#ifdef FEAT_VREPLACE
3114 case VREPLACE:
3115 case VREPLACE+LANGMAP:
3116#endif
3117 case INSERT:
3118 case INSERT+LANGMAP: checkfor = MOUSE_INSERT; break;
3119 case ASKMORE:
3120 case HITRETURN: /* At the more- and hit-enter prompt pass the
3121 mouse event for a click on or below the
3122 message line. */
3123 if (Y_2_ROW(y) >= msg_row)
3124 checkfor = MOUSE_NORMAL;
3125 else
3126 checkfor = MOUSE_RETURN;
3127 break;
3128
3129 /*
3130 * On the command line, use the clipboard selection on all lines
3131 * but the command line. But not when pasting.
3132 */
3133 case CMDLINE:
3134 case CMDLINE+LANGMAP:
3135 if (Y_2_ROW(y) < cmdline_row && button != MOUSE_MIDDLE)
3136 checkfor = MOUSE_NONE;
3137 else
3138 checkfor = MOUSE_COMMAND;
3139 break;
3140
3141 default:
3142 checkfor = MOUSE_NONE;
3143 break;
3144 };
3145
3146 /*
3147 * Allow clipboard selection of text on the command line in "normal"
3148 * modes. Don't do this when dragging the status line, or extending a
3149 * Visual selection.
3150 */
3151 if ((State == NORMAL || State == NORMAL_BUSY || (State & INSERT))
3152 && Y_2_ROW(y) >= topframe->fr_height
Bram Moolenaar8838aee2006-10-08 11:56:24 +00003153# ifdef FEAT_WINDOWS
3154 + firstwin->w_winrow
3155# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003156 && button != MOUSE_DRAG
3157# ifdef FEAT_MOUSESHAPE
3158 && !drag_status_line
Bram Moolenaar44a2f922016-03-19 22:11:51 +01003159# ifdef FEAT_WINDOWS
Bram Moolenaar071d4272004-06-13 20:20:40 +00003160 && !drag_sep_line
3161# endif
3162# endif
3163 )
3164 checkfor = MOUSE_NONE;
3165
3166 /*
3167 * Use modeless selection when holding CTRL and SHIFT pressed.
3168 */
3169 if ((modifiers & MOUSE_CTRL) && (modifiers & MOUSE_SHIFT))
3170 checkfor = MOUSE_NONEF;
3171
3172 /*
3173 * In Ex mode, always use modeless selection.
3174 */
3175 if (exmode_active)
3176 checkfor = MOUSE_NONE;
3177
3178 /*
3179 * If the mouse settings say to not use the mouse, use the modeless
3180 * selection. But if Visual is active, assume that only the Visual area
3181 * will be selected.
3182 * Exception: On the command line, both the selection is used and a mouse
3183 * key is send.
3184 */
3185 if (!mouse_has(checkfor) || checkfor == MOUSE_COMMAND)
3186 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00003187 /* Don't do modeless selection in Visual mode. */
3188 if (checkfor != MOUSE_NONEF && VIsual_active && (State & NORMAL))
3189 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003190
3191 /*
3192 * When 'mousemodel' is "popup", shift-left is translated to right.
3193 * But not when also using Ctrl.
3194 */
3195 if (mouse_model_popup() && button == MOUSE_LEFT
3196 && (modifiers & MOUSE_SHIFT) && !(modifiers & MOUSE_CTRL))
3197 {
3198 button = MOUSE_RIGHT;
3199 modifiers &= ~ MOUSE_SHIFT;
3200 }
3201
3202 /* If the selection is done, allow the right button to extend it.
3203 * If the selection is cleared, allow the right button to start it
3204 * from the cursor position. */
3205 if (button == MOUSE_RIGHT)
3206 {
3207 if (clip_star.state == SELECT_CLEARED)
3208 {
3209 if (State & CMDLINE)
3210 {
3211 col = msg_col;
3212 row = msg_row;
3213 }
3214 else
3215 {
3216 col = curwin->w_wcol;
3217 row = curwin->w_wrow + W_WINROW(curwin);
3218 }
3219 clip_start_selection(col, row, FALSE);
3220 }
3221 clip_process_selection(button, X_2_COL(x), Y_2_ROW(y),
3222 repeated_click);
3223 did_clip = TRUE;
3224 }
3225 /* Allow the left button to start the selection */
Bram Moolenaare60acc12011-05-10 16:41:25 +02003226 else if (button == MOUSE_LEFT)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003227 {
3228 clip_start_selection(X_2_COL(x), Y_2_ROW(y), repeated_click);
3229 did_clip = TRUE;
3230 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003231
3232 /* Always allow pasting */
3233 if (button != MOUSE_MIDDLE)
3234 {
3235 if (!mouse_has(checkfor) || button == MOUSE_RELEASE)
3236 return;
3237 if (checkfor != MOUSE_COMMAND)
3238 button = MOUSE_LEFT;
3239 }
3240 repeated_click = FALSE;
3241 }
3242
3243 if (clip_star.state != SELECT_CLEARED && !did_clip)
Bram Moolenaarc0885aa2012-07-10 16:49:23 +02003244 clip_clear_selection(&clip_star);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003245#endif
3246
3247 /* Don't put events in the input queue now. */
3248 if (hold_gui_events)
3249 return;
3250
3251 row = gui_xy2colrow(x, y, &col);
3252
3253 /*
3254 * If we are dragging and the mouse hasn't moved far enough to be on a
3255 * different character, then don't send an event to vim.
3256 */
3257 if (button == MOUSE_DRAG)
3258 {
3259 if (row == prev_row && col == prev_col)
3260 return;
3261 /* Dragging above the window, set "row" to -1 to cause a scroll. */
3262 if (y < 0)
3263 row = -1;
3264 }
3265
3266 /*
3267 * If topline has changed (window scrolled) since the last click, reset
3268 * repeated_click, because we don't want starting Visual mode when
3269 * clicking on a different character in the text.
3270 */
3271 if (curwin->w_topline != gui_prev_topline
3272#ifdef FEAT_DIFF
3273 || curwin->w_topfill != gui_prev_topfill
3274#endif
3275 )
3276 repeated_click = FALSE;
3277
3278 string[0] = CSI; /* this sequence is recognized by check_termcode() */
3279 string[1] = KS_MOUSE;
3280 string[2] = KE_FILLER;
3281 if (button != MOUSE_DRAG && button != MOUSE_RELEASE)
3282 {
3283 if (repeated_click)
3284 {
3285 /*
3286 * Handle multiple clicks. They only count if the mouse is still
3287 * pointing at the same character.
3288 */
3289 if (button != prev_button || row != prev_row || col != prev_col)
3290 num_clicks = 1;
3291 else if (++num_clicks > 4)
3292 num_clicks = 1;
3293 }
3294 else
3295 num_clicks = 1;
3296 prev_button = button;
3297 gui_prev_topline = curwin->w_topline;
3298#ifdef FEAT_DIFF
3299 gui_prev_topfill = curwin->w_topfill;
3300#endif
3301
3302 string[3] = (char_u)(button | 0x20);
3303 SET_NUM_MOUSE_CLICKS(string[3], num_clicks);
3304 }
3305 else
3306 string[3] = (char_u)button;
3307
3308 string[3] |= modifiers;
3309 fill_mouse_coord(string + 4, col, row);
3310 add_to_input_buf(string, 8);
3311
3312 if (row < 0)
3313 prev_row = 0;
3314 else
3315 prev_row = row;
3316 prev_col = col;
3317
3318 /*
3319 * We need to make sure this is cleared since Athena doesn't tell us when
3320 * he is done dragging. Neither does GTK+ 2 -- at least for now.
3321 */
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02003322#if defined(FEAT_GUI_ATHENA) || defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003323 gui.dragged_sb = SBAR_NONE;
3324#endif
3325}
3326
3327/*
3328 * Convert x and y coordinate to column and row in text window.
3329 * Corrects for multi-byte character.
3330 * returns column in "*colp" and row as return value;
3331 */
3332 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01003333gui_xy2colrow(int x, int y, int *colp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003334{
3335 int col = check_col(X_2_COL(x));
3336 int row = check_row(Y_2_ROW(y));
3337
3338#ifdef FEAT_MBYTE
3339 *colp = mb_fix_col(col, row);
3340#else
3341 *colp = col;
3342#endif
3343 return row;
3344}
3345
3346#if defined(FEAT_MENU) || defined(PROTO)
3347/*
3348 * Callback function for when a menu entry has been selected.
3349 */
3350 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01003351gui_menu_cb(vimmenu_T *menu)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003352{
Bram Moolenaar110bc6b2006-02-10 23:13:40 +00003353 char_u bytes[sizeof(long_u)];
Bram Moolenaar071d4272004-06-13 20:20:40 +00003354
3355 /* Don't put events in the input queue now. */
3356 if (hold_gui_events)
3357 return;
3358
3359 bytes[0] = CSI;
3360 bytes[1] = KS_MENU;
3361 bytes[2] = KE_FILLER;
Bram Moolenaar110bc6b2006-02-10 23:13:40 +00003362 add_to_input_buf(bytes, 3);
3363 add_long_to_buf((long_u)menu, bytes);
3364 add_to_input_buf_csi(bytes, sizeof(long_u));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003365}
3366#endif
3367
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00003368static int prev_which_scrollbars[3];
Bram Moolenaare45828b2006-02-15 22:12:56 +00003369
Bram Moolenaar071d4272004-06-13 20:20:40 +00003370/*
3371 * Set which components are present.
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003372 * If "oldval" is not NULL, "oldval" is the previous value, the new value is
Bram Moolenaar071d4272004-06-13 20:20:40 +00003373 * in p_go.
3374 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003375 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01003376gui_init_which_components(char_u *oldval UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003377{
Bram Moolenaar071d4272004-06-13 20:20:40 +00003378#ifdef FEAT_MENU
3379 static int prev_menu_is_active = -1;
3380#endif
3381#ifdef FEAT_TOOLBAR
3382 static int prev_toolbar = -1;
3383 int using_toolbar = FALSE;
3384#endif
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003385#ifdef FEAT_GUI_TABLINE
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003386 int using_tabline;
3387#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003388#ifdef FEAT_FOOTER
3389 static int prev_footer = -1;
3390 int using_footer = FALSE;
3391#endif
Bram Moolenaarcf7164a2016-02-20 13:55:06 +01003392#if defined(FEAT_MENU)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003393 static int prev_tearoff = -1;
3394 int using_tearoff = FALSE;
3395#endif
3396
3397 char_u *p;
3398 int i;
3399#ifdef FEAT_MENU
3400 int grey_old, grey_new;
3401 char_u *temp;
3402#endif
3403 win_T *wp;
3404 int need_set_size;
3405 int fix_size;
3406
3407#ifdef FEAT_MENU
3408 if (oldval != NULL && gui.in_use)
3409 {
3410 /*
3411 * Check if the menu's go from grey to non-grey or vise versa.
3412 */
3413 grey_old = (vim_strchr(oldval, GO_GREY) != NULL);
3414 grey_new = (vim_strchr(p_go, GO_GREY) != NULL);
3415 if (grey_old != grey_new)
3416 {
3417 temp = p_go;
3418 p_go = oldval;
3419 gui_update_menus(MENU_ALL_MODES);
3420 p_go = temp;
3421 }
3422 }
3423 gui.menu_is_active = FALSE;
3424#endif
3425
3426 for (i = 0; i < 3; i++)
3427 gui.which_scrollbars[i] = FALSE;
3428 for (p = p_go; *p; p++)
3429 switch (*p)
3430 {
3431 case GO_LEFT:
3432 gui.which_scrollbars[SBAR_LEFT] = TRUE;
3433 break;
3434 case GO_RIGHT:
3435 gui.which_scrollbars[SBAR_RIGHT] = TRUE;
3436 break;
Bram Moolenaar44a2f922016-03-19 22:11:51 +01003437#ifdef FEAT_WINDOWS
Bram Moolenaar071d4272004-06-13 20:20:40 +00003438 case GO_VLEFT:
3439 if (win_hasvertsplit())
3440 gui.which_scrollbars[SBAR_LEFT] = TRUE;
3441 break;
3442 case GO_VRIGHT:
3443 if (win_hasvertsplit())
3444 gui.which_scrollbars[SBAR_RIGHT] = TRUE;
3445 break;
3446#endif
3447 case GO_BOT:
3448 gui.which_scrollbars[SBAR_BOTTOM] = TRUE;
3449 break;
3450#ifdef FEAT_MENU
3451 case GO_MENUS:
3452 gui.menu_is_active = TRUE;
3453 break;
3454#endif
3455 case GO_GREY:
3456 /* make menu's have grey items, ignored here */
3457 break;
3458#ifdef FEAT_TOOLBAR
3459 case GO_TOOLBAR:
3460 using_toolbar = TRUE;
3461 break;
3462#endif
3463#ifdef FEAT_FOOTER
3464 case GO_FOOTER:
3465 using_footer = TRUE;
3466 break;
3467#endif
3468 case GO_TEAROFF:
Bram Moolenaarcf7164a2016-02-20 13:55:06 +01003469#if defined(FEAT_MENU)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003470 using_tearoff = TRUE;
3471#endif
3472 break;
3473 default:
3474 /* Ignore options that are not supported */
3475 break;
3476 }
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003477
Bram Moolenaar071d4272004-06-13 20:20:40 +00003478 if (gui.in_use)
3479 {
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00003480 need_set_size = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003481 fix_size = FALSE;
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003482
3483#ifdef FEAT_GUI_TABLINE
Bram Moolenaarc542aef2006-02-25 21:47:41 +00003484 /* Update the GUI tab line, it may appear or disappear. This may
3485 * cause the non-GUI tab line to disappear or appear. */
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003486 using_tabline = gui_has_tabline();
Bram Moolenaarbfb2d402006-03-03 22:50:42 +00003487 if (!gui_mch_showing_tabline() != !using_tabline)
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003488 {
Bram Moolenaar7b5f8322006-03-23 22:47:08 +00003489 /* We don't want a resize event change "Rows" here, save and
3490 * restore it. Resizing is handled below. */
3491 i = Rows;
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003492 gui_update_tabline();
Bram Moolenaar7b5f8322006-03-23 22:47:08 +00003493 Rows = i;
Bram Moolenaar0133bba2008-12-03 17:50:45 +00003494 need_set_size |= RESIZE_VERT;
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003495 if (using_tabline)
3496 fix_size = TRUE;
3497 if (!gui_use_tabline())
3498 redraw_tabline = TRUE; /* may draw non-GUI tab line */
3499 }
3500#endif
3501
Bram Moolenaar071d4272004-06-13 20:20:40 +00003502 for (i = 0; i < 3; i++)
3503 {
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00003504 /* The scrollbar needs to be updated when it is shown/unshown and
3505 * when switching tab pages. But the size only changes when it's
3506 * shown/unshown. Thus we need two places to remember whether a
3507 * scrollbar is there or not. */
3508 if (gui.which_scrollbars[i] != prev_which_scrollbars[i]
Bram Moolenaar371d5402006-03-20 21:47:49 +00003509#ifdef FEAT_WINDOWS
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00003510 || gui.which_scrollbars[i]
3511 != curtab->tp_prev_which_scrollbars[i]
Bram Moolenaar371d5402006-03-20 21:47:49 +00003512#endif
3513 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00003514 {
3515 if (i == SBAR_BOTTOM)
3516 gui_mch_enable_scrollbar(&gui.bottom_sbar,
3517 gui.which_scrollbars[i]);
3518 else
3519 {
3520 FOR_ALL_WINDOWS(wp)
3521 {
3522 gui_do_scrollbar(wp, i, gui.which_scrollbars[i]);
3523 }
3524 }
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00003525 if (gui.which_scrollbars[i] != prev_which_scrollbars[i])
3526 {
3527 if (i == SBAR_BOTTOM)
Bram Moolenaar0133bba2008-12-03 17:50:45 +00003528 need_set_size |= RESIZE_VERT;
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00003529 else
Bram Moolenaar0133bba2008-12-03 17:50:45 +00003530 need_set_size |= RESIZE_HOR;
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00003531 if (gui.which_scrollbars[i])
3532 fix_size = TRUE;
3533 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003534 }
Bram Moolenaar371d5402006-03-20 21:47:49 +00003535#ifdef FEAT_WINDOWS
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00003536 curtab->tp_prev_which_scrollbars[i] = gui.which_scrollbars[i];
Bram Moolenaar371d5402006-03-20 21:47:49 +00003537#endif
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00003538 prev_which_scrollbars[i] = gui.which_scrollbars[i];
Bram Moolenaar071d4272004-06-13 20:20:40 +00003539 }
3540
3541#ifdef FEAT_MENU
3542 if (gui.menu_is_active != prev_menu_is_active)
3543 {
3544 /* We don't want a resize event change "Rows" here, save and
3545 * restore it. Resizing is handled below. */
3546 i = Rows;
3547 gui_mch_enable_menu(gui.menu_is_active);
3548 Rows = i;
3549 prev_menu_is_active = gui.menu_is_active;
Bram Moolenaar0133bba2008-12-03 17:50:45 +00003550 need_set_size |= RESIZE_VERT;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003551 if (gui.menu_is_active)
3552 fix_size = TRUE;
3553 }
3554#endif
3555
3556#ifdef FEAT_TOOLBAR
3557 if (using_toolbar != prev_toolbar)
3558 {
3559 gui_mch_show_toolbar(using_toolbar);
3560 prev_toolbar = using_toolbar;
Bram Moolenaar0133bba2008-12-03 17:50:45 +00003561 need_set_size |= RESIZE_VERT;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003562 if (using_toolbar)
3563 fix_size = TRUE;
3564 }
3565#endif
3566#ifdef FEAT_FOOTER
3567 if (using_footer != prev_footer)
3568 {
3569 gui_mch_enable_footer(using_footer);
3570 prev_footer = using_footer;
Bram Moolenaar0133bba2008-12-03 17:50:45 +00003571 need_set_size |= RESIZE_VERT;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003572 if (using_footer)
3573 fix_size = TRUE;
3574 }
3575#endif
Bram Moolenaarcf7164a2016-02-20 13:55:06 +01003576#if defined(FEAT_MENU) && !(defined(WIN3264) && !defined(FEAT_TEAROFF))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003577 if (using_tearoff != prev_tearoff)
3578 {
3579 gui_mch_toggle_tearoffs(using_tearoff);
3580 prev_tearoff = using_tearoff;
3581 }
3582#endif
Bram Moolenaar0133bba2008-12-03 17:50:45 +00003583 if (need_set_size != 0)
Bram Moolenaarc1087e62005-05-20 21:22:17 +00003584 {
3585#ifdef FEAT_GUI_GTK
Bram Moolenaar0133bba2008-12-03 17:50:45 +00003586 long prev_Columns = Columns;
3587 long prev_Rows = Rows;
Bram Moolenaarc1087e62005-05-20 21:22:17 +00003588#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003589 /* Adjust the size of the window to make the text area keep the
3590 * same size and to avoid that part of our window is off-screen
3591 * and a scrollbar can't be used, for example. */
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00003592 gui_set_shellsize(FALSE, fix_size, need_set_size);
Bram Moolenaarc1087e62005-05-20 21:22:17 +00003593
3594#ifdef FEAT_GUI_GTK
3595 /* GTK has the annoying habit of sending us resize events when
3596 * changing the window size ourselves. This mostly happens when
3597 * waiting for a character to arrive, quite unpredictably, and may
3598 * change Columns and Rows when we don't want it. Wait for a
3599 * character here to avoid this effect.
3600 * If you remove this, please test this command for resizing
Bram Moolenaara04f10b2005-05-31 22:09:46 +00003601 * effects (with optional left scrollbar): ":vsp|q|vsp|q|vsp|q".
Bram Moolenaarc542aef2006-02-25 21:47:41 +00003602 * Don't do this while starting up though.
Bram Moolenaar0133bba2008-12-03 17:50:45 +00003603 * Don't change Rows when adding menu/toolbar/tabline.
3604 * Don't change Columns when adding vertical toolbar. */
3605 if (!gui.starting && need_set_size != (RESIZE_VERT | RESIZE_HOR))
Bram Moolenaar01a7b9d2005-05-27 20:16:24 +00003606 (void)char_avail();
Bram Moolenaar0133bba2008-12-03 17:50:45 +00003607 if ((need_set_size & RESIZE_VERT) == 0)
3608 Rows = prev_Rows;
3609 if ((need_set_size & RESIZE_HOR) == 0)
3610 Columns = prev_Columns;
Bram Moolenaarc1087e62005-05-20 21:22:17 +00003611#endif
3612 }
Bram Moolenaarc542aef2006-02-25 21:47:41 +00003613#ifdef FEAT_WINDOWS
3614 /* When the console tabline appears or disappears the window positions
3615 * change. */
3616 if (firstwin->w_winrow != tabline_height())
3617 shell_new_rows(); /* recompute window positions and heights */
3618#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003619 }
3620}
3621
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003622#if defined(FEAT_GUI_TABLINE) || defined(PROTO)
3623/*
3624 * Return TRUE if the GUI is taking care of the tabline.
3625 * It may still be hidden if 'showtabline' is zero.
3626 */
3627 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01003628gui_use_tabline(void)
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003629{
3630 return gui.in_use && vim_strchr(p_go, GO_TABLINE) != NULL;
3631}
3632
3633/*
3634 * Return TRUE if the GUI is showing the tabline.
3635 * This uses 'showtabline'.
3636 */
3637 static int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01003638gui_has_tabline(void)
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003639{
3640 if (!gui_use_tabline()
3641 || p_stal == 0
3642 || (p_stal == 1 && first_tabpage->tp_next == NULL))
3643 return FALSE;
3644 return TRUE;
3645}
3646
3647/*
3648 * Update the tabline.
3649 * This may display/undisplay the tabline and update the labels.
3650 */
3651 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01003652gui_update_tabline(void)
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003653{
3654 int showit = gui_has_tabline();
Bram Moolenaar7b5f8322006-03-23 22:47:08 +00003655 int shown = gui_mch_showing_tabline();
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003656
3657 if (!gui.starting && starting == 0)
3658 {
Bram Moolenaarbd2ac7e2006-04-28 22:34:45 +00003659 /* Updating the tabline uses direct GUI commands, flush
3660 * outstanding instructions first. (esp. clear screen) */
3661 out_flush();
3662 gui_mch_flush();
3663
Bram Moolenaar7b5f8322006-03-23 22:47:08 +00003664 if (!showit != !shown)
3665 gui_mch_show_tabline(showit);
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003666 if (showit != 0)
3667 gui_mch_update_tabline();
Bram Moolenaar7b5f8322006-03-23 22:47:08 +00003668
3669 /* When the tabs change from hidden to shown or from shown to
3670 * hidden the size of the text area should remain the same. */
3671 if (!showit != !shown)
Bram Moolenaar2e2a2812006-03-27 20:55:21 +00003672 gui_set_shellsize(FALSE, showit, RESIZE_VERT);
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003673 }
3674}
3675
3676/*
Bram Moolenaar57657d82006-04-21 22:12:41 +00003677 * Get the label or tooltip for tab page "tp" into NameBuff[].
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003678 */
3679 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01003680get_tabline_label(
3681 tabpage_T *tp,
3682 int tooltip) /* TRUE: get tooltip */
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003683{
3684 int modified = FALSE;
3685 char_u buf[40];
3686 int wincount;
3687 win_T *wp;
Bram Moolenaard68071d2006-05-02 22:08:30 +00003688 char_u **opt;
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003689
Bram Moolenaar57657d82006-04-21 22:12:41 +00003690 /* Use 'guitablabel' or 'guitabtooltip' if it's set. */
Bram Moolenaard68071d2006-05-02 22:08:30 +00003691 opt = (tooltip ? &p_gtt : &p_gtl);
3692 if (**opt != NUL)
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003693 {
Bram Moolenaarc542aef2006-02-25 21:47:41 +00003694 int use_sandbox = FALSE;
3695 int save_called_emsg = called_emsg;
3696 char_u res[MAXPATHL];
Bram Moolenaarbfb2d402006-03-03 22:50:42 +00003697 tabpage_T *save_curtab;
Bram Moolenaar57657d82006-04-21 22:12:41 +00003698 char_u *opt_name = (char_u *)(tooltip ? "guitabtooltip"
3699 : "guitablabel");
Bram Moolenaarc542aef2006-02-25 21:47:41 +00003700
3701 called_emsg = FALSE;
3702
3703 printer_page_num = tabpage_index(tp);
3704# ifdef FEAT_EVAL
3705 set_vim_var_nr(VV_LNUM, printer_page_num);
Bram Moolenaar57657d82006-04-21 22:12:41 +00003706 use_sandbox = was_set_insecurely(opt_name, 0);
Bram Moolenaarc542aef2006-02-25 21:47:41 +00003707# endif
Bram Moolenaarbfb2d402006-03-03 22:50:42 +00003708 /* It's almost as going to the tabpage, but without autocommands. */
3709 curtab->tp_firstwin = firstwin;
3710 curtab->tp_lastwin = lastwin;
3711 curtab->tp_curwin = curwin;
3712 save_curtab = curtab;
3713 curtab = tp;
3714 topframe = curtab->tp_topframe;
3715 firstwin = curtab->tp_firstwin;
3716 lastwin = curtab->tp_lastwin;
3717 curwin = curtab->tp_curwin;
3718 curbuf = curwin->w_buffer;
3719
Bram Moolenaarc542aef2006-02-25 21:47:41 +00003720 /* Can't use NameBuff directly, build_stl_str_hl() uses it. */
Bram Moolenaard68071d2006-05-02 22:08:30 +00003721 build_stl_str_hl(curwin, res, MAXPATHL, *opt, use_sandbox,
Bram Moolenaarbfb2d402006-03-03 22:50:42 +00003722 0, (int)Columns, NULL, NULL);
Bram Moolenaarc542aef2006-02-25 21:47:41 +00003723 STRCPY(NameBuff, res);
3724
Bram Moolenaarbfb2d402006-03-03 22:50:42 +00003725 /* Back to the original curtab. */
3726 curtab = save_curtab;
3727 topframe = curtab->tp_topframe;
3728 firstwin = curtab->tp_firstwin;
3729 lastwin = curtab->tp_lastwin;
3730 curwin = curtab->tp_curwin;
3731 curbuf = curwin->w_buffer;
3732
Bram Moolenaarc542aef2006-02-25 21:47:41 +00003733 if (called_emsg)
Bram Moolenaar57657d82006-04-21 22:12:41 +00003734 set_string_option_direct(opt_name, -1,
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00003735 (char_u *)"", OPT_FREE, SID_ERROR);
Bram Moolenaarc542aef2006-02-25 21:47:41 +00003736 called_emsg |= save_called_emsg;
3737 }
Bram Moolenaard68071d2006-05-02 22:08:30 +00003738
3739 /* If 'guitablabel'/'guitabtooltip' is not set or the result is empty then
3740 * use a default label. */
3741 if (**opt == NUL || *NameBuff == NUL)
Bram Moolenaarc542aef2006-02-25 21:47:41 +00003742 {
Bram Moolenaar910f66f2006-04-05 20:41:53 +00003743 /* Get the buffer name into NameBuff[] and shorten it. */
Bram Moolenaarc542aef2006-02-25 21:47:41 +00003744 get_trans_bufname(tp == curtab ? curbuf : tp->tp_curwin->w_buffer);
Bram Moolenaar57657d82006-04-21 22:12:41 +00003745 if (!tooltip)
3746 shorten_dir(NameBuff);
Bram Moolenaarc542aef2006-02-25 21:47:41 +00003747
3748 wp = (tp == curtab) ? firstwin : tp->tp_firstwin;
3749 for (wincount = 0; wp != NULL; wp = wp->w_next, ++wincount)
3750 if (bufIsChanged(wp->w_buffer))
3751 modified = TRUE;
3752 if (modified || wincount > 1)
3753 {
3754 if (wincount > 1)
3755 vim_snprintf((char *)buf, sizeof(buf), "%d", wincount);
3756 else
3757 buf[0] = NUL;
3758 if (modified)
3759 STRCAT(buf, "+");
3760 STRCAT(buf, " ");
Bram Moolenaar3577c6f2008-06-24 21:16:56 +00003761 STRMOVE(NameBuff + STRLEN(buf), NameBuff);
Bram Moolenaarc542aef2006-02-25 21:47:41 +00003762 mch_memmove(NameBuff, buf, STRLEN(buf));
3763 }
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003764 }
3765}
3766
Bram Moolenaar1cad2922006-02-27 00:00:52 +00003767/*
3768 * Send the event for clicking to select tab page "nr".
3769 * Returns TRUE if it was done, FALSE when skipped because we are already at
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00003770 * that tab page or the cmdline window is open.
Bram Moolenaar1cad2922006-02-27 00:00:52 +00003771 */
3772 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01003773send_tabline_event(int nr)
Bram Moolenaar1cad2922006-02-27 00:00:52 +00003774{
3775 char_u string[3];
3776
3777 if (nr == tabpage_index(curtab))
3778 return FALSE;
Bram Moolenaarf193fff2006-04-27 00:02:13 +00003779
3780 /* Don't put events in the input queue now. */
3781 if (hold_gui_events
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00003782# ifdef FEAT_CMDWIN
Bram Moolenaarf193fff2006-04-27 00:02:13 +00003783 || cmdwin_type != 0
3784# endif
3785 )
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00003786 {
3787 /* Set it back to the current tab page. */
3788 gui_mch_set_curtab(tabpage_index(curtab));
3789 return FALSE;
3790 }
Bram Moolenaarf193fff2006-04-27 00:02:13 +00003791
Bram Moolenaar1cad2922006-02-27 00:00:52 +00003792 string[0] = CSI;
3793 string[1] = KS_TABLINE;
3794 string[2] = KE_FILLER;
3795 add_to_input_buf(string, 3);
3796 string[0] = nr;
3797 add_to_input_buf_csi(string, 1);
3798 return TRUE;
3799}
3800
Bram Moolenaarc6fe9192006-04-09 21:54:49 +00003801/*
3802 * Send a tabline menu event
3803 */
3804 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01003805send_tabline_menu_event(int tabidx, int event)
Bram Moolenaarc6fe9192006-04-09 21:54:49 +00003806{
3807 char_u string[3];
3808
Bram Moolenaarf193fff2006-04-27 00:02:13 +00003809 /* Don't put events in the input queue now. */
3810 if (hold_gui_events)
3811 return;
3812
Bram Moolenaarc6fe9192006-04-09 21:54:49 +00003813 string[0] = CSI;
3814 string[1] = KS_TABMENU;
3815 string[2] = KE_FILLER;
3816 add_to_input_buf(string, 3);
3817 string[0] = tabidx;
3818 string[1] = (char_u)(long)event;
3819 add_to_input_buf_csi(string, 2);
3820}
3821
Bram Moolenaar32466aa2006-02-24 23:53:04 +00003822#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003823
3824/*
3825 * Scrollbar stuff:
3826 */
3827
Bram Moolenaare45828b2006-02-15 22:12:56 +00003828#if defined(FEAT_WINDOWS) || defined(PROTO)
3829/*
3830 * Remove all scrollbars. Used before switching to another tab page.
3831 */
3832 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01003833gui_remove_scrollbars(void)
Bram Moolenaare45828b2006-02-15 22:12:56 +00003834{
3835 int i;
3836 win_T *wp;
3837
3838 for (i = 0; i < 3; i++)
3839 {
3840 if (i == SBAR_BOTTOM)
3841 gui_mch_enable_scrollbar(&gui.bottom_sbar, FALSE);
3842 else
3843 {
3844 FOR_ALL_WINDOWS(wp)
3845 {
3846 gui_do_scrollbar(wp, i, FALSE);
3847 }
3848 }
Bram Moolenaar371d5402006-03-20 21:47:49 +00003849 curtab->tp_prev_which_scrollbars[i] = -1;
Bram Moolenaare45828b2006-02-15 22:12:56 +00003850 }
3851}
3852#endif
3853
Bram Moolenaar071d4272004-06-13 20:20:40 +00003854 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01003855gui_create_scrollbar(scrollbar_T *sb, int type, win_T *wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003856{
3857 static int sbar_ident = 0;
3858
3859 sb->ident = sbar_ident++; /* No check for too big, but would it happen? */
3860 sb->wp = wp;
3861 sb->type = type;
3862 sb->value = 0;
3863#ifdef FEAT_GUI_ATHENA
3864 sb->pixval = 0;
3865#endif
3866 sb->size = 1;
3867 sb->max = 1;
3868 sb->top = 0;
3869 sb->height = 0;
Bram Moolenaar44a2f922016-03-19 22:11:51 +01003870#ifdef FEAT_WINDOWS
Bram Moolenaar071d4272004-06-13 20:20:40 +00003871 sb->width = 0;
3872#endif
3873 sb->status_height = 0;
3874 gui_mch_create_scrollbar(sb, (wp == NULL) ? SBAR_HORIZ : SBAR_VERT);
3875}
3876
3877/*
3878 * Find the scrollbar with the given index.
3879 */
3880 scrollbar_T *
Bram Moolenaar66f948e2016-01-30 16:39:25 +01003881gui_find_scrollbar(long ident)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003882{
3883 win_T *wp;
3884
3885 if (gui.bottom_sbar.ident == ident)
3886 return &gui.bottom_sbar;
3887 FOR_ALL_WINDOWS(wp)
3888 {
3889 if (wp->w_scrollbars[SBAR_LEFT].ident == ident)
3890 return &wp->w_scrollbars[SBAR_LEFT];
3891 if (wp->w_scrollbars[SBAR_RIGHT].ident == ident)
3892 return &wp->w_scrollbars[SBAR_RIGHT];
3893 }
3894 return NULL;
3895}
3896
3897/*
3898 * For most systems: Put a code in the input buffer for a dragged scrollbar.
3899 *
3900 * For Win32, Macintosh and GTK+ 2:
3901 * Scrollbars seem to grab focus and vim doesn't read the input queue until
3902 * you stop dragging the scrollbar. We get here each time the scrollbar is
3903 * dragged another pixel, but as far as the rest of vim goes, it thinks
3904 * we're just hanging in the call to DispatchMessage() in
3905 * process_message(). The DispatchMessage() call that hangs was passed a
3906 * mouse button click event in the scrollbar window. -- webb.
3907 *
3908 * Solution: Do the scrolling right here. But only when allowed.
3909 * Ignore the scrollbars while executing an external command or when there
3910 * are still characters to be processed.
3911 */
3912 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01003913gui_drag_scrollbar(scrollbar_T *sb, long value, int still_dragging)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003914{
3915#ifdef FEAT_WINDOWS
3916 win_T *wp;
3917#endif
3918 int sb_num;
3919#ifdef USE_ON_FLY_SCROLL
3920 colnr_T old_leftcol = curwin->w_leftcol;
3921# ifdef FEAT_SCROLLBIND
3922 linenr_T old_topline = curwin->w_topline;
3923# endif
3924# ifdef FEAT_DIFF
3925 int old_topfill = curwin->w_topfill;
3926# endif
3927#else
Bram Moolenaar110bc6b2006-02-10 23:13:40 +00003928 char_u bytes[sizeof(long_u)];
Bram Moolenaar071d4272004-06-13 20:20:40 +00003929 int byte_count;
3930#endif
3931
3932 if (sb == NULL)
3933 return;
3934
3935 /* Don't put events in the input queue now. */
3936 if (hold_gui_events)
3937 return;
3938
3939#ifdef FEAT_CMDWIN
3940 if (cmdwin_type != 0 && sb->wp != curwin)
3941 return;
3942#endif
3943
3944 if (still_dragging)
3945 {
3946 if (sb->wp == NULL)
3947 gui.dragged_sb = SBAR_BOTTOM;
3948 else if (sb == &sb->wp->w_scrollbars[SBAR_LEFT])
3949 gui.dragged_sb = SBAR_LEFT;
3950 else
3951 gui.dragged_sb = SBAR_RIGHT;
3952 gui.dragged_wp = sb->wp;
3953 }
3954 else
3955 {
3956 gui.dragged_sb = SBAR_NONE;
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02003957#ifdef FEAT_GUI_GTK
Bram Moolenaar071d4272004-06-13 20:20:40 +00003958 /* Keep the "dragged_wp" value until after the scrolling, for when the
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02003959 * mouse button is released. GTK2 doesn't send the button-up event. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003960 gui.dragged_wp = NULL;
3961#endif
3962 }
3963
3964 /* Vertical sbar info is kept in the first sbar (the left one) */
3965 if (sb->wp != NULL)
3966 sb = &sb->wp->w_scrollbars[0];
3967
3968 /*
3969 * Check validity of value
3970 */
3971 if (value < 0)
3972 value = 0;
3973#ifdef SCROLL_PAST_END
3974 else if (value > sb->max)
3975 value = sb->max;
3976#else
3977 if (value > sb->max - sb->size + 1)
3978 value = sb->max - sb->size + 1;
3979#endif
3980
3981 sb->value = value;
3982
3983#ifdef USE_ON_FLY_SCROLL
Bram Moolenaar67840782008-01-03 15:15:07 +00003984 /* When not allowed to do the scrolling right now, return.
3985 * This also checked input_available(), but that causes the first click in
3986 * a scrollbar to be ignored when Vim doesn't have focus. */
3987 if (dont_scroll)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003988 return;
3989#endif
Bram Moolenaar05bb82f2006-09-10 19:39:25 +00003990#ifdef FEAT_INS_EXPAND
3991 /* Disallow scrolling the current window when the completion popup menu is
3992 * visible. */
3993 if ((sb->wp == NULL || sb->wp == curwin) && pum_visible())
3994 return;
3995#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003996
3997#ifdef FEAT_RIGHTLEFT
3998 if (sb->wp == NULL && curwin->w_p_rl)
3999 {
4000 value = sb->max + 1 - sb->size - value;
4001 if (value < 0)
4002 value = 0;
4003 }
4004#endif
4005
4006 if (sb->wp != NULL) /* vertical scrollbar */
4007 {
4008 sb_num = 0;
4009#ifdef FEAT_WINDOWS
4010 for (wp = firstwin; wp != sb->wp && wp != NULL; wp = wp->w_next)
4011 sb_num++;
4012 if (wp == NULL)
4013 return;
4014#else
4015 if (sb->wp != curwin)
4016 return;
4017#endif
4018
4019#ifdef USE_ON_FLY_SCROLL
4020 current_scrollbar = sb_num;
4021 scrollbar_value = value;
4022 if (State & NORMAL)
4023 {
4024 gui_do_scroll();
4025 setcursor();
4026 }
4027 else if (State & INSERT)
4028 {
4029 ins_scroll();
4030 setcursor();
4031 }
4032 else if (State & CMDLINE)
4033 {
4034 if (msg_scrolled == 0)
4035 {
4036 gui_do_scroll();
4037 redrawcmdline();
4038 }
4039 }
4040# ifdef FEAT_FOLDING
4041 /* Value may have been changed for closed fold. */
4042 sb->value = sb->wp->w_topline - 1;
4043# endif
Bram Moolenaar371d5402006-03-20 21:47:49 +00004044
4045 /* When dragging one scrollbar and there is another one at the other
4046 * side move the thumb of that one too. */
4047 if (gui.which_scrollbars[SBAR_RIGHT] && gui.which_scrollbars[SBAR_LEFT])
4048 gui_mch_set_scrollbar_thumb(
4049 &sb->wp->w_scrollbars[
4050 sb == &sb->wp->w_scrollbars[SBAR_RIGHT]
4051 ? SBAR_LEFT : SBAR_RIGHT],
4052 sb->value, sb->size, sb->max);
4053
Bram Moolenaar071d4272004-06-13 20:20:40 +00004054#else
4055 bytes[0] = CSI;
4056 bytes[1] = KS_VER_SCROLLBAR;
4057 bytes[2] = KE_FILLER;
4058 bytes[3] = (char_u)sb_num;
4059 byte_count = 4;
4060#endif
4061 }
4062 else
4063 {
4064#ifdef USE_ON_FLY_SCROLL
4065 scrollbar_value = value;
4066
4067 if (State & NORMAL)
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02004068 gui_do_horiz_scroll(scrollbar_value, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004069 else if (State & INSERT)
4070 ins_horscroll();
4071 else if (State & CMDLINE)
4072 {
Bram Moolenaar1c7715d2005-10-03 22:02:18 +00004073 if (msg_scrolled == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004074 {
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02004075 gui_do_horiz_scroll(scrollbar_value, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004076 redrawcmdline();
4077 }
4078 }
4079 if (old_leftcol != curwin->w_leftcol)
4080 {
4081 updateWindow(curwin); /* update window, status and cmdline */
4082 setcursor();
4083 }
4084#else
4085 bytes[0] = CSI;
4086 bytes[1] = KS_HOR_SCROLLBAR;
4087 bytes[2] = KE_FILLER;
4088 byte_count = 3;
4089#endif
4090 }
4091
4092#ifdef USE_ON_FLY_SCROLL
4093# ifdef FEAT_SCROLLBIND
4094 /*
4095 * synchronize other windows, as necessary according to 'scrollbind'
4096 */
4097 if (curwin->w_p_scb
4098 && ((sb->wp == NULL && curwin->w_leftcol != old_leftcol)
4099 || (sb->wp == curwin && (curwin->w_topline != old_topline
4100# ifdef FEAT_DIFF
4101 || curwin->w_topfill != old_topfill
4102# endif
4103 ))))
4104 {
4105 do_check_scrollbind(TRUE);
4106 /* need to update the window right here */
Bram Moolenaar29323592016-07-24 22:04:11 +02004107 FOR_ALL_WINDOWS(wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004108 if (wp->w_redr_type > 0)
4109 updateWindow(wp);
4110 setcursor();
4111 }
4112# endif
4113 out_flush();
4114 gui_update_cursor(FALSE, TRUE);
4115#else
Bram Moolenaar110bc6b2006-02-10 23:13:40 +00004116 add_to_input_buf(bytes, byte_count);
4117 add_long_to_buf((long_u)value, bytes);
4118 add_to_input_buf_csi(bytes, sizeof(long_u));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004119#endif
4120}
4121
4122/*
4123 * Scrollbar stuff:
4124 */
4125
Bram Moolenaarfd3e5dc2010-05-30 19:00:15 +02004126#if defined(FEAT_AUTOCMD) || defined(FEAT_WINDOWS) || defined(PROTO)
Bram Moolenaar746ebd32009-06-16 14:01:43 +00004127/*
4128 * Called when something in the window layout has changed.
4129 */
4130 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004131gui_may_update_scrollbars(void)
Bram Moolenaar746ebd32009-06-16 14:01:43 +00004132{
4133 if (gui.in_use && starting == 0)
4134 {
4135 out_flush();
4136 gui_init_which_components(NULL);
4137 gui_update_scrollbars(TRUE);
4138 }
4139 need_mouse_correct = TRUE;
4140}
Bram Moolenaarfd3e5dc2010-05-30 19:00:15 +02004141#endif
Bram Moolenaar746ebd32009-06-16 14:01:43 +00004142
Bram Moolenaar071d4272004-06-13 20:20:40 +00004143 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004144gui_update_scrollbars(
4145 int force) /* Force all scrollbars to get updated */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004146{
4147 win_T *wp;
4148 scrollbar_T *sb;
4149 long val, size, max; /* need 32 bits here */
4150 int which_sb;
4151 int h, y;
Bram Moolenaar44a2f922016-03-19 22:11:51 +01004152#ifdef FEAT_WINDOWS
Bram Moolenaar071d4272004-06-13 20:20:40 +00004153 static win_T *prev_curwin = NULL;
4154#endif
4155
4156 /* Update the horizontal scrollbar */
4157 gui_update_horiz_scrollbar(force);
4158
4159#ifndef WIN3264
4160 /* Return straight away if there is neither a left nor right scrollbar.
4161 * On MS-Windows this is required anyway for scrollwheel messages. */
4162 if (!gui.which_scrollbars[SBAR_LEFT] && !gui.which_scrollbars[SBAR_RIGHT])
4163 return;
4164#endif
4165
4166 /*
4167 * Don't want to update a scrollbar while we're dragging it. But if we
4168 * have both a left and right scrollbar, and we drag one of them, we still
4169 * need to update the other one.
4170 */
Bram Moolenaar7e8fd632006-02-18 22:14:51 +00004171 if (!force && (gui.dragged_sb == SBAR_LEFT || gui.dragged_sb == SBAR_RIGHT)
4172 && gui.which_scrollbars[SBAR_LEFT]
4173 && gui.which_scrollbars[SBAR_RIGHT])
Bram Moolenaar071d4272004-06-13 20:20:40 +00004174 {
4175 /*
4176 * If we have two scrollbars and one of them is being dragged, just
4177 * copy the scrollbar position from the dragged one to the other one.
4178 */
4179 which_sb = SBAR_LEFT + SBAR_RIGHT - gui.dragged_sb;
4180 if (gui.dragged_wp != NULL)
4181 gui_mch_set_scrollbar_thumb(
4182 &gui.dragged_wp->w_scrollbars[which_sb],
4183 gui.dragged_wp->w_scrollbars[0].value,
4184 gui.dragged_wp->w_scrollbars[0].size,
4185 gui.dragged_wp->w_scrollbars[0].max);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004186 }
4187
4188 /* avoid that moving components around generates events */
4189 ++hold_gui_events;
4190
Bram Moolenaar45a24952016-07-24 22:25:15 +02004191 for (wp = firstwin; wp != NULL; wp = W_NEXT(wp))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004192 {
4193 if (wp->w_buffer == NULL) /* just in case */
4194 continue;
Bram Moolenaar7e8fd632006-02-18 22:14:51 +00004195 /* Skip a scrollbar that is being dragged. */
4196 if (!force && (gui.dragged_sb == SBAR_LEFT
4197 || gui.dragged_sb == SBAR_RIGHT)
4198 && gui.dragged_wp == wp)
4199 continue;
4200
Bram Moolenaar071d4272004-06-13 20:20:40 +00004201#ifdef SCROLL_PAST_END
4202 max = wp->w_buffer->b_ml.ml_line_count - 1;
4203#else
4204 max = wp->w_buffer->b_ml.ml_line_count + wp->w_height - 2;
4205#endif
4206 if (max < 0) /* empty buffer */
4207 max = 0;
4208 val = wp->w_topline - 1;
4209 size = wp->w_height;
4210#ifdef SCROLL_PAST_END
4211 if (val > max) /* just in case */
4212 val = max;
4213#else
4214 if (size > max + 1) /* just in case */
4215 size = max + 1;
4216 if (val > max - size + 1)
4217 val = max - size + 1;
4218#endif
4219 if (val < 0) /* minimal value is 0 */
4220 val = 0;
4221
4222 /*
4223 * Scrollbar at index 0 (the left one) contains all the information.
4224 * It would be the same info for left and right so we just store it for
4225 * one of them.
4226 */
4227 sb = &wp->w_scrollbars[0];
4228
4229 /*
4230 * Note: no check for valid w_botline. If it's not valid the
4231 * scrollbars will be updated later anyway.
4232 */
4233 if (size < 1 || wp->w_botline - 2 > max)
4234 {
4235 /*
4236 * This can happen during changing files. Just don't update the
4237 * scrollbar for now.
4238 */
4239 sb->height = 0; /* Force update next time */
4240 if (gui.which_scrollbars[SBAR_LEFT])
4241 gui_do_scrollbar(wp, SBAR_LEFT, FALSE);
4242 if (gui.which_scrollbars[SBAR_RIGHT])
4243 gui_do_scrollbar(wp, SBAR_RIGHT, FALSE);
4244 continue;
4245 }
4246 if (force || sb->height != wp->w_height
4247#ifdef FEAT_WINDOWS
4248 || sb->top != wp->w_winrow
4249 || sb->status_height != wp->w_status_height
Bram Moolenaar071d4272004-06-13 20:20:40 +00004250 || sb->width != wp->w_width
4251 || prev_curwin != curwin
Bram Moolenaar071d4272004-06-13 20:20:40 +00004252#endif
4253 )
4254 {
4255 /* Height, width or position of scrollbar has changed. For
4256 * vertical split: curwin changed. */
4257 sb->height = wp->w_height;
4258#ifdef FEAT_WINDOWS
4259 sb->top = wp->w_winrow;
4260 sb->status_height = wp->w_status_height;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004261 sb->width = wp->w_width;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004262#endif
4263
4264 /* Calculate height and position in pixels */
4265 h = (sb->height + sb->status_height) * gui.char_height;
4266 y = sb->top * gui.char_height + gui.border_offset;
4267#if defined(FEAT_MENU) && !defined(FEAT_GUI_GTK) && !defined(FEAT_GUI_MOTIF) && !defined(FEAT_GUI_PHOTON)
4268 if (gui.menu_is_active)
4269 y += gui.menu_height;
4270#endif
4271
4272#if defined(FEAT_TOOLBAR) && (defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_ATHENA))
4273 if (vim_strchr(p_go, GO_TOOLBAR) != NULL)
4274# ifdef FEAT_GUI_ATHENA
4275 y += gui.toolbar_height;
4276# else
4277# ifdef FEAT_GUI_MSWIN
4278 y += TOOLBAR_BUTTON_HEIGHT + TOOLBAR_BORDER_HEIGHT;
4279# endif
4280# endif
4281#endif
4282
Bram Moolenaar3991dab2006-03-27 17:01:56 +00004283#if defined(FEAT_GUI_TABLINE) && defined(FEAT_GUI_MSWIN)
4284 if (gui_has_tabline())
Bram Moolenaar551dbcc2006-04-25 22:13:59 +00004285 y += gui.tabline_height;
Bram Moolenaar3991dab2006-03-27 17:01:56 +00004286#endif
4287
Bram Moolenaar071d4272004-06-13 20:20:40 +00004288#ifdef FEAT_WINDOWS
4289 if (wp->w_winrow == 0)
4290#endif
4291 {
4292 /* Height of top scrollbar includes width of top border */
4293 h += gui.border_offset;
4294 y -= gui.border_offset;
4295 }
4296 if (gui.which_scrollbars[SBAR_LEFT])
4297 {
4298 gui_mch_set_scrollbar_pos(&wp->w_scrollbars[SBAR_LEFT],
4299 gui.left_sbar_x, y,
4300 gui.scrollbar_width, h);
4301 gui_do_scrollbar(wp, SBAR_LEFT, TRUE);
4302 }
4303 if (gui.which_scrollbars[SBAR_RIGHT])
4304 {
4305 gui_mch_set_scrollbar_pos(&wp->w_scrollbars[SBAR_RIGHT],
4306 gui.right_sbar_x, y,
4307 gui.scrollbar_width, h);
4308 gui_do_scrollbar(wp, SBAR_RIGHT, TRUE);
4309 }
4310 }
4311
4312 /* Reduce the number of calls to gui_mch_set_scrollbar_thumb() by
4313 * checking if the thumb moved at least a pixel. Only do this for
4314 * Athena, most other GUIs require the update anyway to make the
4315 * arrows work. */
4316#ifdef FEAT_GUI_ATHENA
4317 if (max == 0)
4318 y = 0;
4319 else
4320 y = (val * (sb->height + 2) * gui.char_height + max / 2) / max;
4321 if (force || sb->pixval != y || sb->size != size || sb->max != max)
4322#else
4323 if (force || sb->value != val || sb->size != size || sb->max != max)
4324#endif
4325 {
4326 /* Thumb of scrollbar has moved */
4327 sb->value = val;
4328#ifdef FEAT_GUI_ATHENA
4329 sb->pixval = y;
4330#endif
4331 sb->size = size;
4332 sb->max = max;
Bram Moolenaar7e8fd632006-02-18 22:14:51 +00004333 if (gui.which_scrollbars[SBAR_LEFT]
4334 && (gui.dragged_sb != SBAR_LEFT || gui.dragged_wp != wp))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004335 gui_mch_set_scrollbar_thumb(&wp->w_scrollbars[SBAR_LEFT],
4336 val, size, max);
4337 if (gui.which_scrollbars[SBAR_RIGHT]
Bram Moolenaar7e8fd632006-02-18 22:14:51 +00004338 && (gui.dragged_sb != SBAR_RIGHT || gui.dragged_wp != wp))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004339 gui_mch_set_scrollbar_thumb(&wp->w_scrollbars[SBAR_RIGHT],
4340 val, size, max);
4341 }
4342 }
Bram Moolenaar44a2f922016-03-19 22:11:51 +01004343#ifdef FEAT_WINDOWS
Bram Moolenaar071d4272004-06-13 20:20:40 +00004344 prev_curwin = curwin;
4345#endif
4346 --hold_gui_events;
4347}
4348
4349/*
4350 * Enable or disable a scrollbar.
4351 * Check for scrollbars for vertically split windows which are not enabled
4352 * sometimes.
4353 */
4354 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004355gui_do_scrollbar(
4356 win_T *wp,
4357 int which, /* SBAR_LEFT or SBAR_RIGHT */
4358 int enable) /* TRUE to enable scrollbar */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004359{
Bram Moolenaar44a2f922016-03-19 22:11:51 +01004360#ifdef FEAT_WINDOWS
Bram Moolenaar071d4272004-06-13 20:20:40 +00004361 int midcol = curwin->w_wincol + curwin->w_width / 2;
4362 int has_midcol = (wp->w_wincol <= midcol
4363 && wp->w_wincol + wp->w_width >= midcol);
4364
4365 /* Only enable scrollbars that contain the middle column of the current
4366 * window. */
4367 if (gui.which_scrollbars[SBAR_RIGHT] != gui.which_scrollbars[SBAR_LEFT])
4368 {
4369 /* Scrollbars only on one side. Don't enable scrollbars that don't
4370 * contain the middle column of the current window. */
4371 if (!has_midcol)
4372 enable = FALSE;
4373 }
4374 else
4375 {
4376 /* Scrollbars on both sides. Don't enable scrollbars that neither
4377 * contain the middle column of the current window nor are on the far
4378 * side. */
4379 if (midcol > Columns / 2)
4380 {
4381 if (which == SBAR_LEFT ? wp->w_wincol != 0 : !has_midcol)
4382 enable = FALSE;
4383 }
4384 else
4385 {
4386 if (which == SBAR_RIGHT ? wp->w_wincol + wp->w_width != Columns
4387 : !has_midcol)
4388 enable = FALSE;
4389 }
4390 }
4391#endif
4392 gui_mch_enable_scrollbar(&wp->w_scrollbars[which], enable);
4393}
4394
4395/*
4396 * Scroll a window according to the values set in the globals current_scrollbar
4397 * and scrollbar_value. Return TRUE if the cursor in the current window moved
4398 * or FALSE otherwise.
4399 */
4400 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004401gui_do_scroll(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004402{
4403 win_T *wp, *save_wp;
4404 int i;
4405 long nlines;
4406 pos_T old_cursor;
4407 linenr_T old_topline;
4408#ifdef FEAT_DIFF
4409 int old_topfill;
4410#endif
4411
4412 for (wp = firstwin, i = 0; i < current_scrollbar; wp = W_NEXT(wp), i++)
4413 if (wp == NULL)
4414 break;
4415 if (wp == NULL)
4416 /* Couldn't find window */
4417 return FALSE;
4418
4419 /*
4420 * Compute number of lines to scroll. If zero, nothing to do.
4421 */
4422 nlines = (long)scrollbar_value + 1 - (long)wp->w_topline;
4423 if (nlines == 0)
4424 return FALSE;
4425
4426 save_wp = curwin;
4427 old_topline = wp->w_topline;
4428#ifdef FEAT_DIFF
4429 old_topfill = wp->w_topfill;
4430#endif
4431 old_cursor = wp->w_cursor;
4432 curwin = wp;
4433 curbuf = wp->w_buffer;
4434 if (nlines < 0)
4435 scrolldown(-nlines, gui.dragged_wp == NULL);
4436 else
4437 scrollup(nlines, gui.dragged_wp == NULL);
4438 /* Reset dragged_wp after using it. "dragged_sb" will have been reset for
4439 * the mouse-up event already, but we still want it to behave like when
4440 * dragging. But not the next click in an arrow. */
4441 if (gui.dragged_sb == SBAR_NONE)
4442 gui.dragged_wp = NULL;
4443
4444 if (old_topline != wp->w_topline
4445#ifdef FEAT_DIFF
4446 || old_topfill != wp->w_topfill
4447#endif
4448 )
4449 {
4450 if (p_so != 0)
4451 {
4452 cursor_correct(); /* fix window for 'so' */
4453 update_topline(); /* avoid up/down jump */
4454 }
4455 if (old_cursor.lnum != wp->w_cursor.lnum)
4456 coladvance(wp->w_curswant);
4457#ifdef FEAT_SCROLLBIND
4458 wp->w_scbind_pos = wp->w_topline;
4459#endif
4460 }
4461
Bram Moolenaar578b49e2005-09-10 19:22:57 +00004462 /* Make sure wp->w_leftcol and wp->w_skipcol are correct. */
4463 validate_cursor();
4464
Bram Moolenaar071d4272004-06-13 20:20:40 +00004465 curwin = save_wp;
4466 curbuf = save_wp->w_buffer;
4467
4468 /*
4469 * Don't call updateWindow() when nothing has changed (it will overwrite
4470 * the status line!).
4471 */
4472 if (old_topline != wp->w_topline
Bram Moolenaar578b49e2005-09-10 19:22:57 +00004473 || wp->w_redr_type != 0
Bram Moolenaar071d4272004-06-13 20:20:40 +00004474#ifdef FEAT_DIFF
4475 || old_topfill != wp->w_topfill
4476#endif
4477 )
4478 {
Bram Moolenaar9b25ffb2007-11-06 21:27:31 +00004479 int type = VALID;
4480
4481#ifdef FEAT_INS_EXPAND
4482 if (pum_visible())
4483 {
4484 type = NOT_VALID;
4485 wp->w_lines_valid = 0;
4486 }
4487#endif
4488 /* Don't set must_redraw here, it may cause the popup menu to
4489 * disappear when losing focus after a scrollbar drag. */
4490 if (wp->w_redr_type < type)
4491 wp->w_redr_type = type;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004492 updateWindow(wp); /* update window, status line, and cmdline */
4493 }
4494
Bram Moolenaar05bb82f2006-09-10 19:39:25 +00004495#ifdef FEAT_INS_EXPAND
4496 /* May need to redraw the popup menu. */
4497 if (pum_visible())
4498 pum_redraw();
4499#endif
4500
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01004501 return (wp == curwin && !EQUAL_POS(curwin->w_cursor, old_cursor));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004502}
4503
4504
4505/*
4506 * Horizontal scrollbar stuff:
4507 */
4508
4509/*
4510 * Return length of line "lnum" for horizontal scrolling.
4511 */
4512 static colnr_T
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004513scroll_line_len(linenr_T lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004514{
4515 char_u *p;
4516 colnr_T col;
4517 int w;
4518
4519 p = ml_get(lnum);
4520 col = 0;
4521 if (*p != NUL)
4522 for (;;)
4523 {
4524 w = chartabsize(p, col);
Bram Moolenaar91acfff2017-03-12 19:22:36 +01004525 MB_PTR_ADV(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004526 if (*p == NUL) /* don't count the last character */
4527 break;
4528 col += w;
4529 }
4530 return col;
4531}
4532
4533/* Remember which line is currently the longest, so that we don't have to
4534 * search for it when scrolling horizontally. */
4535static linenr_T longest_lnum = 0;
4536
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02004537/*
4538 * Find longest visible line number. If this is not possible (or not desired,
4539 * by setting 'h' in "guioptions") then the current line number is returned.
4540 */
4541 static linenr_T
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004542gui_find_longest_lnum(void)
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02004543{
4544 linenr_T ret = 0;
4545
4546 /* Calculate maximum for horizontal scrollbar. Check for reasonable
4547 * line numbers, topline and botline can be invalid when displaying is
4548 * postponed. */
4549 if (vim_strchr(p_go, GO_HORSCROLL) == NULL
4550 && curwin->w_topline <= curwin->w_cursor.lnum
4551 && curwin->w_botline > curwin->w_cursor.lnum
4552 && curwin->w_botline <= curbuf->b_ml.ml_line_count + 1)
4553 {
4554 linenr_T lnum;
4555 colnr_T n;
4556 long max = 0;
4557
4558 /* Use maximum of all visible lines. Remember the lnum of the
4559 * longest line, closest to the cursor line. Used when scrolling
4560 * below. */
4561 for (lnum = curwin->w_topline; lnum < curwin->w_botline; ++lnum)
4562 {
4563 n = scroll_line_len(lnum);
4564 if (n > (colnr_T)max)
4565 {
4566 max = n;
4567 ret = lnum;
4568 }
4569 else if (n == (colnr_T)max
4570 && abs((int)(lnum - curwin->w_cursor.lnum))
4571 < abs((int)(ret - curwin->w_cursor.lnum)))
4572 ret = lnum;
4573 }
4574 }
4575 else
4576 /* Use cursor line only. */
4577 ret = curwin->w_cursor.lnum;
4578
4579 return ret;
4580}
4581
Bram Moolenaar071d4272004-06-13 20:20:40 +00004582 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004583gui_update_horiz_scrollbar(int force)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004584{
4585 long value, size, max; /* need 32 bit ints here */
4586
4587 if (!gui.which_scrollbars[SBAR_BOTTOM])
4588 return;
4589
4590 if (!force && gui.dragged_sb == SBAR_BOTTOM)
4591 return;
4592
4593 if (!force && curwin->w_p_wrap && gui.prev_wrap)
4594 return;
4595
4596 /*
4597 * It is possible for the cursor to be invalid if we're in the middle of
4598 * something (like changing files). If so, don't do anything for now.
4599 */
4600 if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
4601 {
4602 gui.bottom_sbar.value = -1;
4603 return;
4604 }
4605
4606 size = W_WIDTH(curwin);
4607 if (curwin->w_p_wrap)
4608 {
4609 value = 0;
4610#ifdef SCROLL_PAST_END
4611 max = 0;
4612#else
4613 max = W_WIDTH(curwin) - 1;
4614#endif
4615 }
4616 else
4617 {
4618 value = curwin->w_leftcol;
4619
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02004620 longest_lnum = gui_find_longest_lnum();
4621 max = scroll_line_len(longest_lnum);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004622
Bram Moolenaar071d4272004-06-13 20:20:40 +00004623#ifdef FEAT_VIRTUALEDIT
4624 if (virtual_active())
4625 {
4626 /* May move the cursor even further to the right. */
4627 if (curwin->w_virtcol >= (colnr_T)max)
4628 max = curwin->w_virtcol;
4629 }
4630#endif
4631
4632#ifndef SCROLL_PAST_END
4633 max += W_WIDTH(curwin) - 1;
4634#endif
4635 /* The line number isn't scrolled, thus there is less space when
Bram Moolenaar64486672010-05-16 15:46:46 +02004636 * 'number' or 'relativenumber' is set (also for 'foldcolumn'). */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004637 size -= curwin_col_off();
4638#ifndef SCROLL_PAST_END
4639 max -= curwin_col_off();
4640#endif
4641 }
4642
4643#ifndef SCROLL_PAST_END
4644 if (value > max - size + 1)
4645 value = max - size + 1; /* limit the value to allowable range */
4646#endif
4647
4648#ifdef FEAT_RIGHTLEFT
4649 if (curwin->w_p_rl)
4650 {
4651 value = max + 1 - size - value;
4652 if (value < 0)
4653 {
4654 size += value;
4655 value = 0;
4656 }
4657 }
4658#endif
4659 if (!force && value == gui.bottom_sbar.value && size == gui.bottom_sbar.size
4660 && max == gui.bottom_sbar.max)
4661 return;
4662
4663 gui.bottom_sbar.value = value;
4664 gui.bottom_sbar.size = size;
4665 gui.bottom_sbar.max = max;
4666 gui.prev_wrap = curwin->w_p_wrap;
4667
4668 gui_mch_set_scrollbar_thumb(&gui.bottom_sbar, value, size, max);
4669}
4670
4671/*
4672 * Do a horizontal scroll. Return TRUE if the cursor moved, FALSE otherwise.
4673 */
4674 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004675gui_do_horiz_scroll(long_u leftcol, int compute_longest_lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004676{
4677 /* no wrapping, no scrolling */
4678 if (curwin->w_p_wrap)
4679 return FALSE;
4680
Bram Moolenaar5e109c42010-07-26 22:51:28 +02004681 if (curwin->w_leftcol == (colnr_T)leftcol)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004682 return FALSE;
4683
Bram Moolenaar5e109c42010-07-26 22:51:28 +02004684 curwin->w_leftcol = (colnr_T)leftcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004685
4686 /* When the line of the cursor is too short, move the cursor to the
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02004687 * longest visible line. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004688 if (vim_strchr(p_go, GO_HORSCROLL) == NULL
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02004689 && !virtual_active()
Bram Moolenaar5e109c42010-07-26 22:51:28 +02004690 && (colnr_T)leftcol > scroll_line_len(curwin->w_cursor.lnum))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004691 {
Bram Moolenaar8d9b40e2010-07-25 15:49:07 +02004692 if (compute_longest_lnum)
4693 {
4694 curwin->w_cursor.lnum = gui_find_longest_lnum();
4695 curwin->w_cursor.col = 0;
4696 }
4697 /* Do a sanity check on "longest_lnum", just in case. */
4698 else if (longest_lnum >= curwin->w_topline
4699 && longest_lnum < curwin->w_botline)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004700 {
4701 curwin->w_cursor.lnum = longest_lnum;
4702 curwin->w_cursor.col = 0;
4703 }
4704 }
4705
4706 return leftcol_changed();
4707}
4708
4709/*
4710 * Check that none of the colors are the same as the background color
4711 */
4712 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004713gui_check_colors(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004714{
4715 if (gui.norm_pixel == gui.back_pixel || gui.norm_pixel == INVALCOLOR)
4716 {
4717 gui_set_bg_color((char_u *)"White");
4718 if (gui.norm_pixel == gui.back_pixel || gui.norm_pixel == INVALCOLOR)
4719 gui_set_fg_color((char_u *)"Black");
4720 }
4721}
4722
Bram Moolenaar3918c952005-03-15 22:34:55 +00004723 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004724gui_set_fg_color(char_u *name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004725{
4726 gui.norm_pixel = gui_get_color(name);
4727 hl_set_fg_color_name(vim_strsave(name));
4728}
4729
Bram Moolenaar3918c952005-03-15 22:34:55 +00004730 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004731gui_set_bg_color(char_u *name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004732{
4733 gui.back_pixel = gui_get_color(name);
4734 hl_set_bg_color_name(vim_strsave(name));
4735}
4736
4737/*
4738 * Allocate a color by name.
4739 * Returns INVALCOLOR and gives an error message when failed.
4740 */
4741 guicolor_T
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004742gui_get_color(char_u *name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004743{
4744 guicolor_T t;
4745
4746 if (*name == NUL)
4747 return INVALCOLOR;
4748 t = gui_mch_get_color(name);
Bram Moolenaar843ee412004-06-30 16:16:41 +00004749
Bram Moolenaar071d4272004-06-13 20:20:40 +00004750 if (t == INVALCOLOR
Bram Moolenaar9372a112005-12-06 19:59:18 +00004751#if defined(FEAT_GUI_X11) || defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004752 && gui.in_use
4753#endif
4754 )
4755 EMSG2(_("E254: Cannot allocate color %s"), name);
4756 return t;
4757}
4758
4759/*
4760 * Return the grey value of a color (range 0-255).
4761 */
4762 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004763gui_get_lightness(guicolor_T pixel)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004764{
Bram Moolenaar1b58cdd2016-08-22 23:04:33 +02004765 long_u rgb = (long_u)gui_mch_get_rgb(pixel);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004766
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00004767 return (int)( (((rgb >> 16) & 0xff) * 299)
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00004768 + (((rgb >> 8) & 0xff) * 587)
4769 + ((rgb & 0xff) * 114)) / 1000;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004770}
4771
4772#if defined(FEAT_GUI_X11) || defined(PROTO)
4773 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004774gui_new_scrollbar_colors(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004775{
4776 win_T *wp;
4777
4778 /* Nothing to do if GUI hasn't started yet. */
4779 if (!gui.in_use)
4780 return;
4781
4782 FOR_ALL_WINDOWS(wp)
4783 {
4784 gui_mch_set_scrollbar_colors(&(wp->w_scrollbars[SBAR_LEFT]));
4785 gui_mch_set_scrollbar_colors(&(wp->w_scrollbars[SBAR_RIGHT]));
4786 }
4787 gui_mch_set_scrollbar_colors(&gui.bottom_sbar);
4788}
4789#endif
4790
4791/*
4792 * Call this when focus has changed.
4793 */
4794 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004795gui_focus_change(int in_focus)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004796{
4797/*
4798 * Skip this code to avoid drawing the cursor when debugging and switching
4799 * between the debugger window and gvim.
4800 */
4801#if 1
4802 gui.in_focus = in_focus;
4803 out_flush(); /* make sure output has been written */
4804 gui_update_cursor(TRUE, FALSE);
4805
4806# ifdef FEAT_XIM
4807 xim_set_focus(in_focus);
4808# endif
4809
Bram Moolenaar9c8791f2007-09-05 19:47:23 +00004810 /* Put events in the input queue only when allowed.
4811 * ui_focus_change() isn't called directly, because it invokes
4812 * autocommands and that must not happen asynchronously. */
4813 if (!hold_gui_events)
4814 {
4815 char_u bytes[3];
4816
4817 bytes[0] = CSI;
4818 bytes[1] = KS_EXTRA;
4819 bytes[2] = in_focus ? (int)KE_FOCUSGAINED : (int)KE_FOCUSLOST;
4820 add_to_input_buf(bytes, 3);
4821 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004822#endif
4823}
4824
4825/*
4826 * Called when the mouse moved (but not when dragging).
4827 */
4828 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004829gui_mouse_moved(int x, int y)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004830{
4831 win_T *wp;
Bram Moolenaar7b240602006-06-20 18:39:51 +00004832 char_u st[8];
Bram Moolenaar071d4272004-06-13 20:20:40 +00004833
Bram Moolenaard3667a22006-03-16 21:35:52 +00004834 /* Ignore this while still starting up. */
4835 if (!gui.in_use || gui.starting)
4836 return;
4837
Bram Moolenaar071d4272004-06-13 20:20:40 +00004838#ifdef FEAT_MOUSESHAPE
4839 /* Get window pointer, and update mouse shape as well. */
4840 wp = xy2win(x, y);
4841#endif
4842
4843 /* Only handle this when 'mousefocus' set and ... */
4844 if (p_mousef
4845 && !hold_gui_events /* not holding events */
4846 && (State & (NORMAL|INSERT))/* Normal/Visual/Insert mode */
4847 && State != HITRETURN /* but not hit-return prompt */
4848 && msg_scrolled == 0 /* no scrolled message */
4849 && !need_mouse_correct /* not moving the pointer */
4850 && gui.in_focus) /* gvim in focus */
4851 {
4852 /* Don't move the mouse when it's left or right of the Vim window */
4853 if (x < 0 || x > Columns * gui.char_width)
4854 return;
4855#ifndef FEAT_MOUSESHAPE
4856 wp = xy2win(x, y);
4857#endif
4858 if (wp == curwin || wp == NULL)
4859 return; /* still in the same old window, or none at all */
4860
Bram Moolenaar9c102382006-05-03 21:26:49 +00004861#ifdef FEAT_WINDOWS
4862 /* Ignore position in the tab pages line. */
4863 if (Y_2_ROW(y) < tabline_height())
4864 return;
4865#endif
4866
Bram Moolenaar071d4272004-06-13 20:20:40 +00004867 /*
4868 * format a mouse click on status line input
4869 * ala gui_send_mouse_event(0, x, y, 0, 0);
Bram Moolenaar41bfd302005-04-24 21:59:46 +00004870 * Trick: Use a column number -1, so that get_pseudo_mouse_code() will
4871 * generate a K_LEFTMOUSE_NM key code.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004872 */
4873 if (finish_op)
4874 {
4875 /* abort the current operator first */
4876 st[0] = ESC;
4877 add_to_input_buf(st, 1);
4878 }
4879 st[0] = CSI;
4880 st[1] = KS_MOUSE;
4881 st[2] = KE_FILLER;
4882 st[3] = (char_u)MOUSE_LEFT;
4883 fill_mouse_coord(st + 4,
Bram Moolenaar44a2f922016-03-19 22:11:51 +01004884#ifdef FEAT_WINDOWS
Bram Moolenaar41bfd302005-04-24 21:59:46 +00004885 wp->w_wincol == 0 ? -1 : wp->w_wincol + MOUSE_COLOFF,
Bram Moolenaar071d4272004-06-13 20:20:40 +00004886#else
4887 -1,
4888#endif
4889 wp->w_height + W_WINROW(wp));
4890
4891 add_to_input_buf(st, 8);
4892 st[3] = (char_u)MOUSE_RELEASE;
4893 add_to_input_buf(st, 8);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004894#ifdef FEAT_GUI_GTK
4895 /* Need to wake up the main loop */
4896 if (gtk_main_level() > 0)
4897 gtk_main_quit();
4898#endif
4899 }
4900}
4901
4902/*
4903 * Called when mouse should be moved to window with focus.
4904 */
4905 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004906gui_mouse_correct(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004907{
4908 int x, y;
4909 win_T *wp = NULL;
4910
4911 need_mouse_correct = FALSE;
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00004912
4913 if (!(gui.in_use && p_mousef))
4914 return;
4915
4916 gui_mch_getmouse(&x, &y);
4917 /* Don't move the mouse when it's left or right of the Vim window */
4918 if (x < 0 || x > Columns * gui.char_width)
4919 return;
Bram Moolenaar8798be02006-05-13 10:11:39 +00004920 if (y >= 0
Bram Moolenaar9c102382006-05-03 21:26:49 +00004921# ifdef FEAT_WINDOWS
Bram Moolenaar8798be02006-05-13 10:11:39 +00004922 && Y_2_ROW(y) >= tabline_height()
Bram Moolenaar9c102382006-05-03 21:26:49 +00004923# endif
Bram Moolenaar8798be02006-05-13 10:11:39 +00004924 )
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00004925 wp = xy2win(x, y);
4926 if (wp != curwin && wp != NULL) /* If in other than current window */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004927 {
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00004928 validate_cline_row();
4929 gui_mch_setmouse((int)W_ENDCOL(curwin) * gui.char_width - 3,
4930 (W_WINROW(curwin) + curwin->w_wrow) * gui.char_height
Bram Moolenaar071d4272004-06-13 20:20:40 +00004931 + (gui.char_height) / 2);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004932 }
4933}
4934
4935/*
Bram Moolenaar989a70c2017-08-16 22:46:01 +02004936 * Find window where the mouse pointer "x" / "y" coordinate is in.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004937 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004938 static win_T *
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004939xy2win(int x UNUSED, int y UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004940{
4941#ifdef FEAT_WINDOWS
4942 int row;
4943 int col;
4944 win_T *wp;
4945
4946 row = Y_2_ROW(y);
4947 col = X_2_COL(x);
4948 if (row < 0 || col < 0) /* before first window */
4949 return NULL;
4950 wp = mouse_find_win(&row, &col);
Bram Moolenaar989a70c2017-08-16 22:46:01 +02004951 if (wp == NULL)
4952 return NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004953# ifdef FEAT_MOUSESHAPE
4954 if (State == HITRETURN || State == ASKMORE)
4955 {
4956 if (Y_2_ROW(y) >= msg_row)
4957 update_mouseshape(SHAPE_IDX_MOREL);
4958 else
4959 update_mouseshape(SHAPE_IDX_MORE);
4960 }
4961 else if (row > wp->w_height) /* below status line */
4962 update_mouseshape(SHAPE_IDX_CLINE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004963 else if (!(State & CMDLINE) && W_VSEP_WIDTH(wp) > 0 && col == wp->w_width
Bram Moolenaar910f66f2006-04-05 20:41:53 +00004964 && (row != wp->w_height || !stl_connected(wp)) && msg_scrolled == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004965 update_mouseshape(SHAPE_IDX_VSEP);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004966 else if (!(State & CMDLINE) && W_STATUS_HEIGHT(wp) > 0
Bram Moolenaar910f66f2006-04-05 20:41:53 +00004967 && row == wp->w_height && msg_scrolled == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004968 update_mouseshape(SHAPE_IDX_STATUS);
4969 else
4970 update_mouseshape(-2);
4971# endif
4972 return wp;
4973#else
4974 return firstwin;
4975#endif
4976}
4977
4978/*
4979 * ":gui" and ":gvim": Change from the terminal version to the GUI version.
4980 * File names may be given to redefine the args list.
4981 */
4982 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01004983ex_gui(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004984{
4985 char_u *arg = eap->arg;
4986
4987 /*
4988 * Check for "-f" argument: foreground, don't fork.
4989 * Also don't fork when started with "gvim -f".
4990 * Do fork when using "gui -b".
4991 */
4992 if (arg[0] == '-'
4993 && (arg[1] == 'f' || arg[1] == 'b')
Bram Moolenaar1c465442017-03-12 20:10:05 +01004994 && (arg[2] == NUL || VIM_ISWHITE(arg[2])))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004995 {
4996 gui.dofork = (arg[1] == 'b');
4997 eap->arg = skipwhite(eap->arg + 2);
4998 }
4999 if (!gui.in_use)
5000 {
5001 /* Clear the command. Needed for when forking+exiting, to avoid part
5002 * of the argument ending up after the shell prompt. */
5003 msg_clr_eos_force();
5004 gui_start();
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01005005#ifdef FEAT_JOB_CHANNEL
Bram Moolenaard04a0202016-01-26 23:30:18 +01005006 channel_gui_register_all();
Bram Moolenaar67c53842010-05-22 18:28:27 +02005007#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005008 }
5009 if (!ends_excmd(*eap->arg))
5010 ex_next(eap);
5011}
5012
5013#if ((defined(FEAT_GUI_X11) || defined(FEAT_GUI_GTK) || defined(FEAT_GUI_W32) \
Bram Moolenaar9372a112005-12-06 19:59:18 +00005014 || defined(FEAT_GUI_PHOTON)) && defined(FEAT_TOOLBAR)) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005015/*
5016 * This is shared between Athena, Motif and GTK.
5017 */
Bram Moolenaard25c16e2016-01-29 22:13:30 +01005018static void gfp_setname(char_u *fname, void *cookie);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005019
5020/*
5021 * Callback function for do_in_runtimepath().
5022 */
5023 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01005024gfp_setname(char_u *fname, void *cookie)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005025{
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00005026 char_u *gfp_buffer = cookie;
5027
Bram Moolenaar071d4272004-06-13 20:20:40 +00005028 if (STRLEN(fname) >= MAXPATHL)
5029 *gfp_buffer = NUL;
5030 else
5031 STRCPY(gfp_buffer, fname);
5032}
5033
5034/*
5035 * Find the path of bitmap "name" with extension "ext" in 'runtimepath'.
5036 * Return FAIL for failure and OK if buffer[MAXPATHL] contains the result.
5037 */
5038 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01005039gui_find_bitmap(char_u *name, char_u *buffer, char *ext)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005040{
5041 if (STRLEN(name) > MAXPATHL - 14)
5042 return FAIL;
Bram Moolenaar051b7822005-05-19 21:00:46 +00005043 vim_snprintf((char *)buffer, MAXPATHL, "bitmaps/%s.%s", name, ext);
Bram Moolenaar7f8989d2016-03-12 22:11:39 +01005044 if (do_in_runtimepath(buffer, 0, gfp_setname, buffer) == FAIL
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00005045 || *buffer == NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005046 return FAIL;
5047 return OK;
5048}
5049
Bram Moolenaar0eda7ac2010-06-26 05:38:18 +02005050# if !defined(FEAT_GUI_GTK) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005051/*
5052 * Given the name of the "icon=" argument, try finding the bitmap file for the
5053 * icon. If it is an absolute path name, use it as it is. Otherwise append
5054 * "ext" and search for it in 'runtimepath'.
5055 * The result is put in "buffer[MAXPATHL]". If something fails "buffer"
5056 * contains "name".
5057 */
5058 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01005059gui_find_iconfile(char_u *name, char_u *buffer, char *ext)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005060{
5061 char_u buf[MAXPATHL + 1];
5062
5063 expand_env(name, buffer, MAXPATHL);
5064 if (!mch_isFullName(buffer) && gui_find_bitmap(buffer, buf, ext) == OK)
5065 STRCPY(buffer, buf);
5066}
5067# endif
5068#endif
5069
Bram Moolenaar9372a112005-12-06 19:59:18 +00005070#if defined(FEAT_GUI_GTK) || defined(FEAT_GUI_X11) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005071 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01005072display_errors(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005073{
5074 char_u *p;
5075
5076 if (isatty(2))
5077 fflush(stderr);
5078 else if (error_ga.ga_data != NULL)
5079 {
5080 /* avoid putting up a message box with blanks only */
5081 for (p = (char_u *)error_ga.ga_data; *p != NUL; ++p)
5082 if (!isspace(*p))
5083 {
5084 /* Truncate a very long message, it will go off-screen. */
5085 if (STRLEN(p) > 2000)
5086 STRCPY(p + 2000 - 14, "...(truncated)");
5087 (void)do_dialog(VIM_ERROR, (char_u *)_("Error"),
Bram Moolenaard2c340a2011-01-17 20:08:11 +01005088 p, (char_u *)_("&Ok"), 1, NULL, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005089 break;
5090 }
5091 ga_clear(&error_ga);
5092 }
5093}
5094#endif
5095
5096#if defined(NO_CONSOLE_INPUT) || defined(PROTO)
5097/*
5098 * Return TRUE if still starting up and there is no place to enter text.
5099 * For GTK and X11 we check if stderr is not a tty, which means we were
5100 * (probably) started from the desktop. Also check stdin, "vim >& file" does
5101 * allow typing on stdin.
5102 */
5103 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01005104no_console_input(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005105{
5106 return ((!gui.in_use || gui.starting)
5107# ifndef NO_CONSOLE
5108 && !isatty(0) && !isatty(2)
5109# endif
5110 );
5111}
5112#endif
5113
Bram Moolenaar7171abe2004-10-11 10:06:20 +00005114#if defined(FIND_REPLACE_DIALOG) || defined(FEAT_SUN_WORKSHOP) \
Bram Moolenaarda68cf32006-10-10 15:35:57 +00005115 || defined(NEED_GUI_UPDATE_SCREEN) \
Bram Moolenaar7171abe2004-10-11 10:06:20 +00005116 || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005117/*
5118 * Update the current window and the screen.
5119 */
5120 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01005121gui_update_screen(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005122{
Bram Moolenaarb2c03502010-07-02 20:20:09 +02005123#ifdef FEAT_CONCEAL
5124 linenr_T conceal_old_cursor_line = 0;
5125 linenr_T conceal_new_cursor_line = 0;
5126 int conceal_update_lines = FALSE;
5127#endif
5128
Bram Moolenaar071d4272004-06-13 20:20:40 +00005129 update_topline();
5130 validate_cursor();
Bram Moolenaarb2c03502010-07-02 20:20:09 +02005131
5132#if defined(FEAT_AUTOCMD) || defined(FEAT_CONCEAL)
Bram Moolenaarec80df72008-05-07 19:46:51 +00005133 /* Trigger CursorMoved if the cursor moved. */
Bram Moolenaarb2c03502010-07-02 20:20:09 +02005134 if (!finish_op && (
5135# ifdef FEAT_AUTOCMD
5136 has_cursormoved()
5137# endif
5138# if defined(FEAT_AUTOCMD) && defined(FEAT_CONCEAL)
5139 ||
5140# endif
5141# ifdef FEAT_CONCEAL
Bram Moolenaarf5963f72010-07-23 22:10:27 +02005142 curwin->w_p_cole > 0
Bram Moolenaarb2c03502010-07-02 20:20:09 +02005143# endif
5144 )
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01005145 && !EQUAL_POS(last_cursormoved, curwin->w_cursor))
Bram Moolenaarec80df72008-05-07 19:46:51 +00005146 {
Bram Moolenaarb2c03502010-07-02 20:20:09 +02005147# ifdef FEAT_AUTOCMD
5148 if (has_cursormoved())
5149 apply_autocmds(EVENT_CURSORMOVED, NULL, NULL, FALSE, curbuf);
5150# endif
5151# ifdef FEAT_CONCEAL
Bram Moolenaarf5963f72010-07-23 22:10:27 +02005152 if (curwin->w_p_cole > 0)
Bram Moolenaarb2c03502010-07-02 20:20:09 +02005153 {
5154 conceal_old_cursor_line = last_cursormoved.lnum;
5155 conceal_new_cursor_line = curwin->w_cursor.lnum;
5156 conceal_update_lines = TRUE;
5157 }
5158# endif
Bram Moolenaarec80df72008-05-07 19:46:51 +00005159 last_cursormoved = curwin->w_cursor;
5160 }
5161#endif
Bram Moolenaarb2c03502010-07-02 20:20:09 +02005162
Bram Moolenaar071d4272004-06-13 20:20:40 +00005163 update_screen(0); /* may need to update the screen */
5164 setcursor();
Bram Moolenaarb2c03502010-07-02 20:20:09 +02005165# if defined(FEAT_CONCEAL)
5166 if (conceal_update_lines
Bram Moolenaarf5963f72010-07-23 22:10:27 +02005167 && (conceal_old_cursor_line != conceal_new_cursor_line
5168 || conceal_cursor_line(curwin)
5169 || need_cursor_line_redraw))
Bram Moolenaarb2c03502010-07-02 20:20:09 +02005170 {
Bram Moolenaarf5963f72010-07-23 22:10:27 +02005171 if (conceal_old_cursor_line != conceal_new_cursor_line)
5172 update_single_line(curwin, conceal_old_cursor_line);
Bram Moolenaarb2c03502010-07-02 20:20:09 +02005173 update_single_line(curwin, conceal_new_cursor_line);
5174 curwin->w_valid &= ~VALID_CROW;
5175 }
5176# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005177 out_flush(); /* make sure output has been written */
5178 gui_update_cursor(TRUE, FALSE);
5179 gui_mch_flush();
5180}
5181#endif
5182
Bram Moolenaar7171abe2004-10-11 10:06:20 +00005183#if defined(FIND_REPLACE_DIALOG) || defined(PROTO)
Bram Moolenaard25c16e2016-01-29 22:13:30 +01005184static void concat_esc(garray_T *gap, char_u *text, int what);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005185
5186/*
5187 * Get the text to use in a find/replace dialog. Uses the last search pattern
5188 * if the argument is empty.
5189 * Returns an allocated string.
5190 */
5191 char_u *
Bram Moolenaar66f948e2016-01-30 16:39:25 +01005192get_find_dialog_text(
5193 char_u *arg,
5194 int *wwordp, /* return: TRUE if \< \> found */
5195 int *mcasep) /* return: TRUE if \C found */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005196{
5197 char_u *text;
5198
5199 if (*arg == NUL)
5200 text = last_search_pat();
5201 else
5202 text = arg;
5203 if (text != NULL)
5204 {
5205 text = vim_strsave(text);
5206 if (text != NULL)
5207 {
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00005208 int len = (int)STRLEN(text);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005209 int i;
5210
5211 /* Remove "\V" */
5212 if (len >= 2 && STRNCMP(text, "\\V", 2) == 0)
5213 {
5214 mch_memmove(text, text + 2, (size_t)(len - 1));
5215 len -= 2;
5216 }
5217
5218 /* Recognize "\c" and "\C" and remove. */
5219 if (len >= 2 && *text == '\\' && (text[1] == 'c' || text[1] == 'C'))
5220 {
5221 *mcasep = (text[1] == 'C');
5222 mch_memmove(text, text + 2, (size_t)(len - 1));
5223 len -= 2;
5224 }
5225
5226 /* Recognize "\<text\>" and remove. */
5227 if (len >= 4
5228 && STRNCMP(text, "\\<", 2) == 0
5229 && STRNCMP(text + len - 2, "\\>", 2) == 0)
5230 {
5231 *wwordp = TRUE;
5232 mch_memmove(text, text + 2, (size_t)(len - 4));
5233 text[len - 4] = NUL;
5234 }
5235
5236 /* Recognize "\/" or "\?" and remove. */
5237 for (i = 0; i + 1 < len; ++i)
5238 if (text[i] == '\\' && (text[i + 1] == '/'
5239 || text[i + 1] == '?'))
5240 {
5241 mch_memmove(text + i, text + i + 1, (size_t)(len - i));
5242 --len;
5243 }
5244 }
5245 }
5246 return text;
5247}
5248
5249/*
5250 * Concatenate "text" to grow array "gap", escaping "what" with a backslash.
5251 */
5252 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01005253concat_esc(garray_T *gap, char_u *text, int what)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005254{
5255 while (*text != NUL)
5256 {
5257#ifdef FEAT_MBYTE
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00005258 int l = (*mb_ptr2len)(text);
Bram Moolenaar910f66f2006-04-05 20:41:53 +00005259
Bram Moolenaar071d4272004-06-13 20:20:40 +00005260 if (l > 1)
5261 {
5262 while (--l >= 0)
5263 ga_append(gap, *text++);
5264 continue;
5265 }
5266#endif
5267 if (*text == what)
5268 ga_append(gap, '\\');
5269 ga_append(gap, *text);
5270 ++text;
5271 }
5272}
5273
5274/*
5275 * Handle the press of a button in the find-replace dialog.
5276 * Return TRUE when something was added to the input buffer.
5277 */
5278 int
Bram Moolenaar66f948e2016-01-30 16:39:25 +01005279gui_do_findrepl(
5280 int flags, /* one of FRD_REPLACE, FRD_FINDNEXT, etc. */
5281 char_u *find_text,
5282 char_u *repl_text,
5283 int down) /* Search downwards. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005284{
5285 garray_T ga;
5286 int i;
5287 int type = (flags & FRD_TYPE_MASK);
5288 char_u *p;
Bram Moolenaar7171abe2004-10-11 10:06:20 +00005289 regmatch_T regmatch;
Bram Moolenaar5b8d8fd2005-08-16 23:01:50 +00005290 int save_did_emsg = did_emsg;
Bram Moolenaar9f8650c2009-07-29 09:11:15 +00005291 static int busy = FALSE;
5292
5293 /* When the screen is being updated we should not change buffers and
5294 * windows structures, it may cause freed memory to be used. Also don't
5295 * do this recursively (pressing "Find" quickly several times. */
5296 if (updating_screen || busy)
5297 return FALSE;
5298
5299 /* refuse replace when text cannot be changed */
5300 if ((type == FRD_REPLACE || type == FRD_REPLACEALL) && text_locked())
5301 return FALSE;
5302
5303 busy = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005304
5305 ga_init2(&ga, 1, 100);
Bram Moolenaar7171abe2004-10-11 10:06:20 +00005306 if (type == FRD_REPLACEALL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005307 ga_concat(&ga, (char_u *)"%s/");
5308
5309 ga_concat(&ga, (char_u *)"\\V");
5310 if (flags & FRD_MATCH_CASE)
5311 ga_concat(&ga, (char_u *)"\\C");
5312 else
5313 ga_concat(&ga, (char_u *)"\\c");
5314 if (flags & FRD_WHOLE_WORD)
5315 ga_concat(&ga, (char_u *)"\\<");
5316 if (type == FRD_REPLACEALL || down)
5317 concat_esc(&ga, find_text, '/'); /* escape slashes */
5318 else
5319 concat_esc(&ga, find_text, '?'); /* escape '?' */
5320 if (flags & FRD_WHOLE_WORD)
5321 ga_concat(&ga, (char_u *)"\\>");
5322
5323 if (type == FRD_REPLACEALL)
5324 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00005325 ga_concat(&ga, (char_u *)"/");
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00005326 /* escape / and \ */
5327 p = vim_strsave_escaped(repl_text, (char_u *)"/\\");
5328 if (p != NULL)
5329 ga_concat(&ga, p);
5330 vim_free(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005331 ga_concat(&ga, (char_u *)"/g");
Bram Moolenaar7171abe2004-10-11 10:06:20 +00005332 }
5333 ga_append(&ga, NUL);
5334
5335 if (type == FRD_REPLACE)
5336 {
5337 /* Do the replacement when the text at the cursor matches. Thus no
5338 * replacement is done if the cursor was moved! */
5339 regmatch.regprog = vim_regcomp(ga.ga_data, RE_MAGIC + RE_STRING);
5340 regmatch.rm_ic = 0;
5341 if (regmatch.regprog != NULL)
5342 {
5343 p = ml_get_cursor();
5344 if (vim_regexec_nl(&regmatch, p, (colnr_T)0)
5345 && regmatch.startp[0] == p)
5346 {
5347 /* Clear the command line to remove any old "No match"
5348 * error. */
5349 msg_end_prompt();
5350
5351 if (u_save_cursor() == OK)
5352 {
5353 /* A button was pressed thus undo should be synced. */
Bram Moolenaar779b74b2006-04-10 14:55:34 +00005354 u_sync(FALSE);
Bram Moolenaar7171abe2004-10-11 10:06:20 +00005355
5356 del_bytes((long)(regmatch.endp[0] - regmatch.startp[0]),
Bram Moolenaard35f9712005-12-18 22:02:33 +00005357 FALSE, FALSE);
Bram Moolenaar7171abe2004-10-11 10:06:20 +00005358 ins_str(repl_text);
5359 }
5360 }
5361 else
5362 MSG(_("No match at cursor, finding next"));
Bram Moolenaar473de612013-06-08 18:19:48 +02005363 vim_regfree(regmatch.regprog);
Bram Moolenaar7171abe2004-10-11 10:06:20 +00005364 }
5365 }
5366
5367 if (type == FRD_REPLACEALL)
5368 {
5369 /* A button was pressed, thus undo should be synced. */
Bram Moolenaar779b74b2006-04-10 14:55:34 +00005370 u_sync(FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005371 do_cmdline_cmd(ga.ga_data);
5372 }
5373 else
5374 {
Bram Moolenaarbee666f2016-06-14 20:39:42 +02005375 int searchflags = SEARCH_MSG + SEARCH_MARK;
5376
5377 /* Search for the next match.
5378 * Don't skip text under cursor for single replace. */
5379 if (type == FRD_REPLACE)
5380 searchflags += SEARCH_START;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005381 i = msg_scroll;
Bram Moolenaarcde88542015-08-11 19:14:00 +02005382 (void)do_search(NULL, down ? '/' : '?', ga.ga_data, 1L,
Bram Moolenaarfbd0b0a2017-06-17 18:44:21 +02005383 searchflags, NULL, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005384 msg_scroll = i; /* don't let an error message set msg_scroll */
5385 }
5386
Bram Moolenaar5b8d8fd2005-08-16 23:01:50 +00005387 /* Don't want to pass did_emsg to other code, it may cause disabling
5388 * syntax HL if we were busy redrawing. */
5389 did_emsg = save_did_emsg;
5390
Bram Moolenaar071d4272004-06-13 20:20:40 +00005391 if (State & (NORMAL | INSERT))
5392 {
5393 gui_update_screen(); /* update the screen */
5394 msg_didout = 0; /* overwrite any message */
5395 need_wait_return = FALSE; /* don't wait for return */
5396 }
5397
5398 vim_free(ga.ga_data);
Bram Moolenaar9f8650c2009-07-29 09:11:15 +00005399 busy = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005400 return (ga.ga_len > 0);
5401}
5402
5403#endif
5404
5405#if (defined(FEAT_DND) && defined(FEAT_GUI_GTK)) \
5406 || defined(FEAT_GUI_MSWIN) \
5407 || defined(FEAT_GUI_MAC) \
5408 || defined(PROTO)
5409
5410#ifdef FEAT_WINDOWS
Bram Moolenaard25c16e2016-01-29 22:13:30 +01005411static void gui_wingoto_xy(int x, int y);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005412
5413/*
5414 * Jump to the window at specified point (x, y).
5415 */
5416 static void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01005417gui_wingoto_xy(int x, int y)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005418{
5419 int row = Y_2_ROW(y);
5420 int col = X_2_COL(x);
5421 win_T *wp;
5422
5423 if (row >= 0 && col >= 0)
5424 {
5425 wp = mouse_find_win(&row, &col);
5426 if (wp != NULL && wp != curwin)
5427 win_goto(wp);
5428 }
5429}
5430#endif
5431
5432/*
5433 * Process file drop. Mouse cursor position, key modifiers, name of files
5434 * and count of files are given. Argument "fnames[count]" has full pathnames
5435 * of dropped files, they will be freed in this function, and caller can't use
5436 * fnames after call this function.
5437 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005438 void
Bram Moolenaar66f948e2016-01-30 16:39:25 +01005439gui_handle_drop(
5440 int x UNUSED,
5441 int y UNUSED,
5442 int_u modifiers,
5443 char_u **fnames,
5444 int count)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005445{
5446 int i;
5447 char_u *p;
Bram Moolenaarc236c162008-07-13 17:41:49 +00005448 static int entered = FALSE;
5449
5450 /*
5451 * This function is called by event handlers. Just in case we get a
5452 * second event before the first one is handled, ignore the second one.
5453 * Not sure if this can ever happen, just in case.
5454 */
5455 if (entered)
5456 return;
5457 entered = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005458
5459 /*
5460 * When the cursor is at the command line, add the file names to the
5461 * command line, don't edit the files.
5462 */
5463 if (State & CMDLINE)
5464 {
5465 shorten_filenames(fnames, count);
5466 for (i = 0; i < count; ++i)
5467 {
5468 if (fnames[i] != NULL)
5469 {
5470 if (i > 0)
5471 add_to_input_buf((char_u*)" ", 1);
5472
5473 /* We don't know what command is used thus we can't be sure
5474 * about which characters need to be escaped. Only escape the
5475 * most common ones. */
5476# ifdef BACKSLASH_IN_FILENAME
5477 p = vim_strsave_escaped(fnames[i], (char_u *)" \t\"|");
5478# else
5479 p = vim_strsave_escaped(fnames[i], (char_u *)"\\ \t\"|");
5480# endif
5481 if (p != NULL)
Bram Moolenaar70c2a632007-08-15 18:08:50 +00005482 add_to_input_buf_csi(p, (int)STRLEN(p));
Bram Moolenaar071d4272004-06-13 20:20:40 +00005483 vim_free(p);
5484 vim_free(fnames[i]);
5485 }
5486 }
5487 vim_free(fnames);
5488 }
5489 else
5490 {
5491 /* Go to the window under mouse cursor, then shorten given "fnames" by
5492 * current window, because a window can have local current dir. */
5493# ifdef FEAT_WINDOWS
5494 gui_wingoto_xy(x, y);
5495# endif
5496 shorten_filenames(fnames, count);
5497
5498 /* If Shift held down, remember the first item. */
5499 if ((modifiers & MOUSE_SHIFT) != 0)
5500 p = vim_strsave(fnames[0]);
5501 else
5502 p = NULL;
5503
5504 /* Handle the drop, :edit or :split to get to the file. This also
5505 * frees fnames[]. Skip this if there is only one item it's a
5506 * directory and Shift is held down. */
5507 if (count == 1 && (modifiers & MOUSE_SHIFT) != 0
5508 && mch_isdir(fnames[0]))
5509 {
5510 vim_free(fnames[0]);
5511 vim_free(fnames);
5512 }
5513 else
5514 handle_drop(count, fnames, (modifiers & MOUSE_CTRL) != 0);
5515
5516 /* If Shift held down, change to first file's directory. If the first
5517 * item is a directory, change to that directory (and let the explorer
5518 * plugin show the contents). */
5519 if (p != NULL)
5520 {
5521 if (mch_isdir(p))
5522 {
5523 if (mch_chdir((char *)p) == 0)
5524 shorten_fnames(TRUE);
5525 }
5526 else if (vim_chdirfile(p) == OK)
5527 shorten_fnames(TRUE);
5528 vim_free(p);
5529 }
5530
5531 /* Update the screen display */
5532 update_screen(NOT_VALID);
5533# ifdef FEAT_MENU
5534 gui_update_menus(0);
5535# endif
Bram Moolenaarca7e1f22010-05-22 15:50:12 +02005536#ifdef FEAT_TITLE
5537 maketitle();
5538#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005539 setcursor();
5540 out_flush();
5541 gui_update_cursor(FALSE, FALSE);
5542 gui_mch_flush();
5543 }
Bram Moolenaarc236c162008-07-13 17:41:49 +00005544
5545 entered = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005546}
5547#endif