1 /* vi:set ts=8 sts=4 sw=4 noet:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read a list of people who contributed.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10 #include "vim.h"
11
12 static void cmd_with_count(char *cmd, char_u *bufp, size_t bufsize, long Prenum);
13 static void win_init(win_T *newp, win_T *oldp, int flags);
14 static void win_init_some(win_T *newp, win_T *oldp);
15 static void frame_comp_pos(frame_T *topfrp, int *row, int *col);
16 static void frame_setheight(frame_T *curfrp, int height);
17 static void frame_setwidth(frame_T *curfrp, int width);
18 static void win_exchange(long);
19 static void win_rotate(int, int);
20 static void win_totop(int size, int flags);
21 static void win_equal_rec(win_T *next_curwin, int current, frame_T *topfr, int dir, int col, int row, int width, int height);
22 static void trigger_winclosed(win_T *win);
23 static win_T *win_free_mem(win_T *win, int *dirp, tabpage_T *tp);
24 static frame_T *win_altframe(win_T *win, tabpage_T *tp);
25 static tabpage_T *alt_tabpage(void);
26 static win_T *frame2win(frame_T *frp);
27 static int frame_has_win(frame_T *frp, win_T *wp);
28 static void frame_new_height(frame_T *topfrp, int height, int topfirst, int wfh);
29 static int frame_fixed_height(frame_T *frp);
30 static int frame_fixed_width(frame_T *frp);
31 static void frame_add_statusline(frame_T *frp);
32 static void frame_new_width(frame_T *topfrp, int width, int leftfirst, int wfw);
33 static void frame_add_vsep(frame_T *frp);
34 static int frame_minwidth(frame_T *topfrp, win_T *next_curwin);
35 static void frame_fix_width(win_T *wp);
36 static int win_alloc_firstwin(win_T *oldwin);
37 static void new_frame(win_T *wp);
38 static tabpage_T *alloc_tabpage(void);
39 static int leave_tabpage(buf_T *new_curbuf, int trigger_leave_autocmds);
40 static void enter_tabpage(tabpage_T *tp, buf_T *old_curbuf, int trigger_enter_autocmds, int trigger_leave_autocmds);
41 static void frame_fix_height(win_T *wp);
42 static int frame_minheight(frame_T *topfrp, win_T *next_curwin);
43 static int may_open_tabpage(void);
44 static int win_enter_ext(win_T *wp, int flags);
45 static void win_free(win_T *wp, tabpage_T *tp);
46 static int win_unlisted(win_T *wp);
47 static void win_append(win_T *after, win_T *wp);
48 static void frame_append(frame_T *after, frame_T *frp);
49 static void frame_insert(frame_T *before, frame_T *frp);
50 static void frame_remove(frame_T *frp);
51 static void win_goto_ver(int up, long count);
52 static void win_goto_hor(int left, long count);
53 static void frame_add_height(frame_T *frp, int n);
54 static void last_status_rec(frame_T *fr, int statusline);
55
56 static void make_snapshot_rec(frame_T *fr, frame_T **frp);
57 static void clear_snapshot(tabpage_T *tp, int idx);
58 static void clear_snapshot_rec(frame_T *fr);
59 static int check_snapshot_rec(frame_T *sn, frame_T *fr);
60 static win_T *restore_snapshot_rec(frame_T *sn, frame_T *fr);
61
62 static int frame_check_height(frame_T *topfrp, int height);
63 static int frame_check_width(frame_T *topfrp, int width);
64
65 static win_T *win_alloc(win_T *after, int hidden);
66
67 #define NOWIN (win_T *)-1 // non-existing window
68
69 #define ROWS_AVAIL (Rows - p_ch - tabline_height())
70
71 // flags for win_enter_ext()
72 #define WEE_UNDO_SYNC 0x01
73 #define WEE_CURWIN_INVALID 0x02
74 #define WEE_TRIGGER_NEW_AUTOCMDS 0x04
75 #define WEE_TRIGGER_ENTER_AUTOCMDS 0x08
76 #define WEE_TRIGGER_LEAVE_AUTOCMDS 0x10
77 #define WEE_ALLOW_PARSE_MESSAGES 0x20
78
79 static char *m_onlyone = N_("Already only one window");
80
81 // When non-zero splitting a window is forbidden. Used to avoid that nasty
82 // autocommands mess up the window structure.
83 static int split_disallowed = 0;
84
85 // #define WIN_DEBUG
86 #ifdef WIN_DEBUG
87 /*
88 * Call this method to log the current window layout.
89 */
90 static void
log_frame_layout(frame_T * frame)91 log_frame_layout(frame_T *frame)
92 {
93 ch_log(NULL, "layout %s, wi: %d, he: %d, wwi: %d, whe: %d, id: %d",
94 frame->fr_layout == FR_LEAF ? "LEAF"
95 : frame->fr_layout == FR_ROW ? "ROW" : "COL",
96 frame->fr_width,
97 frame->fr_height,
98 frame->fr_win == NULL ? -1 : frame->fr_win->w_width,
99 frame->fr_win == NULL ? -1 : frame->fr_win->w_height,
100 frame->fr_win == NULL ? -1 : frame->fr_win->w_id);
101 if (frame->fr_child != NULL)
102 {
103 ch_log(NULL, "children");
104 log_frame_layout(frame->fr_child);
105 if (frame->fr_next != NULL)
106 ch_log(NULL, "END of children");
107 }
108 if (frame->fr_next != NULL)
109 log_frame_layout(frame->fr_next);
110 }
111 #endif
112
113 /*
114 * All CTRL-W window commands are handled here, called from normal_cmd().
115 */
116 void
do_window(int nchar,long Prenum,int xchar)117 do_window(
118 int nchar,
119 long Prenum,
120 int xchar) // extra char from ":wincmd gx" or NUL
121 {
122 long Prenum1;
123 win_T *wp;
124 #if defined(FEAT_SEARCHPATH) || defined(FEAT_FIND_ID)
125 char_u *ptr;
126 linenr_T lnum = -1;
127 #endif
128 #ifdef FEAT_FIND_ID
129 int type = FIND_DEFINE;
130 int len;
131 #endif
132 char_u cbuf[40];
133
134 if (ERROR_IF_ANY_POPUP_WINDOW)
135 return;
136
137 #ifdef FEAT_CMDWIN
138 # define CHECK_CMDWIN \
139 do { \
140 if (cmdwin_type != 0) \
141 { \
142 emsg(_(e_invalid_in_cmdline_window)); \
143 return; \
144 } \
145 } while (0)
146 #else
147 # define CHECK_CMDWIN do { /**/ } while (0)
148 #endif
149
150 Prenum1 = Prenum == 0 ? 1 : Prenum;
151
152 switch (nchar)
153 {
154 // split current window in two parts, horizontally
155 case 'S':
156 case Ctrl_S:
157 case 's':
158 CHECK_CMDWIN;
159 reset_VIsual_and_resel(); // stop Visual mode
160 #ifdef FEAT_QUICKFIX
161 // When splitting the quickfix window open a new buffer in it,
162 // don't replicate the quickfix buffer.
163 if (bt_quickfix(curbuf))
164 goto newwindow;
165 #endif
166 #ifdef FEAT_GUI
167 need_mouse_correct = TRUE;
168 #endif
169 (void)win_split((int)Prenum, 0);
170 break;
171
172 // split current window in two parts, vertically
173 case Ctrl_V:
174 case 'v':
175 CHECK_CMDWIN;
176 reset_VIsual_and_resel(); // stop Visual mode
177 #ifdef FEAT_QUICKFIX
178 // When splitting the quickfix window open a new buffer in it,
179 // don't replicate the quickfix buffer.
180 if (bt_quickfix(curbuf))
181 goto newwindow;
182 #endif
183 #ifdef FEAT_GUI
184 need_mouse_correct = TRUE;
185 #endif
186 (void)win_split((int)Prenum, WSP_VERT);
187 break;
188
189 // split current window and edit alternate file
190 case Ctrl_HAT:
191 case '^':
192 CHECK_CMDWIN;
193 reset_VIsual_and_resel(); // stop Visual mode
194
195 if (buflist_findnr(Prenum == 0
196 ? curwin->w_alt_fnum : Prenum) == NULL)
197 {
198 if (Prenum == 0)
199 emsg(_(e_no_alternate_file));
200 else
201 semsg(_("E92: Buffer %ld not found"), Prenum);
202 break;
203 }
204
205 if (!curbuf_locked() && win_split(0, 0) == OK)
206 (void)buflist_getfile(
207 Prenum == 0 ? curwin->w_alt_fnum : Prenum,
208 (linenr_T)0, GETF_ALT, FALSE);
209 break;
210
211 // open new window
212 case Ctrl_N:
213 case 'n':
214 CHECK_CMDWIN;
215 reset_VIsual_and_resel(); // stop Visual mode
216 #ifdef FEAT_QUICKFIX
217 newwindow:
218 #endif
219 if (Prenum)
220 // window height
221 vim_snprintf((char *)cbuf, sizeof(cbuf) - 5, "%ld", Prenum);
222 else
223 cbuf[0] = NUL;
224 #if defined(FEAT_QUICKFIX)
225 if (nchar == 'v' || nchar == Ctrl_V)
226 STRCAT(cbuf, "v");
227 #endif
228 STRCAT(cbuf, "new");
229 do_cmdline_cmd(cbuf);
230 break;
231
232 // quit current window
233 case Ctrl_Q:
234 case 'q':
235 reset_VIsual_and_resel(); // stop Visual mode
236 cmd_with_count("quit", cbuf, sizeof(cbuf), Prenum);
237 do_cmdline_cmd(cbuf);
238 break;
239
240 // close current window
241 case Ctrl_C:
242 case 'c':
243 reset_VIsual_and_resel(); // stop Visual mode
244 cmd_with_count("close", cbuf, sizeof(cbuf), Prenum);
245 do_cmdline_cmd(cbuf);
246 break;
247
248 #if defined(FEAT_QUICKFIX)
249 // close preview window
250 case Ctrl_Z:
251 case 'z':
252 CHECK_CMDWIN;
253 reset_VIsual_and_resel(); // stop Visual mode
254 do_cmdline_cmd((char_u *)"pclose");
255 break;
256
257 // cursor to preview window
258 case 'P':
259 FOR_ALL_WINDOWS(wp)
260 if (wp->w_p_pvw)
261 break;
262 if (wp == NULL)
263 emsg(_("E441: There is no preview window"));
264 else
265 win_goto(wp);
266 break;
267 #endif
268
269 // close all but current window
270 case Ctrl_O:
271 case 'o':
272 CHECK_CMDWIN;
273 reset_VIsual_and_resel(); // stop Visual mode
274 cmd_with_count("only", cbuf, sizeof(cbuf), Prenum);
275 do_cmdline_cmd(cbuf);
276 break;
277
278 // cursor to next window with wrap around
279 case Ctrl_W:
280 case 'w':
281 // cursor to previous window with wrap around
282 case 'W':
283 CHECK_CMDWIN;
284 if (ONE_WINDOW && Prenum != 1) // just one window
285 beep_flush();
286 else
287 {
288 if (Prenum) // go to specified window
289 {
290 for (wp = firstwin; --Prenum > 0; )
291 {
292 if (wp->w_next == NULL)
293 break;
294 else
295 wp = wp->w_next;
296 }
297 }
298 else
299 {
300 if (nchar == 'W') // go to previous window
301 {
302 wp = curwin->w_prev;
303 if (wp == NULL)
304 wp = lastwin; // wrap around
305 }
306 else // go to next window
307 {
308 wp = curwin->w_next;
309 if (wp == NULL)
310 wp = firstwin; // wrap around
311 }
312 }
313 win_goto(wp);
314 }
315 break;
316
317 // cursor to window below
318 case 'j':
319 case K_DOWN:
320 case Ctrl_J:
321 CHECK_CMDWIN;
322 win_goto_ver(FALSE, Prenum1);
323 break;
324
325 // cursor to window above
326 case 'k':
327 case K_UP:
328 case Ctrl_K:
329 CHECK_CMDWIN;
330 win_goto_ver(TRUE, Prenum1);
331 break;
332
333 // cursor to left window
334 case 'h':
335 case K_LEFT:
336 case Ctrl_H:
337 case K_BS:
338 CHECK_CMDWIN;
339 win_goto_hor(TRUE, Prenum1);
340 break;
341
342 // cursor to right window
343 case 'l':
344 case K_RIGHT:
345 case Ctrl_L:
346 CHECK_CMDWIN;
347 win_goto_hor(FALSE, Prenum1);
348 break;
349
350 // move window to new tab page
351 case 'T':
352 CHECK_CMDWIN;
353 if (one_window())
354 msg(_(m_onlyone));
355 else
356 {
357 tabpage_T *oldtab = curtab;
358 tabpage_T *newtab;
359
360 // First create a new tab with the window, then go back to
361 // the old tab and close the window there.
362 wp = curwin;
363 if (win_new_tabpage((int)Prenum) == OK
364 && valid_tabpage(oldtab))
365 {
366 newtab = curtab;
367 goto_tabpage_tp(oldtab, TRUE, TRUE);
368 if (curwin == wp)
369 win_close(curwin, FALSE);
370 if (valid_tabpage(newtab))
371 goto_tabpage_tp(newtab, TRUE, TRUE);
372 }
373 }
374 break;
375
376 // cursor to top-left window
377 case 't':
378 case Ctrl_T:
379 win_goto(firstwin);
380 break;
381
382 // cursor to bottom-right window
383 case 'b':
384 case Ctrl_B:
385 win_goto(lastwin);
386 break;
387
388 // cursor to last accessed (previous) window
389 case 'p':
390 case Ctrl_P:
391 if (!win_valid(prevwin))
392 beep_flush();
393 else
394 win_goto(prevwin);
395 break;
396
397 // exchange current and next window
398 case 'x':
399 case Ctrl_X:
400 CHECK_CMDWIN;
401 win_exchange(Prenum);
402 break;
403
404 // rotate windows downwards
405 case Ctrl_R:
406 case 'r':
407 CHECK_CMDWIN;
408 reset_VIsual_and_resel(); // stop Visual mode
409 win_rotate(FALSE, (int)Prenum1); // downwards
410 break;
411
412 // rotate windows upwards
413 case 'R':
414 CHECK_CMDWIN;
415 reset_VIsual_and_resel(); // stop Visual mode
416 win_rotate(TRUE, (int)Prenum1); // upwards
417 break;
418
419 // move window to the very top/bottom/left/right
420 case 'K':
421 case 'J':
422 case 'H':
423 case 'L':
424 CHECK_CMDWIN;
425 win_totop((int)Prenum,
426 ((nchar == 'H' || nchar == 'L') ? WSP_VERT : 0)
427 | ((nchar == 'H' || nchar == 'K') ? WSP_TOP : WSP_BOT));
428 break;
429
430 // make all windows the same height
431 case '=':
432 #ifdef FEAT_GUI
433 need_mouse_correct = TRUE;
434 #endif
435 win_equal(NULL, FALSE, 'b');
436 break;
437
438 // increase current window height
439 case '+':
440 #ifdef FEAT_GUI
441 need_mouse_correct = TRUE;
442 #endif
443 win_setheight(curwin->w_height + (int)Prenum1);
444 break;
445
446 // decrease current window height
447 case '-':
448 #ifdef FEAT_GUI
449 need_mouse_correct = TRUE;
450 #endif
451 win_setheight(curwin->w_height - (int)Prenum1);
452 break;
453
454 // set current window height
455 case Ctrl__:
456 case '_':
457 #ifdef FEAT_GUI
458 need_mouse_correct = TRUE;
459 #endif
460 win_setheight(Prenum ? (int)Prenum : 9999);
461 break;
462
463 // increase current window width
464 case '>':
465 #ifdef FEAT_GUI
466 need_mouse_correct = TRUE;
467 #endif
468 win_setwidth(curwin->w_width + (int)Prenum1);
469 break;
470
471 // decrease current window width
472 case '<':
473 #ifdef FEAT_GUI
474 need_mouse_correct = TRUE;
475 #endif
476 win_setwidth(curwin->w_width - (int)Prenum1);
477 break;
478
479 // set current window width
480 case '|':
481 #ifdef FEAT_GUI
482 need_mouse_correct = TRUE;
483 #endif
484 win_setwidth(Prenum != 0 ? (int)Prenum : 9999);
485 break;
486
487 // jump to tag and split window if tag exists (in preview window)
488 #if defined(FEAT_QUICKFIX)
489 case '}':
490 CHECK_CMDWIN;
491 if (Prenum)
492 g_do_tagpreview = Prenum;
493 else
494 g_do_tagpreview = p_pvh;
495 #endif
496 // FALLTHROUGH
497 case ']':
498 case Ctrl_RSB:
499 CHECK_CMDWIN;
500 // keep Visual mode, can select words to use as a tag
501 if (Prenum)
502 postponed_split = Prenum;
503 else
504 postponed_split = -1;
505 #ifdef FEAT_QUICKFIX
506 if (nchar != '}')
507 g_do_tagpreview = 0;
508 #endif
509
510 // Execute the command right here, required when "wincmd ]"
511 // was used in a function.
512 do_nv_ident(Ctrl_RSB, NUL);
513 break;
514
515 #ifdef FEAT_SEARCHPATH
516 // edit file name under cursor in a new window
517 case 'f':
518 case 'F':
519 case Ctrl_F:
520 wingotofile:
521 CHECK_CMDWIN;
522
523 ptr = grab_file_name(Prenum1, &lnum);
524 if (ptr != NULL)
525 {
526 tabpage_T *oldtab = curtab;
527 win_T *oldwin = curwin;
528 # ifdef FEAT_GUI
529 need_mouse_correct = TRUE;
530 # endif
531 setpcmark();
532 if (win_split(0, 0) == OK)
533 {
534 RESET_BINDING(curwin);
535 if (do_ecmd(0, ptr, NULL, NULL, ECMD_LASTL,
536 ECMD_HIDE, NULL) == FAIL)
537 {
538 // Failed to open the file, close the window
539 // opened for it.
540 win_close(curwin, FALSE);
541 goto_tabpage_win(oldtab, oldwin);
542 }
543 else if (nchar == 'F' && lnum >= 0)
544 {
545 curwin->w_cursor.lnum = lnum;
546 check_cursor_lnum();
547 beginline(BL_SOL | BL_FIX);
548 }
549 }
550 vim_free(ptr);
551 }
552 break;
553 #endif
554
555 #ifdef FEAT_FIND_ID
556 // Go to the first occurrence of the identifier under cursor along path in a
557 // new window -- webb
558 case 'i': // Go to any match
559 case Ctrl_I:
560 type = FIND_ANY;
561 // FALLTHROUGH
562 case 'd': // Go to definition, using 'define'
563 case Ctrl_D:
564 CHECK_CMDWIN;
565 if ((len = find_ident_under_cursor(&ptr, FIND_IDENT)) == 0)
566 break;
567 find_pattern_in_path(ptr, 0, len, TRUE,
568 Prenum == 0 ? TRUE : FALSE, type,
569 Prenum1, ACTION_SPLIT, (linenr_T)1, (linenr_T)MAXLNUM);
570 curwin->w_set_curswant = TRUE;
571 break;
572 #endif
573
574 // Quickfix window only: view the result under the cursor in a new split.
575 #if defined(FEAT_QUICKFIX)
576 case K_KENTER:
577 case CAR:
578 if (bt_quickfix(curbuf))
579 qf_view_result(TRUE);
580 break;
581 #endif
582
583 // CTRL-W g extended commands
584 case 'g':
585 case Ctrl_G:
586 CHECK_CMDWIN;
587 #ifdef USE_ON_FLY_SCROLL
588 dont_scroll = TRUE; // disallow scrolling here
589 #endif
590 ++no_mapping;
591 ++allow_keys; // no mapping for xchar, but allow key codes
592 if (xchar == NUL)
593 xchar = plain_vgetc();
594 LANGMAP_ADJUST(xchar, TRUE);
595 --no_mapping;
596 --allow_keys;
597 #ifdef FEAT_CMDL_INFO
598 (void)add_to_showcmd(xchar);
599 #endif
600 switch (xchar)
601 {
602 #if defined(FEAT_QUICKFIX)
603 case '}':
604 xchar = Ctrl_RSB;
605 if (Prenum)
606 g_do_tagpreview = Prenum;
607 else
608 g_do_tagpreview = p_pvh;
609 #endif
610 // FALLTHROUGH
611 case ']':
612 case Ctrl_RSB:
613 // keep Visual mode, can select words to use as a tag
614 if (Prenum)
615 postponed_split = Prenum;
616 else
617 postponed_split = -1;
618
619 // Execute the command right here, required when
620 // "wincmd g}" was used in a function.
621 do_nv_ident('g', xchar);
622 break;
623
624 #ifdef FEAT_SEARCHPATH
625 case 'f': // CTRL-W gf: "gf" in a new tab page
626 case 'F': // CTRL-W gF: "gF" in a new tab page
627 cmdmod.cmod_tab = tabpage_index(curtab) + 1;
628 nchar = xchar;
629 goto wingotofile;
630 #endif
631 case 't': // CTRL-W gt: go to next tab page
632 goto_tabpage((int)Prenum);
633 break;
634
635 case 'T': // CTRL-W gT: go to previous tab page
636 goto_tabpage(-(int)Prenum1);
637 break;
638
639 case TAB: // CTRL-W g<Tab>: go to last used tab page
640 if (goto_tabpage_lastused() == FAIL)
641 beep_flush();
642 break;
643
644 default:
645 beep_flush();
646 break;
647 }
648 break;
649
650 default: beep_flush();
651 break;
652 }
653 }
654
655 /*
656 * Figure out the address type for ":wincmd".
657 */
658 void
get_wincmd_addr_type(char_u * arg,exarg_T * eap)659 get_wincmd_addr_type(char_u *arg, exarg_T *eap)
660 {
661 switch (*arg)
662 {
663 case 'S':
664 case Ctrl_S:
665 case 's':
666 case Ctrl_N:
667 case 'n':
668 case 'j':
669 case Ctrl_J:
670 case 'k':
671 case Ctrl_K:
672 case 'T':
673 case Ctrl_R:
674 case 'r':
675 case 'R':
676 case 'K':
677 case 'J':
678 case '+':
679 case '-':
680 case Ctrl__:
681 case '_':
682 case '|':
683 case ']':
684 case Ctrl_RSB:
685 case 'g':
686 case Ctrl_G:
687 case Ctrl_V:
688 case 'v':
689 case 'h':
690 case Ctrl_H:
691 case 'l':
692 case Ctrl_L:
693 case 'H':
694 case 'L':
695 case '>':
696 case '<':
697 #if defined(FEAT_QUICKFIX)
698 case '}':
699 #endif
700 #ifdef FEAT_SEARCHPATH
701 case 'f':
702 case 'F':
703 case Ctrl_F:
704 #endif
705 #ifdef FEAT_FIND_ID
706 case 'i':
707 case Ctrl_I:
708 case 'd':
709 case Ctrl_D:
710 #endif
711 // window size or any count
712 eap->addr_type = ADDR_OTHER;
713 break;
714
715 case Ctrl_HAT:
716 case '^':
717 // buffer number
718 eap->addr_type = ADDR_BUFFERS;
719 break;
720
721 case Ctrl_Q:
722 case 'q':
723 case Ctrl_C:
724 case 'c':
725 case Ctrl_O:
726 case 'o':
727 case Ctrl_W:
728 case 'w':
729 case 'W':
730 case 'x':
731 case Ctrl_X:
732 // window number
733 eap->addr_type = ADDR_WINDOWS;
734 break;
735
736 #if defined(FEAT_QUICKFIX)
737 case Ctrl_Z:
738 case 'z':
739 case 'P':
740 #endif
741 case 't':
742 case Ctrl_T:
743 case 'b':
744 case Ctrl_B:
745 case 'p':
746 case Ctrl_P:
747 case '=':
748 case CAR:
749 // no count
750 eap->addr_type = ADDR_NONE;
751 break;
752 }
753 }
754
755 static void
cmd_with_count(char * cmd,char_u * bufp,size_t bufsize,long Prenum)756 cmd_with_count(
757 char *cmd,
758 char_u *bufp,
759 size_t bufsize,
760 long Prenum)
761 {
762 if (Prenum > 0)
763 vim_snprintf((char *)bufp, bufsize, "%s %ld", cmd, Prenum);
764 else
765 STRCPY(bufp, cmd);
766 }
767
768 /*
769 * If "split_disallowed" is set given an error and return FAIL.
770 * Otherwise return OK.
771 */
772 static int
check_split_disallowed()773 check_split_disallowed()
774 {
775 if (split_disallowed > 0)
776 {
777 emsg(_("E242: Can't split a window while closing another"));
778 return FAIL;
779 }
780 if (curwin->w_buffer->b_locked_split)
781 {
782 emsg(_(e_cannot_split_window_when_closing_buffer));
783 return FAIL;
784 }
785 return OK;
786 }
787
788 /*
789 * split the current window, implements CTRL-W s and :split
790 *
791 * "size" is the height or width for the new window, 0 to use half of current
792 * height or width.
793 *
794 * "flags":
795 * WSP_ROOM: require enough room for new window
796 * WSP_VERT: vertical split.
797 * WSP_TOP: open window at the top-left of the shell (help window).
798 * WSP_BOT: open window at the bottom-right of the shell (quickfix window).
799 * WSP_HELP: creating the help window, keep layout snapshot
800 *
801 * return FAIL for failure, OK otherwise
802 */
803 int
win_split(int size,int flags)804 win_split(int size, int flags)
805 {
806 if (ERROR_IF_ANY_POPUP_WINDOW)
807 return FAIL;
808
809 if (check_split_disallowed() == FAIL)
810 return FAIL;
811
812 // When the ":tab" modifier was used open a new tab page instead.
813 if (may_open_tabpage() == OK)
814 return OK;
815
816 // Add flags from ":vertical", ":topleft" and ":botright".
817 flags |= cmdmod.cmod_split;
818 if ((flags & WSP_TOP) && (flags & WSP_BOT))
819 {
820 emsg(_("E442: Can't split topleft and botright at the same time"));
821 return FAIL;
822 }
823
824 // When creating the help window make a snapshot of the window layout.
825 // Otherwise clear the snapshot, it's now invalid.
826 if (flags & WSP_HELP)
827 make_snapshot(SNAP_HELP_IDX);
828 else
829 clear_snapshot(curtab, SNAP_HELP_IDX);
830
831 return win_split_ins(size, flags, NULL, 0);
832 }
833
834 /*
835 * When "new_wp" is NULL: split the current window in two.
836 * When "new_wp" is not NULL: insert this window at the far
837 * top/left/right/bottom.
838 * return FAIL for failure, OK otherwise
839 */
840 int
win_split_ins(int size,int flags,win_T * new_wp,int dir)841 win_split_ins(
842 int size,
843 int flags,
844 win_T *new_wp,
845 int dir)
846 {
847 win_T *wp = new_wp;
848 win_T *oldwin;
849 int new_size = size;
850 int i;
851 int need_status = 0;
852 int do_equal = FALSE;
853 int needed;
854 int available;
855 int oldwin_height = 0;
856 int layout;
857 frame_T *frp, *curfrp, *frp2, *prevfrp;
858 int before;
859 int minheight;
860 int wmh1;
861 int did_set_fraction = FALSE;
862
863 if (flags & WSP_TOP)
864 oldwin = firstwin;
865 else if (flags & WSP_BOT)
866 oldwin = lastwin;
867 else
868 oldwin = curwin;
869
870 // add a status line when p_ls == 1 and splitting the first window
871 if (ONE_WINDOW && p_ls == 1 && oldwin->w_status_height == 0)
872 {
873 if (VISIBLE_HEIGHT(oldwin) <= p_wmh && new_wp == NULL)
874 {
875 emsg(_(e_not_enough_room));
876 return FAIL;
877 }
878 need_status = STATUS_HEIGHT;
879 }
880
881 #ifdef FEAT_GUI
882 // May be needed for the scrollbars that are going to change.
883 if (gui.in_use)
884 out_flush();
885 #endif
886
887 if (flags & WSP_VERT)
888 {
889 int wmw1;
890 int minwidth;
891
892 layout = FR_ROW;
893
894 /*
895 * Check if we are able to split the current window and compute its
896 * width.
897 */
898 // Current window requires at least 1 space.
899 wmw1 = (p_wmw == 0 ? 1 : p_wmw);
900 needed = wmw1 + 1;
901 if (flags & WSP_ROOM)
902 needed += p_wiw - wmw1;
903 if (flags & (WSP_BOT | WSP_TOP))
904 {
905 minwidth = frame_minwidth(topframe, NOWIN);
906 available = topframe->fr_width;
907 needed += minwidth;
908 }
909 else if (p_ea)
910 {
911 minwidth = frame_minwidth(oldwin->w_frame, NOWIN);
912 prevfrp = oldwin->w_frame;
913 for (frp = oldwin->w_frame->fr_parent; frp != NULL;
914 frp = frp->fr_parent)
915 {
916 if (frp->fr_layout == FR_ROW)
917 FOR_ALL_FRAMES(frp2, frp->fr_child)
918 if (frp2 != prevfrp)
919 minwidth += frame_minwidth(frp2, NOWIN);
920 prevfrp = frp;
921 }
922 available = topframe->fr_width;
923 needed += minwidth;
924 }
925 else
926 {
927 minwidth = frame_minwidth(oldwin->w_frame, NOWIN);
928 available = oldwin->w_frame->fr_width;
929 needed += minwidth;
930 }
931 if (available < needed && new_wp == NULL)
932 {
933 emsg(_(e_not_enough_room));
934 return FAIL;
935 }
936 if (new_size == 0)
937 new_size = oldwin->w_width / 2;
938 if (new_size > available - minwidth - 1)
939 new_size = available - minwidth - 1;
940 if (new_size < wmw1)
941 new_size = wmw1;
942
943 // if it doesn't fit in the current window, need win_equal()
944 if (oldwin->w_width - new_size - 1 < p_wmw)
945 do_equal = TRUE;
946
947 // We don't like to take lines for the new window from a
948 // 'winfixwidth' window. Take them from a window to the left or right
949 // instead, if possible. Add one for the separator.
950 if (oldwin->w_p_wfw)
951 win_setwidth_win(oldwin->w_width + new_size + 1, oldwin);
952
953 // Only make all windows the same width if one of them (except oldwin)
954 // is wider than one of the split windows.
955 if (!do_equal && p_ea && size == 0 && *p_ead != 'v'
956 && oldwin->w_frame->fr_parent != NULL)
957 {
958 frp = oldwin->w_frame->fr_parent->fr_child;
959 while (frp != NULL)
960 {
961 if (frp->fr_win != oldwin && frp->fr_win != NULL
962 && (frp->fr_win->w_width > new_size
963 || frp->fr_win->w_width > oldwin->w_width
964 - new_size - 1))
965 {
966 do_equal = TRUE;
967 break;
968 }
969 frp = frp->fr_next;
970 }
971 }
972 }
973 else
974 {
975 layout = FR_COL;
976
977 /*
978 * Check if we are able to split the current window and compute its
979 * height.
980 */
981 // Current window requires at least 1 space.
982 wmh1 = (p_wmh == 0 ? 1 : p_wmh) + WINBAR_HEIGHT(curwin);
983 needed = wmh1 + STATUS_HEIGHT;
984 if (flags & WSP_ROOM)
985 needed += p_wh - wmh1;
986 if (flags & (WSP_BOT | WSP_TOP))
987 {
988 minheight = frame_minheight(topframe, NOWIN) + need_status;
989 available = topframe->fr_height;
990 needed += minheight;
991 }
992 else if (p_ea)
993 {
994 minheight = frame_minheight(oldwin->w_frame, NOWIN) + need_status;
995 prevfrp = oldwin->w_frame;
996 for (frp = oldwin->w_frame->fr_parent; frp != NULL;
997 frp = frp->fr_parent)
998 {
999 if (frp->fr_layout == FR_COL)
1000 FOR_ALL_FRAMES(frp2, frp->fr_child)
1001 if (frp2 != prevfrp)
1002 minheight += frame_minheight(frp2, NOWIN);
1003 prevfrp = frp;
1004 }
1005 available = topframe->fr_height;
1006 needed += minheight;
1007 }
1008 else
1009 {
1010 minheight = frame_minheight(oldwin->w_frame, NOWIN) + need_status;
1011 available = oldwin->w_frame->fr_height;
1012 needed += minheight;
1013 }
1014 if (available < needed && new_wp == NULL)
1015 {
1016 emsg(_(e_not_enough_room));
1017 return FAIL;
1018 }
1019 oldwin_height = oldwin->w_height;
1020 if (need_status)
1021 {
1022 oldwin->w_status_height = STATUS_HEIGHT;
1023 oldwin_height -= STATUS_HEIGHT;
1024 }
1025 if (new_size == 0)
1026 new_size = oldwin_height / 2;
1027 if (new_size > available - minheight - STATUS_HEIGHT)
1028 new_size = available - minheight - STATUS_HEIGHT;
1029 if (new_size < wmh1)
1030 new_size = wmh1;
1031
1032 // if it doesn't fit in the current window, need win_equal()
1033 if (oldwin_height - new_size - STATUS_HEIGHT < p_wmh)
1034 do_equal = TRUE;
1035
1036 // We don't like to take lines for the new window from a
1037 // 'winfixheight' window. Take them from a window above or below
1038 // instead, if possible.
1039 if (oldwin->w_p_wfh)
1040 {
1041 // Set w_fraction now so that the cursor keeps the same relative
1042 // vertical position using the old height.
1043 set_fraction(oldwin);
1044 did_set_fraction = TRUE;
1045
1046 win_setheight_win(oldwin->w_height + new_size + STATUS_HEIGHT,
1047 oldwin);
1048 oldwin_height = oldwin->w_height;
1049 if (need_status)
1050 oldwin_height -= STATUS_HEIGHT;
1051 }
1052
1053 // Only make all windows the same height if one of them (except oldwin)
1054 // is higher than one of the split windows.
1055 if (!do_equal && p_ea && size == 0 && *p_ead != 'h'
1056 && oldwin->w_frame->fr_parent != NULL)
1057 {
1058 frp = oldwin->w_frame->fr_parent->fr_child;
1059 while (frp != NULL)
1060 {
1061 if (frp->fr_win != oldwin && frp->fr_win != NULL
1062 && (frp->fr_win->w_height > new_size
1063 || frp->fr_win->w_height > oldwin_height - new_size
1064 - STATUS_HEIGHT))
1065 {
1066 do_equal = TRUE;
1067 break;
1068 }
1069 frp = frp->fr_next;
1070 }
1071 }
1072 }
1073
1074 /*
1075 * allocate new window structure and link it in the window list
1076 */
1077 if ((flags & WSP_TOP) == 0
1078 && ((flags & WSP_BOT)
1079 || (flags & WSP_BELOW)
1080 || (!(flags & WSP_ABOVE)
1081 && ( (flags & WSP_VERT) ? p_spr : p_sb))))
1082 {
1083 // new window below/right of current one
1084 if (new_wp == NULL)
1085 wp = win_alloc(oldwin, FALSE);
1086 else
1087 win_append(oldwin, wp);
1088 }
1089 else
1090 {
1091 if (new_wp == NULL)
1092 wp = win_alloc(oldwin->w_prev, FALSE);
1093 else
1094 win_append(oldwin->w_prev, wp);
1095 }
1096
1097 if (new_wp == NULL)
1098 {
1099 if (wp == NULL)
1100 return FAIL;
1101
1102 new_frame(wp);
1103 if (wp->w_frame == NULL)
1104 {
1105 win_free(wp, NULL);
1106 return FAIL;
1107 }
1108
1109 // make the contents of the new window the same as the current one
1110 win_init(wp, curwin, flags);
1111 }
1112
1113 /*
1114 * Reorganise the tree of frames to insert the new window.
1115 */
1116 if (flags & (WSP_TOP | WSP_BOT))
1117 {
1118 if ((topframe->fr_layout == FR_COL && (flags & WSP_VERT) == 0)
1119 || (topframe->fr_layout == FR_ROW && (flags & WSP_VERT) != 0))
1120 {
1121 curfrp = topframe->fr_child;
1122 if (flags & WSP_BOT)
1123 while (curfrp->fr_next != NULL)
1124 curfrp = curfrp->fr_next;
1125 }
1126 else
1127 curfrp = topframe;
1128 before = (flags & WSP_TOP);
1129 }
1130 else
1131 {
1132 curfrp = oldwin->w_frame;
1133 if (flags & WSP_BELOW)
1134 before = FALSE;
1135 else if (flags & WSP_ABOVE)
1136 before = TRUE;
1137 else if (flags & WSP_VERT)
1138 before = !p_spr;
1139 else
1140 before = !p_sb;
1141 }
1142 if (curfrp->fr_parent == NULL || curfrp->fr_parent->fr_layout != layout)
1143 {
1144 // Need to create a new frame in the tree to make a branch.
1145 frp = ALLOC_CLEAR_ONE(frame_T);
1146 *frp = *curfrp;
1147 curfrp->fr_layout = layout;
1148 frp->fr_parent = curfrp;
1149 frp->fr_next = NULL;
1150 frp->fr_prev = NULL;
1151 curfrp->fr_child = frp;
1152 curfrp->fr_win = NULL;
1153 curfrp = frp;
1154 if (frp->fr_win != NULL)
1155 oldwin->w_frame = frp;
1156 else
1157 FOR_ALL_FRAMES(frp, frp->fr_child)
1158 frp->fr_parent = curfrp;
1159 }
1160
1161 if (new_wp == NULL)
1162 frp = wp->w_frame;
1163 else
1164 frp = new_wp->w_frame;
1165 frp->fr_parent = curfrp->fr_parent;
1166
1167 // Insert the new frame at the right place in the frame list.
1168 if (before)
1169 frame_insert(curfrp, frp);
1170 else
1171 frame_append(curfrp, frp);
1172
1173 // Set w_fraction now so that the cursor keeps the same relative
1174 // vertical position.
1175 if (!did_set_fraction)
1176 set_fraction(oldwin);
1177 wp->w_fraction = oldwin->w_fraction;
1178
1179 if (flags & WSP_VERT)
1180 {
1181 wp->w_p_scr = curwin->w_p_scr;
1182
1183 if (need_status)
1184 {
1185 win_new_height(oldwin, oldwin->w_height - 1);
1186 oldwin->w_status_height = need_status;
1187 }
1188 if (flags & (WSP_TOP | WSP_BOT))
1189 {
1190 // set height and row of new window to full height
1191 wp->w_winrow = tabline_height();
1192 win_new_height(wp, curfrp->fr_height - (p_ls > 0)
1193 - WINBAR_HEIGHT(wp));
1194 wp->w_status_height = (p_ls > 0);
1195 }
1196 else
1197 {
1198 // height and row of new window is same as current window
1199 wp->w_winrow = oldwin->w_winrow;
1200 win_new_height(wp, VISIBLE_HEIGHT(oldwin));
1201 wp->w_status_height = oldwin->w_status_height;
1202 }
1203 frp->fr_height = curfrp->fr_height;
1204
1205 // "new_size" of the current window goes to the new window, use
1206 // one column for the vertical separator
1207 win_new_width(wp, new_size);
1208 if (before)
1209 wp->w_vsep_width = 1;
1210 else
1211 {
1212 wp->w_vsep_width = oldwin->w_vsep_width;
1213 oldwin->w_vsep_width = 1;
1214 }
1215 if (flags & (WSP_TOP | WSP_BOT))
1216 {
1217 if (flags & WSP_BOT)
1218 frame_add_vsep(curfrp);
1219 // Set width of neighbor frame
1220 frame_new_width(curfrp, curfrp->fr_width
1221 - (new_size + ((flags & WSP_TOP) != 0)), flags & WSP_TOP,
1222 FALSE);
1223 }
1224 else
1225 win_new_width(oldwin, oldwin->w_width - (new_size + 1));
1226 if (before) // new window left of current one
1227 {
1228 wp->w_wincol = oldwin->w_wincol;
1229 oldwin->w_wincol += new_size + 1;
1230 }
1231 else // new window right of current one
1232 wp->w_wincol = oldwin->w_wincol + oldwin->w_width + 1;
1233 frame_fix_width(oldwin);
1234 frame_fix_width(wp);
1235 }
1236 else
1237 {
1238 // width and column of new window is same as current window
1239 if (flags & (WSP_TOP | WSP_BOT))
1240 {
1241 wp->w_wincol = 0;
1242 win_new_width(wp, Columns);
1243 wp->w_vsep_width = 0;
1244 }
1245 else
1246 {
1247 wp->w_wincol = oldwin->w_wincol;
1248 win_new_width(wp, oldwin->w_width);
1249 wp->w_vsep_width = oldwin->w_vsep_width;
1250 }
1251 frp->fr_width = curfrp->fr_width;
1252
1253 // "new_size" of the current window goes to the new window, use
1254 // one row for the status line
1255 win_new_height(wp, new_size);
1256 if (flags & (WSP_TOP | WSP_BOT))
1257 {
1258 int new_fr_height = curfrp->fr_height - new_size
1259 + WINBAR_HEIGHT(wp) ;
1260
1261 if (!((flags & WSP_BOT) && p_ls == 0))
1262 new_fr_height -= STATUS_HEIGHT;
1263 frame_new_height(curfrp, new_fr_height, flags & WSP_TOP, FALSE);
1264 }
1265 else
1266 win_new_height(oldwin, oldwin_height - (new_size + STATUS_HEIGHT));
1267 if (before) // new window above current one
1268 {
1269 wp->w_winrow = oldwin->w_winrow;
1270 wp->w_status_height = STATUS_HEIGHT;
1271 oldwin->w_winrow += wp->w_height + STATUS_HEIGHT;
1272 }
1273 else // new window below current one
1274 {
1275 wp->w_winrow = oldwin->w_winrow + VISIBLE_HEIGHT(oldwin)
1276 + STATUS_HEIGHT;
1277 wp->w_status_height = oldwin->w_status_height;
1278 if (!(flags & WSP_BOT))
1279 oldwin->w_status_height = STATUS_HEIGHT;
1280 }
1281 if (flags & WSP_BOT)
1282 frame_add_statusline(curfrp);
1283 frame_fix_height(wp);
1284 frame_fix_height(oldwin);
1285 }
1286
1287 if (flags & (WSP_TOP | WSP_BOT))
1288 (void)win_comp_pos();
1289
1290 // Both windows need redrawing. Update all status lines, in case they
1291 // show something related to the window count or position.
1292 redraw_win_later(wp, NOT_VALID);
1293 redraw_win_later(oldwin, NOT_VALID);
1294 status_redraw_all();
1295
1296 if (need_status)
1297 {
1298 msg_row = Rows - 1;
1299 msg_col = sc_col;
1300 msg_clr_eos_force(); // Old command/ruler may still be there
1301 comp_col();
1302 msg_row = Rows - 1;
1303 msg_col = 0; // put position back at start of line
1304 }
1305
1306 /*
1307 * equalize the window sizes.
1308 */
1309 if (do_equal || dir != 0)
1310 win_equal(wp, TRUE,
1311 (flags & WSP_VERT) ? (dir == 'v' ? 'b' : 'h')
1312 : dir == 'h' ? 'b' : 'v');
1313
1314 // Don't change the window height/width to 'winheight' / 'winwidth' if a
1315 // size was given.
1316 if (flags & WSP_VERT)
1317 {
1318 i = p_wiw;
1319 if (size != 0)
1320 p_wiw = size;
1321
1322 # ifdef FEAT_GUI
1323 // When 'guioptions' includes 'L' or 'R' may have to add scrollbars.
1324 if (gui.in_use)
1325 gui_init_which_components(NULL);
1326 # endif
1327 }
1328 else
1329 {
1330 i = p_wh;
1331 if (size != 0)
1332 p_wh = size;
1333 }
1334
1335 #ifdef FEAT_JUMPLIST
1336 // Keep same changelist position in new window.
1337 wp->w_changelistidx = oldwin->w_changelistidx;
1338 #endif
1339
1340 /*
1341 * make the new window the current window
1342 */
1343 (void)win_enter_ext(wp, WEE_TRIGGER_NEW_AUTOCMDS
1344 | WEE_TRIGGER_ENTER_AUTOCMDS | WEE_TRIGGER_LEAVE_AUTOCMDS);
1345 if (flags & WSP_VERT)
1346 p_wiw = i;
1347 else
1348 p_wh = i;
1349
1350 return OK;
1351 }
1352
1353
1354 /*
1355 * Initialize window "newp" from window "oldp".
1356 * Used when splitting a window and when creating a new tab page.
1357 * The windows will both edit the same buffer.
1358 * WSP_NEWLOC may be specified in flags to prevent the location list from
1359 * being copied.
1360 */
1361 static void
win_init(win_T * newp,win_T * oldp,int flags UNUSED)1362 win_init(win_T *newp, win_T *oldp, int flags UNUSED)
1363 {
1364 int i;
1365
1366 newp->w_buffer = oldp->w_buffer;
1367 #ifdef FEAT_SYN_HL
1368 newp->w_s = &(oldp->w_buffer->b_s);
1369 #endif
1370 oldp->w_buffer->b_nwindows++;
1371 newp->w_cursor = oldp->w_cursor;
1372 newp->w_valid = 0;
1373 newp->w_curswant = oldp->w_curswant;
1374 newp->w_set_curswant = oldp->w_set_curswant;
1375 newp->w_topline = oldp->w_topline;
1376 #ifdef FEAT_DIFF
1377 newp->w_topfill = oldp->w_topfill;
1378 #endif
1379 newp->w_leftcol = oldp->w_leftcol;
1380 newp->w_pcmark = oldp->w_pcmark;
1381 newp->w_prev_pcmark = oldp->w_prev_pcmark;
1382 newp->w_alt_fnum = oldp->w_alt_fnum;
1383 newp->w_wrow = oldp->w_wrow;
1384 newp->w_fraction = oldp->w_fraction;
1385 newp->w_prev_fraction_row = oldp->w_prev_fraction_row;
1386 #ifdef FEAT_JUMPLIST
1387 copy_jumplist(oldp, newp);
1388 #endif
1389 #ifdef FEAT_QUICKFIX
1390 if (flags & WSP_NEWLOC)
1391 {
1392 // Don't copy the location list.
1393 newp->w_llist = NULL;
1394 newp->w_llist_ref = NULL;
1395 }
1396 else
1397 copy_loclist_stack(oldp, newp);
1398 #endif
1399 newp->w_localdir = (oldp->w_localdir == NULL)
1400 ? NULL : vim_strsave(oldp->w_localdir);
1401 newp->w_prevdir = (oldp->w_prevdir == NULL)
1402 ? NULL : vim_strsave(oldp->w_prevdir);
1403
1404 // copy tagstack and folds
1405 for (i = 0; i < oldp->w_tagstacklen; i++)
1406 {
1407 taggy_T *tag = &newp->w_tagstack[i];
1408 *tag = oldp->w_tagstack[i];
1409 if (tag->tagname != NULL)
1410 tag->tagname = vim_strsave(tag->tagname);
1411 if (tag->user_data != NULL)
1412 tag->user_data = vim_strsave(tag->user_data);
1413 }
1414 newp->w_tagstackidx = oldp->w_tagstackidx;
1415 newp->w_tagstacklen = oldp->w_tagstacklen;
1416 #ifdef FEAT_FOLDING
1417 copyFoldingState(oldp, newp);
1418 #endif
1419
1420 win_init_some(newp, oldp);
1421
1422 #ifdef FEAT_SYN_HL
1423 check_colorcolumn(newp);
1424 #endif
1425 #ifdef FEAT_TERMINAL
1426 term_update_wincolor(newp);
1427 #endif
1428 }
1429
1430 /*
1431 * Initialize window "newp" from window "old".
1432 * Only the essential things are copied.
1433 */
1434 static void
win_init_some(win_T * newp,win_T * oldp)1435 win_init_some(win_T *newp, win_T *oldp)
1436 {
1437 // Use the same argument list.
1438 newp->w_alist = oldp->w_alist;
1439 ++newp->w_alist->al_refcount;
1440 newp->w_arg_idx = oldp->w_arg_idx;
1441
1442 // copy options from existing window
1443 win_copy_options(oldp, newp);
1444 }
1445
1446 /*
1447 * Return TRUE if "win" is a global popup or a popup in the current tab page.
1448 */
1449 int
win_valid_popup(win_T * win UNUSED)1450 win_valid_popup(win_T *win UNUSED)
1451 {
1452 #ifdef FEAT_PROP_POPUP
1453 win_T *wp;
1454
1455 FOR_ALL_POPUPWINS(wp)
1456 if (wp == win)
1457 return TRUE;
1458 FOR_ALL_POPUPWINS_IN_TAB(curtab, wp)
1459 if (wp == win)
1460 return TRUE;
1461 #endif
1462 return FALSE;
1463 }
1464
1465 /*
1466 * Check if "win" is a pointer to an existing window in the current tab page.
1467 */
1468 int
win_valid(win_T * win)1469 win_valid(win_T *win)
1470 {
1471 win_T *wp;
1472
1473 if (win == NULL)
1474 return FALSE;
1475 FOR_ALL_WINDOWS(wp)
1476 if (wp == win)
1477 return TRUE;
1478 return win_valid_popup(win);
1479 }
1480
1481 /*
1482 * Find window "id" in the current tab page.
1483 * Also find popup windows.
1484 * Return NULL if not found.
1485 */
1486 win_T *
win_find_by_id(int id)1487 win_find_by_id(int id)
1488 {
1489 win_T *wp;
1490
1491 FOR_ALL_WINDOWS(wp)
1492 if (wp->w_id == id)
1493 return wp;
1494 #ifdef FEAT_PROP_POPUP
1495 FOR_ALL_POPUPWINS(wp)
1496 if (wp->w_id == id)
1497 return wp;
1498 FOR_ALL_POPUPWINS_IN_TAB(curtab, wp)
1499 if (wp->w_id == id)
1500 return wp;
1501 #endif
1502 return NULL;
1503 }
1504
1505 /*
1506 * Check if "win" is a pointer to an existing window in any tab page.
1507 */
1508 int
win_valid_any_tab(win_T * win)1509 win_valid_any_tab(win_T *win)
1510 {
1511 win_T *wp;
1512 tabpage_T *tp;
1513
1514 if (win == NULL)
1515 return FALSE;
1516 FOR_ALL_TABPAGES(tp)
1517 {
1518 FOR_ALL_WINDOWS_IN_TAB(tp, wp)
1519 {
1520 if (wp == win)
1521 return TRUE;
1522 }
1523 #ifdef FEAT_PROP_POPUP
1524 FOR_ALL_POPUPWINS_IN_TAB(tp, wp)
1525 if (wp == win)
1526 return TRUE;
1527 #endif
1528 }
1529 return win_valid_popup(win);
1530 }
1531
1532 /*
1533 * Return the number of windows.
1534 */
1535 int
win_count(void)1536 win_count(void)
1537 {
1538 win_T *wp;
1539 int count = 0;
1540
1541 FOR_ALL_WINDOWS(wp)
1542 ++count;
1543 return count;
1544 }
1545
1546 /*
1547 * Make "count" windows on the screen.
1548 * Return actual number of windows on the screen.
1549 * Must be called when there is just one window, filling the whole screen
1550 * (excluding the command line).
1551 */
1552 int
make_windows(int count,int vertical UNUSED)1553 make_windows(
1554 int count,
1555 int vertical UNUSED) // split windows vertically if TRUE
1556 {
1557 int maxcount;
1558 int todo;
1559
1560 if (vertical)
1561 {
1562 // Each windows needs at least 'winminwidth' lines and a separator
1563 // column.
1564 maxcount = (curwin->w_width + curwin->w_vsep_width
1565 - (p_wiw - p_wmw)) / (p_wmw + 1);
1566 }
1567 else
1568 {
1569 // Each window needs at least 'winminheight' lines and a status line.
1570 maxcount = (VISIBLE_HEIGHT(curwin) + curwin->w_status_height
1571 - (p_wh - p_wmh)) / (p_wmh + STATUS_HEIGHT);
1572 }
1573
1574 if (maxcount < 2)
1575 maxcount = 2;
1576 if (count > maxcount)
1577 count = maxcount;
1578
1579 /*
1580 * add status line now, otherwise first window will be too big
1581 */
1582 if (count > 1)
1583 last_status(TRUE);
1584
1585 /*
1586 * Don't execute autocommands while creating the windows. Must do that
1587 * when putting the buffers in the windows.
1588 */
1589 block_autocmds();
1590
1591 // todo is number of windows left to create
1592 for (todo = count - 1; todo > 0; --todo)
1593 if (vertical)
1594 {
1595 if (win_split(curwin->w_width - (curwin->w_width - todo)
1596 / (todo + 1) - 1, WSP_VERT | WSP_ABOVE) == FAIL)
1597 break;
1598 }
1599 else
1600 {
1601 if (win_split(curwin->w_height - (curwin->w_height - todo
1602 * STATUS_HEIGHT) / (todo + 1)
1603 - STATUS_HEIGHT, WSP_ABOVE) == FAIL)
1604 break;
1605 }
1606
1607 unblock_autocmds();
1608
1609 // return actual number of windows
1610 return (count - todo);
1611 }
1612
1613 /*
1614 * Exchange current and next window
1615 */
1616 static void
win_exchange(long Prenum)1617 win_exchange(long Prenum)
1618 {
1619 frame_T *frp;
1620 frame_T *frp2;
1621 win_T *wp;
1622 win_T *wp2;
1623 int temp;
1624
1625 if (ERROR_IF_ANY_POPUP_WINDOW)
1626 return;
1627 if (ONE_WINDOW) // just one window
1628 {
1629 beep_flush();
1630 return;
1631 }
1632
1633 #ifdef FEAT_GUI
1634 need_mouse_correct = TRUE;
1635 #endif
1636
1637 /*
1638 * find window to exchange with
1639 */
1640 if (Prenum)
1641 {
1642 frp = curwin->w_frame->fr_parent->fr_child;
1643 while (frp != NULL && --Prenum > 0)
1644 frp = frp->fr_next;
1645 }
1646 else if (curwin->w_frame->fr_next != NULL) // Swap with next
1647 frp = curwin->w_frame->fr_next;
1648 else // Swap last window in row/col with previous
1649 frp = curwin->w_frame->fr_prev;
1650
1651 // We can only exchange a window with another window, not with a frame
1652 // containing windows.
1653 if (frp == NULL || frp->fr_win == NULL || frp->fr_win == curwin)
1654 return;
1655 wp = frp->fr_win;
1656
1657 /*
1658 * 1. remove curwin from the list. Remember after which window it was in wp2
1659 * 2. insert curwin before wp in the list
1660 * if wp != wp2
1661 * 3. remove wp from the list
1662 * 4. insert wp after wp2
1663 * 5. exchange the status line height and vsep width.
1664 */
1665 wp2 = curwin->w_prev;
1666 frp2 = curwin->w_frame->fr_prev;
1667 if (wp->w_prev != curwin)
1668 {
1669 win_remove(curwin, NULL);
1670 frame_remove(curwin->w_frame);
1671 win_append(wp->w_prev, curwin);
1672 frame_insert(frp, curwin->w_frame);
1673 }
1674 if (wp != wp2)
1675 {
1676 win_remove(wp, NULL);
1677 frame_remove(wp->w_frame);
1678 win_append(wp2, wp);
1679 if (frp2 == NULL)
1680 frame_insert(wp->w_frame->fr_parent->fr_child, wp->w_frame);
1681 else
1682 frame_append(frp2, wp->w_frame);
1683 }
1684 temp = curwin->w_status_height;
1685 curwin->w_status_height = wp->w_status_height;
1686 wp->w_status_height = temp;
1687 temp = curwin->w_vsep_width;
1688 curwin->w_vsep_width = wp->w_vsep_width;
1689 wp->w_vsep_width = temp;
1690
1691 frame_fix_height(curwin);
1692 frame_fix_height(wp);
1693 frame_fix_width(curwin);
1694 frame_fix_width(wp);
1695
1696 (void)win_comp_pos(); // recompute window positions
1697
1698 win_enter(wp, TRUE);
1699 redraw_all_later(NOT_VALID);
1700 }
1701
1702 /*
1703 * rotate windows: if upwards TRUE the second window becomes the first one
1704 * if upwards FALSE the first window becomes the second one
1705 */
1706 static void
win_rotate(int upwards,int count)1707 win_rotate(int upwards, int count)
1708 {
1709 win_T *wp1;
1710 win_T *wp2;
1711 frame_T *frp;
1712 int n;
1713
1714 if (ONE_WINDOW) // nothing to do
1715 {
1716 beep_flush();
1717 return;
1718 }
1719
1720 #ifdef FEAT_GUI
1721 need_mouse_correct = TRUE;
1722 #endif
1723
1724 // Check if all frames in this row/col have one window.
1725 FOR_ALL_FRAMES(frp, curwin->w_frame->fr_parent->fr_child)
1726 if (frp->fr_win == NULL)
1727 {
1728 emsg(_("E443: Cannot rotate when another window is split"));
1729 return;
1730 }
1731
1732 while (count--)
1733 {
1734 if (upwards) // first window becomes last window
1735 {
1736 // remove first window/frame from the list
1737 frp = curwin->w_frame->fr_parent->fr_child;
1738 wp1 = frp->fr_win;
1739 win_remove(wp1, NULL);
1740 frame_remove(frp);
1741
1742 // find last frame and append removed window/frame after it
1743 for ( ; frp->fr_next != NULL; frp = frp->fr_next)
1744 ;
1745 win_append(frp->fr_win, wp1);
1746 frame_append(frp, wp1->w_frame);
1747
1748 wp2 = frp->fr_win; // previously last window
1749 }
1750 else // last window becomes first window
1751 {
1752 // find last window/frame in the list and remove it
1753 for (frp = curwin->w_frame; frp->fr_next != NULL;
1754 frp = frp->fr_next)
1755 ;
1756 wp1 = frp->fr_win;
1757 wp2 = wp1->w_prev; // will become last window
1758 win_remove(wp1, NULL);
1759 frame_remove(frp);
1760
1761 // append the removed window/frame before the first in the list
1762 win_append(frp->fr_parent->fr_child->fr_win->w_prev, wp1);
1763 frame_insert(frp->fr_parent->fr_child, frp);
1764 }
1765
1766 // exchange status height and vsep width of old and new last window
1767 n = wp2->w_status_height;
1768 wp2->w_status_height = wp1->w_status_height;
1769 wp1->w_status_height = n;
1770 frame_fix_height(wp1);
1771 frame_fix_height(wp2);
1772 n = wp2->w_vsep_width;
1773 wp2->w_vsep_width = wp1->w_vsep_width;
1774 wp1->w_vsep_width = n;
1775 frame_fix_width(wp1);
1776 frame_fix_width(wp2);
1777
1778 // recompute w_winrow and w_wincol for all windows
1779 (void)win_comp_pos();
1780 }
1781
1782 redraw_all_later(NOT_VALID);
1783 }
1784
1785 /*
1786 * Move the current window to the very top/bottom/left/right of the screen.
1787 */
1788 static void
win_totop(int size,int flags)1789 win_totop(int size, int flags)
1790 {
1791 int dir;
1792 int height = curwin->w_height;
1793
1794 if (ONE_WINDOW)
1795 {
1796 beep_flush();
1797 return;
1798 }
1799 if (check_split_disallowed() == FAIL)
1800 return;
1801
1802 // Remove the window and frame from the tree of frames.
1803 (void)winframe_remove(curwin, &dir, NULL);
1804 win_remove(curwin, NULL);
1805 last_status(FALSE); // may need to remove last status line
1806 (void)win_comp_pos(); // recompute window positions
1807
1808 // Split a window on the desired side and put the window there.
1809 (void)win_split_ins(size, flags, curwin, dir);
1810 if (!(flags & WSP_VERT))
1811 {
1812 win_setheight(height);
1813 if (p_ea)
1814 win_equal(curwin, TRUE, 'v');
1815 }
1816
1817 #if defined(FEAT_GUI)
1818 // When 'guioptions' includes 'L' or 'R' may have to remove or add
1819 // scrollbars. Have to update them anyway.
1820 gui_may_update_scrollbars();
1821 #endif
1822 }
1823
1824 /*
1825 * Move window "win1" to below/right of "win2" and make "win1" the current
1826 * window. Only works within the same frame!
1827 */
1828 void
win_move_after(win_T * win1,win_T * win2)1829 win_move_after(win_T *win1, win_T *win2)
1830 {
1831 int height;
1832
1833 // check if the arguments are reasonable
1834 if (win1 == win2)
1835 return;
1836
1837 // check if there is something to do
1838 if (win2->w_next != win1)
1839 {
1840 if (win1->w_frame->fr_parent != win2->w_frame->fr_parent)
1841 {
1842 iemsg("INTERNAL: trying to move a window into another frame");
1843 return;
1844 }
1845
1846 // may need to move the status line/vertical separator of the last
1847 // window
1848 if (win1 == lastwin)
1849 {
1850 height = win1->w_prev->w_status_height;
1851 win1->w_prev->w_status_height = win1->w_status_height;
1852 win1->w_status_height = height;
1853 if (win1->w_prev->w_vsep_width == 1)
1854 {
1855 // Remove the vertical separator from the last-but-one window,
1856 // add it to the last window. Adjust the frame widths.
1857 win1->w_prev->w_vsep_width = 0;
1858 win1->w_prev->w_frame->fr_width -= 1;
1859 win1->w_vsep_width = 1;
1860 win1->w_frame->fr_width += 1;
1861 }
1862 }
1863 else if (win2 == lastwin)
1864 {
1865 height = win1->w_status_height;
1866 win1->w_status_height = win2->w_status_height;
1867 win2->w_status_height = height;
1868 if (win1->w_vsep_width == 1)
1869 {
1870 // Remove the vertical separator from win1, add it to the last
1871 // window, win2. Adjust the frame widths.
1872 win2->w_vsep_width = 1;
1873 win2->w_frame->fr_width += 1;
1874 win1->w_vsep_width = 0;
1875 win1->w_frame->fr_width -= 1;
1876 }
1877 }
1878 win_remove(win1, NULL);
1879 frame_remove(win1->w_frame);
1880 win_append(win2, win1);
1881 frame_append(win2->w_frame, win1->w_frame);
1882
1883 (void)win_comp_pos(); // recompute w_winrow for all windows
1884 redraw_later(NOT_VALID);
1885 }
1886 win_enter(win1, FALSE);
1887 }
1888
1889 /*
1890 * Make all windows the same height.
1891 * 'next_curwin' will soon be the current window, make sure it has enough
1892 * rows.
1893 */
1894 void
win_equal(win_T * next_curwin,int current,int dir)1895 win_equal(
1896 win_T *next_curwin, // pointer to current window to be or NULL
1897 int current, // do only frame with current window
1898 int dir) // 'v' for vertically, 'h' for horizontally,
1899 // 'b' for both, 0 for using p_ead
1900 {
1901 if (dir == 0)
1902 dir = *p_ead;
1903 win_equal_rec(next_curwin == NULL ? curwin : next_curwin, current,
1904 topframe, dir, 0, tabline_height(),
1905 (int)Columns, topframe->fr_height);
1906 }
1907
1908 /*
1909 * Set a frame to a new position and height, spreading the available room
1910 * equally over contained frames.
1911 * The window "next_curwin" (if not NULL) should at least get the size from
1912 * 'winheight' and 'winwidth' if possible.
1913 */
1914 static void
win_equal_rec(win_T * next_curwin,int current,frame_T * topfr,int dir,int col,int row,int width,int height)1915 win_equal_rec(
1916 win_T *next_curwin, // pointer to current window to be or NULL
1917 int current, // do only frame with current window
1918 frame_T *topfr, // frame to set size off
1919 int dir, // 'v', 'h' or 'b', see win_equal()
1920 int col, // horizontal position for frame
1921 int row, // vertical position for frame
1922 int width, // new width of frame
1923 int height) // new height of frame
1924 {
1925 int n, m;
1926 int extra_sep = 0;
1927 int wincount, totwincount = 0;
1928 frame_T *fr;
1929 int next_curwin_size = 0;
1930 int room = 0;
1931 int new_size;
1932 int has_next_curwin = 0;
1933 int hnc;
1934
1935 if (topfr->fr_layout == FR_LEAF)
1936 {
1937 // Set the width/height of this frame.
1938 // Redraw when size or position changes
1939 if (topfr->fr_height != height || topfr->fr_win->w_winrow != row
1940 || topfr->fr_width != width || topfr->fr_win->w_wincol != col
1941 )
1942 {
1943 topfr->fr_win->w_winrow = row;
1944 frame_new_height(topfr, height, FALSE, FALSE);
1945 topfr->fr_win->w_wincol = col;
1946 frame_new_width(topfr, width, FALSE, FALSE);
1947 redraw_all_later(NOT_VALID);
1948 }
1949 }
1950 else if (topfr->fr_layout == FR_ROW)
1951 {
1952 topfr->fr_width = width;
1953 topfr->fr_height = height;
1954
1955 if (dir != 'v') // equalize frame widths
1956 {
1957 // Compute the maximum number of windows horizontally in this
1958 // frame.
1959 n = frame_minwidth(topfr, NOWIN);
1960 // add one for the rightmost window, it doesn't have a separator
1961 if (col + width == Columns)
1962 extra_sep = 1;
1963 else
1964 extra_sep = 0;
1965 totwincount = (n + extra_sep) / (p_wmw + 1);
1966 has_next_curwin = frame_has_win(topfr, next_curwin);
1967
1968 /*
1969 * Compute width for "next_curwin" window and room available for
1970 * other windows.
1971 * "m" is the minimal width when counting p_wiw for "next_curwin".
1972 */
1973 m = frame_minwidth(topfr, next_curwin);
1974 room = width - m;
1975 if (room < 0)
1976 {
1977 next_curwin_size = p_wiw + room;
1978 room = 0;
1979 }
1980 else
1981 {
1982 next_curwin_size = -1;
1983 FOR_ALL_FRAMES(fr, topfr->fr_child)
1984 {
1985 // If 'winfixwidth' set keep the window width if
1986 // possible.
1987 // Watch out for this window being the next_curwin.
1988 if (frame_fixed_width(fr))
1989 {
1990 n = frame_minwidth(fr, NOWIN);
1991 new_size = fr->fr_width;
1992 if (frame_has_win(fr, next_curwin))
1993 {
1994 room += p_wiw - p_wmw;
1995 next_curwin_size = 0;
1996 if (new_size < p_wiw)
1997 new_size = p_wiw;
1998 }
1999 else
2000 // These windows don't use up room.
2001 totwincount -= (n + (fr->fr_next == NULL
2002 ? extra_sep : 0)) / (p_wmw + 1);
2003 room -= new_size - n;
2004 if (room < 0)
2005 {
2006 new_size += room;
2007 room = 0;
2008 }
2009 fr->fr_newwidth = new_size;
2010 }
2011 }
2012 if (next_curwin_size == -1)
2013 {
2014 if (!has_next_curwin)
2015 next_curwin_size = 0;
2016 else if (totwincount > 1
2017 && (room + (totwincount - 2))
2018 / (totwincount - 1) > p_wiw)
2019 {
2020 // Can make all windows wider than 'winwidth', spread
2021 // the room equally.
2022 next_curwin_size = (room + p_wiw
2023 + (totwincount - 1) * p_wmw
2024 + (totwincount - 1)) / totwincount;
2025 room -= next_curwin_size - p_wiw;
2026 }
2027 else
2028 next_curwin_size = p_wiw;
2029 }
2030 }
2031
2032 if (has_next_curwin)
2033 --totwincount; // don't count curwin
2034 }
2035
2036 FOR_ALL_FRAMES(fr, topfr->fr_child)
2037 {
2038 wincount = 1;
2039 if (fr->fr_next == NULL)
2040 // last frame gets all that remains (avoid roundoff error)
2041 new_size = width;
2042 else if (dir == 'v')
2043 new_size = fr->fr_width;
2044 else if (frame_fixed_width(fr))
2045 {
2046 new_size = fr->fr_newwidth;
2047 wincount = 0; // doesn't count as a sizeable window
2048 }
2049 else
2050 {
2051 // Compute the maximum number of windows horiz. in "fr".
2052 n = frame_minwidth(fr, NOWIN);
2053 wincount = (n + (fr->fr_next == NULL ? extra_sep : 0))
2054 / (p_wmw + 1);
2055 m = frame_minwidth(fr, next_curwin);
2056 if (has_next_curwin)
2057 hnc = frame_has_win(fr, next_curwin);
2058 else
2059 hnc = FALSE;
2060 if (hnc) // don't count next_curwin
2061 --wincount;
2062 if (totwincount == 0)
2063 new_size = room;
2064 else
2065 new_size = (wincount * room + ((unsigned)totwincount >> 1))
2066 / totwincount;
2067 if (hnc) // add next_curwin size
2068 {
2069 next_curwin_size -= p_wiw - (m - n);
2070 new_size += next_curwin_size;
2071 room -= new_size - next_curwin_size;
2072 }
2073 else
2074 room -= new_size;
2075 new_size += n;
2076 }
2077
2078 // Skip frame that is full width when splitting or closing a
2079 // window, unless equalizing all frames.
2080 if (!current || dir != 'v' || topfr->fr_parent != NULL
2081 || (new_size != fr->fr_width)
2082 || frame_has_win(fr, next_curwin))
2083 win_equal_rec(next_curwin, current, fr, dir, col, row,
2084 new_size, height);
2085 col += new_size;
2086 width -= new_size;
2087 totwincount -= wincount;
2088 }
2089 }
2090 else // topfr->fr_layout == FR_COL
2091 {
2092 topfr->fr_width = width;
2093 topfr->fr_height = height;
2094
2095 if (dir != 'h') // equalize frame heights
2096 {
2097 // Compute maximum number of windows vertically in this frame.
2098 n = frame_minheight(topfr, NOWIN);
2099 // add one for the bottom window if it doesn't have a statusline
2100 if (row + height == cmdline_row && p_ls == 0)
2101 extra_sep = 1;
2102 else
2103 extra_sep = 0;
2104 totwincount = (n + extra_sep) / (p_wmh + 1);
2105 has_next_curwin = frame_has_win(topfr, next_curwin);
2106
2107 /*
2108 * Compute height for "next_curwin" window and room available for
2109 * other windows.
2110 * "m" is the minimal height when counting p_wh for "next_curwin".
2111 */
2112 m = frame_minheight(topfr, next_curwin);
2113 room = height - m;
2114 if (room < 0)
2115 {
2116 // The room is less then 'winheight', use all space for the
2117 // current window.
2118 next_curwin_size = p_wh + room;
2119 room = 0;
2120 }
2121 else
2122 {
2123 next_curwin_size = -1;
2124 FOR_ALL_FRAMES(fr, topfr->fr_child)
2125 {
2126 // If 'winfixheight' set keep the window height if
2127 // possible.
2128 // Watch out for this window being the next_curwin.
2129 if (frame_fixed_height(fr))
2130 {
2131 n = frame_minheight(fr, NOWIN);
2132 new_size = fr->fr_height;
2133 if (frame_has_win(fr, next_curwin))
2134 {
2135 room += p_wh - p_wmh;
2136 next_curwin_size = 0;
2137 if (new_size < p_wh)
2138 new_size = p_wh;
2139 }
2140 else
2141 // These windows don't use up room.
2142 totwincount -= (n + (fr->fr_next == NULL
2143 ? extra_sep : 0)) / (p_wmh + 1);
2144 room -= new_size - n;
2145 if (room < 0)
2146 {
2147 new_size += room;
2148 room = 0;
2149 }
2150 fr->fr_newheight = new_size;
2151 }
2152 }
2153 if (next_curwin_size == -1)
2154 {
2155 if (!has_next_curwin)
2156 next_curwin_size = 0;
2157 else if (totwincount > 1
2158 && (room + (totwincount - 2))
2159 / (totwincount - 1) > p_wh)
2160 {
2161 // can make all windows higher than 'winheight',
2162 // spread the room equally.
2163 next_curwin_size = (room + p_wh
2164 + (totwincount - 1) * p_wmh
2165 + (totwincount - 1)) / totwincount;
2166 room -= next_curwin_size - p_wh;
2167 }
2168 else
2169 next_curwin_size = p_wh;
2170 }
2171 }
2172
2173 if (has_next_curwin)
2174 --totwincount; // don't count curwin
2175 }
2176
2177 FOR_ALL_FRAMES(fr, topfr->fr_child)
2178 {
2179 wincount = 1;
2180 if (fr->fr_next == NULL)
2181 // last frame gets all that remains (avoid roundoff error)
2182 new_size = height;
2183 else if (dir == 'h')
2184 new_size = fr->fr_height;
2185 else if (frame_fixed_height(fr))
2186 {
2187 new_size = fr->fr_newheight;
2188 wincount = 0; // doesn't count as a sizeable window
2189 }
2190 else
2191 {
2192 // Compute the maximum number of windows vert. in "fr".
2193 n = frame_minheight(fr, NOWIN);
2194 wincount = (n + (fr->fr_next == NULL ? extra_sep : 0))
2195 / (p_wmh + 1);
2196 m = frame_minheight(fr, next_curwin);
2197 if (has_next_curwin)
2198 hnc = frame_has_win(fr, next_curwin);
2199 else
2200 hnc = FALSE;
2201 if (hnc) // don't count next_curwin
2202 --wincount;
2203 if (totwincount == 0)
2204 new_size = room;
2205 else
2206 new_size = (wincount * room + ((unsigned)totwincount >> 1))
2207 / totwincount;
2208 if (hnc) // add next_curwin size
2209 {
2210 next_curwin_size -= p_wh - (m - n);
2211 new_size += next_curwin_size;
2212 room -= new_size - next_curwin_size;
2213 }
2214 else
2215 room -= new_size;
2216 new_size += n;
2217 }
2218 // Skip frame that is full width when splitting or closing a
2219 // window, unless equalizing all frames.
2220 if (!current || dir != 'h' || topfr->fr_parent != NULL
2221 || (new_size != fr->fr_height)
2222 || frame_has_win(fr, next_curwin))
2223 win_equal_rec(next_curwin, current, fr, dir, col, row,
2224 width, new_size);
2225 row += new_size;
2226 height -= new_size;
2227 totwincount -= wincount;
2228 }
2229 }
2230 }
2231
2232 #ifdef FEAT_JOB_CHANNEL
2233 static void
leaving_window(win_T * win)2234 leaving_window(win_T *win)
2235 {
2236 // Only matters for a prompt window.
2237 if (!bt_prompt(win->w_buffer))
2238 return;
2239
2240 // When leaving a prompt window stop Insert mode and perhaps restart
2241 // it when entering that window again.
2242 win->w_buffer->b_prompt_insert = restart_edit;
2243 if (restart_edit != 0 && mode_displayed)
2244 clear_cmdline = TRUE; // unshow mode later
2245 restart_edit = NUL;
2246
2247 // When leaving the window (or closing the window) was done from a
2248 // callback we need to break out of the Insert mode loop and restart Insert
2249 // mode when entering the window again.
2250 if (State & INSERT)
2251 {
2252 stop_insert_mode = TRUE;
2253 if (win->w_buffer->b_prompt_insert == NUL)
2254 win->w_buffer->b_prompt_insert = 'A';
2255 }
2256 }
2257
2258 void
entering_window(win_T * win)2259 entering_window(win_T *win)
2260 {
2261 // Only matters for a prompt window.
2262 if (!bt_prompt(win->w_buffer))
2263 return;
2264
2265 // When switching to a prompt buffer that was in Insert mode, don't stop
2266 // Insert mode, it may have been set in leaving_window().
2267 if (win->w_buffer->b_prompt_insert != NUL)
2268 stop_insert_mode = FALSE;
2269
2270 // When entering the prompt window restart Insert mode if we were in Insert
2271 // mode when we left it and not already in Insert mode.
2272 if ((State & INSERT) == 0)
2273 restart_edit = win->w_buffer->b_prompt_insert;
2274 }
2275 #endif
2276
2277 /*
2278 * Close all windows for buffer "buf".
2279 */
2280 void
close_windows(buf_T * buf,int keep_curwin)2281 close_windows(
2282 buf_T *buf,
2283 int keep_curwin) // don't close "curwin"
2284 {
2285 win_T *wp;
2286 tabpage_T *tp, *nexttp;
2287 int h = tabline_height();
2288 int count = tabpage_index(NULL);
2289
2290 ++RedrawingDisabled;
2291
2292 for (wp = firstwin; wp != NULL && !ONE_WINDOW; )
2293 {
2294 if (wp->w_buffer == buf && (!keep_curwin || wp != curwin)
2295 && !(wp->w_closing || wp->w_buffer->b_locked > 0))
2296 {
2297 if (win_close(wp, FALSE) == FAIL)
2298 // If closing the window fails give up, to avoid looping
2299 // forever.
2300 break;
2301
2302 // Start all over, autocommands may change the window layout.
2303 wp = firstwin;
2304 }
2305 else
2306 wp = wp->w_next;
2307 }
2308
2309 // Also check windows in other tab pages.
2310 for (tp = first_tabpage; tp != NULL; tp = nexttp)
2311 {
2312 nexttp = tp->tp_next;
2313 if (tp != curtab)
2314 FOR_ALL_WINDOWS_IN_TAB(tp, wp)
2315 if (wp->w_buffer == buf
2316 && !(wp->w_closing || wp->w_buffer->b_locked > 0))
2317 {
2318 win_close_othertab(wp, FALSE, tp);
2319
2320 // Start all over, the tab page may be closed and
2321 // autocommands may change the window layout.
2322 nexttp = first_tabpage;
2323 break;
2324 }
2325 }
2326
2327 --RedrawingDisabled;
2328
2329 if (count != tabpage_index(NULL))
2330 apply_autocmds(EVENT_TABCLOSED, NULL, NULL, FALSE, curbuf);
2331
2332 redraw_tabline = TRUE;
2333 if (h != tabline_height())
2334 shell_new_rows();
2335 }
2336
2337 /*
2338 * Return TRUE if the current window is the only window that exists (ignoring
2339 * "aucmd_win").
2340 * Returns FALSE if there is a window, possibly in another tab page.
2341 */
2342 static int
last_window(void)2343 last_window(void)
2344 {
2345 return (one_window() && first_tabpage->tp_next == NULL);
2346 }
2347
2348 /*
2349 * Return TRUE if there is only one window other than "aucmd_win" in the
2350 * current tab page.
2351 */
2352 int
one_window(void)2353 one_window(void)
2354 {
2355 win_T *wp;
2356 int seen_one = FALSE;
2357
2358 FOR_ALL_WINDOWS(wp)
2359 {
2360 if (wp != aucmd_win)
2361 {
2362 if (seen_one)
2363 return FALSE;
2364 seen_one = TRUE;
2365 }
2366 }
2367 return TRUE;
2368 }
2369
2370 /*
2371 * Close the possibly last window in a tab page.
2372 * Returns TRUE when the window was closed already.
2373 */
2374 static int
close_last_window_tabpage(win_T * win,int free_buf,tabpage_T * prev_curtab)2375 close_last_window_tabpage(
2376 win_T *win,
2377 int free_buf,
2378 tabpage_T *prev_curtab)
2379 {
2380 if (ONE_WINDOW)
2381 {
2382 buf_T *old_curbuf = curbuf;
2383
2384 /*
2385 * Closing the last window in a tab page. First go to another tab
2386 * page and then close the window and the tab page. This avoids that
2387 * curwin and curtab are invalid while we are freeing memory, they may
2388 * be used in GUI events.
2389 * Don't trigger autocommands yet, they may use wrong values, so do
2390 * that below.
2391 */
2392 goto_tabpage_tp(alt_tabpage(), FALSE, TRUE);
2393 redraw_tabline = TRUE;
2394
2395 // Safety check: Autocommands may have closed the window when jumping
2396 // to the other tab page.
2397 if (valid_tabpage(prev_curtab) && prev_curtab->tp_firstwin == win)
2398 {
2399 int h = tabline_height();
2400
2401 win_close_othertab(win, free_buf, prev_curtab);
2402 if (h != tabline_height())
2403 shell_new_rows();
2404 }
2405 #ifdef FEAT_JOB_CHANNEL
2406 entering_window(curwin);
2407 #endif
2408 // Since goto_tabpage_tp above did not trigger *Enter autocommands, do
2409 // that now.
2410 apply_autocmds(EVENT_TABCLOSED, NULL, NULL, FALSE, curbuf);
2411 apply_autocmds(EVENT_WINENTER, NULL, NULL, FALSE, curbuf);
2412 apply_autocmds(EVENT_TABENTER, NULL, NULL, FALSE, curbuf);
2413 if (old_curbuf != curbuf)
2414 apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf);
2415 return TRUE;
2416 }
2417 return FALSE;
2418 }
2419
2420 /*
2421 * Close the buffer of "win" and unload it if "action" is DOBUF_UNLOAD.
2422 * "action" can also be zero (do nothing) or DOBUF_WIPE.
2423 * "abort_if_last" is passed to close_buffer(): abort closing if all other
2424 * windows are closed.
2425 */
2426 static void
win_close_buffer(win_T * win,int action,int abort_if_last)2427 win_close_buffer(win_T *win, int action, int abort_if_last)
2428 {
2429 #ifdef FEAT_SYN_HL
2430 // Free independent synblock before the buffer is freed.
2431 if (win->w_buffer != NULL)
2432 reset_synblock(win);
2433 #endif
2434
2435 #ifdef FEAT_QUICKFIX
2436 // When the quickfix/location list window is closed, unlist the buffer.
2437 if (win->w_buffer != NULL && bt_quickfix(win->w_buffer))
2438 win->w_buffer->b_p_bl = FALSE;
2439 #endif
2440
2441 // Close the link to the buffer.
2442 if (win->w_buffer != NULL)
2443 {
2444 bufref_T bufref;
2445
2446 set_bufref(&bufref, curbuf);
2447 win->w_closing = TRUE;
2448 close_buffer(win, win->w_buffer, action, abort_if_last, FALSE);
2449 if (win_valid_any_tab(win))
2450 win->w_closing = FALSE;
2451 // Make sure curbuf is valid. It can become invalid if 'bufhidden' is
2452 // "wipe".
2453 if (!bufref_valid(&bufref))
2454 curbuf = firstbuf;
2455 }
2456 }
2457
2458 /*
2459 * Close window "win". Only works for the current tab page.
2460 * If "free_buf" is TRUE related buffer may be unloaded.
2461 *
2462 * Called by :quit, :close, :xit, :wq and findtag().
2463 * Returns FAIL when the window was not closed.
2464 */
2465 int
win_close(win_T * win,int free_buf)2466 win_close(win_T *win, int free_buf)
2467 {
2468 win_T *wp;
2469 int other_buffer = FALSE;
2470 int close_curwin = FALSE;
2471 int dir;
2472 int help_window = FALSE;
2473 tabpage_T *prev_curtab = curtab;
2474 frame_T *win_frame = win->w_frame->fr_parent;
2475 #ifdef FEAT_DIFF
2476 int had_diffmode = win->w_p_diff;
2477 #endif
2478 #ifdef MESSAGE_QUEUE
2479 int did_decrement = FALSE;
2480 #endif
2481
2482 #if defined(FEAT_TERMINAL) && defined(FEAT_PROP_POPUP)
2483 // Can close a popup window with a terminal if the job has finished.
2484 if (may_close_term_popup() == OK)
2485 return OK;
2486 #endif
2487 if (ERROR_IF_ANY_POPUP_WINDOW)
2488 return FAIL;
2489
2490 if (last_window())
2491 {
2492 emsg(_("E444: Cannot close last window"));
2493 return FAIL;
2494 }
2495
2496 if (win->w_closing || (win->w_buffer != NULL
2497 && win->w_buffer->b_locked > 0))
2498 return FAIL; // window is already being closed
2499 if (win_unlisted(win))
2500 {
2501 emsg(_(e_autocmd_close));
2502 return FAIL;
2503 }
2504 if ((firstwin == aucmd_win || lastwin == aucmd_win) && one_window())
2505 {
2506 emsg(_("E814: Cannot close window, only autocmd window would remain"));
2507 return FAIL;
2508 }
2509
2510 // When closing the last window in a tab page first go to another tab page
2511 // and then close the window and the tab page to avoid that curwin and
2512 // curtab are invalid while we are freeing memory.
2513 if (close_last_window_tabpage(win, free_buf, prev_curtab))
2514 return FAIL;
2515
2516 // When closing the help window, try restoring a snapshot after closing
2517 // the window. Otherwise clear the snapshot, it's now invalid.
2518 if (bt_help(win->w_buffer))
2519 help_window = TRUE;
2520 else
2521 clear_snapshot(curtab, SNAP_HELP_IDX);
2522
2523 if (win == curwin)
2524 {
2525 #ifdef FEAT_JOB_CHANNEL
2526 leaving_window(curwin);
2527 #endif
2528 /*
2529 * Guess which window is going to be the new current window.
2530 * This may change because of the autocommands (sigh).
2531 */
2532 wp = frame2win(win_altframe(win, NULL));
2533
2534 /*
2535 * Be careful: If autocommands delete the window or cause this window
2536 * to be the last one left, return now.
2537 */
2538 if (wp->w_buffer != curbuf)
2539 {
2540 other_buffer = TRUE;
2541 win->w_closing = TRUE;
2542 apply_autocmds(EVENT_BUFLEAVE, NULL, NULL, FALSE, curbuf);
2543 if (!win_valid(win))
2544 return FAIL;
2545 win->w_closing = FALSE;
2546 if (last_window())
2547 return FAIL;
2548 }
2549 win->w_closing = TRUE;
2550 apply_autocmds(EVENT_WINLEAVE, NULL, NULL, FALSE, curbuf);
2551 if (!win_valid(win))
2552 return FAIL;
2553 win->w_closing = FALSE;
2554 if (last_window())
2555 return FAIL;
2556 #ifdef FEAT_EVAL
2557 // autocmds may abort script processing
2558 if (aborting())
2559 return FAIL;
2560 #endif
2561 }
2562
2563 #ifdef FEAT_GUI
2564 // Avoid trouble with scrollbars that are going to be deleted in
2565 // win_free().
2566 if (gui.in_use)
2567 out_flush();
2568 #endif
2569
2570 #ifdef FEAT_PROP_POPUP
2571 if (popup_win_closed(win) && !win_valid(win))
2572 return FAIL;
2573 #endif
2574
2575 // Trigger WinClosed just before starting to free window-related resources.
2576 trigger_winclosed(win);
2577 // autocmd may have freed the window already.
2578 if (!win_valid_any_tab(win))
2579 return OK;
2580
2581 win_close_buffer(win, free_buf ? DOBUF_UNLOAD : 0, TRUE);
2582
2583 if (only_one_window() && win_valid(win) && win->w_buffer == NULL
2584 && (last_window() || curtab != prev_curtab
2585 || close_last_window_tabpage(win, free_buf, prev_curtab)))
2586 {
2587 // Autocommands have closed all windows, quit now. Restore
2588 // curwin->w_buffer, otherwise writing viminfo may fail.
2589 if (curwin->w_buffer == NULL)
2590 curwin->w_buffer = curbuf;
2591 getout(0);
2592 }
2593
2594 // Autocommands may have moved to another tab page.
2595 if (curtab != prev_curtab && win_valid_any_tab(win)
2596 && win->w_buffer == NULL)
2597 {
2598 // Need to close the window anyway, since the buffer is NULL.
2599 win_close_othertab(win, FALSE, prev_curtab);
2600 return FAIL;
2601 }
2602
2603 // Autocommands may have closed the window already or closed the only
2604 // other window.
2605 if (!win_valid(win) || last_window()
2606 || close_last_window_tabpage(win, free_buf, prev_curtab))
2607 return FAIL;
2608
2609 // Now we are really going to close the window. Disallow any autocommand
2610 // to split a window to avoid trouble.
2611 // Also bail out of parse_queued_messages() to avoid it tries to update the
2612 // screen.
2613 ++split_disallowed;
2614 #ifdef MESSAGE_QUEUE
2615 ++dont_parse_messages;
2616 #endif
2617
2618 // Free the memory used for the window and get the window that received
2619 // the screen space.
2620 wp = win_free_mem(win, &dir, NULL);
2621
2622 // Make sure curwin isn't invalid. It can cause severe trouble when
2623 // printing an error message. For win_equal() curbuf needs to be valid
2624 // too.
2625 if (win == curwin)
2626 {
2627 curwin = wp;
2628 #ifdef FEAT_QUICKFIX
2629 if (wp->w_p_pvw || bt_quickfix(wp->w_buffer))
2630 {
2631 /*
2632 * If the cursor goes to the preview or the quickfix window, try
2633 * finding another window to go to.
2634 */
2635 for (;;)
2636 {
2637 if (wp->w_next == NULL)
2638 wp = firstwin;
2639 else
2640 wp = wp->w_next;
2641 if (wp == curwin)
2642 break;
2643 if (!wp->w_p_pvw && !bt_quickfix(wp->w_buffer))
2644 {
2645 curwin = wp;
2646 break;
2647 }
2648 }
2649 }
2650 #endif
2651 curbuf = curwin->w_buffer;
2652 close_curwin = TRUE;
2653
2654 // The cursor position may be invalid if the buffer changed after last
2655 // using the window.
2656 check_cursor();
2657 }
2658 if (p_ea && (*p_ead == 'b' || *p_ead == dir))
2659 // If the frame of the closed window contains the new current window,
2660 // only resize that frame. Otherwise resize all windows.
2661 win_equal(curwin, curwin->w_frame->fr_parent == win_frame, dir);
2662 else
2663 win_comp_pos();
2664 if (close_curwin)
2665 {
2666 // Pass WEE_ALLOW_PARSE_MESSAGES to decrement dont_parse_messages
2667 // before autocommands.
2668 #ifdef MESSAGE_QUEUE
2669 did_decrement =
2670 #else
2671 (void)
2672 #endif
2673 win_enter_ext(wp,
2674 WEE_CURWIN_INVALID | WEE_TRIGGER_ENTER_AUTOCMDS
2675 | WEE_TRIGGER_LEAVE_AUTOCMDS | WEE_ALLOW_PARSE_MESSAGES);
2676 if (other_buffer)
2677 // careful: after this wp and win may be invalid!
2678 apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf);
2679 }
2680
2681 --split_disallowed;
2682 #ifdef MESSAGE_QUEUE
2683 if (!did_decrement)
2684 --dont_parse_messages;
2685 #endif
2686
2687 /*
2688 * If last window has a status line now and we don't want one,
2689 * remove the status line.
2690 */
2691 last_status(FALSE);
2692
2693 // After closing the help window, try restoring the window layout from
2694 // before it was opened.
2695 if (help_window)
2696 restore_snapshot(SNAP_HELP_IDX, close_curwin);
2697
2698 #ifdef FEAT_DIFF
2699 // If the window had 'diff' set and now there is only one window left in
2700 // the tab page with 'diff' set, and "closeoff" is in 'diffopt', then
2701 // execute ":diffoff!".
2702 if (diffopt_closeoff() && had_diffmode && curtab == prev_curtab)
2703 {
2704 int diffcount = 0;
2705 win_T *dwin;
2706
2707 FOR_ALL_WINDOWS(dwin)
2708 if (dwin->w_p_diff)
2709 ++diffcount;
2710 if (diffcount == 1)
2711 do_cmdline_cmd((char_u *)"diffoff!");
2712 }
2713 #endif
2714
2715 #if defined(FEAT_GUI)
2716 // When 'guioptions' includes 'L' or 'R' may have to remove scrollbars.
2717 if (gui.in_use && !win_hasvertsplit())
2718 gui_init_which_components(NULL);
2719 #endif
2720
2721 redraw_all_later(NOT_VALID);
2722 return OK;
2723 }
2724
2725 static void
trigger_winclosed(win_T * win)2726 trigger_winclosed(win_T *win)
2727 {
2728 static int recursive = FALSE;
2729 char_u winid[NUMBUFLEN];
2730
2731 if (recursive)
2732 return;
2733 recursive = TRUE;
2734 vim_snprintf((char *)winid, sizeof(winid), "%i", win->w_id);
2735 apply_autocmds(EVENT_WINCLOSED, winid, winid, FALSE, win->w_buffer);
2736 recursive = FALSE;
2737 }
2738
2739 /*
2740 * Close window "win" in tab page "tp", which is not the current tab page.
2741 * This may be the last window in that tab page and result in closing the tab,
2742 * thus "tp" may become invalid!
2743 * Caller must check if buffer is hidden and whether the tabline needs to be
2744 * updated.
2745 */
2746 void
win_close_othertab(win_T * win,int free_buf,tabpage_T * tp)2747 win_close_othertab(win_T *win, int free_buf, tabpage_T *tp)
2748 {
2749 win_T *wp;
2750 int dir;
2751 tabpage_T *ptp = NULL;
2752 int free_tp = FALSE;
2753
2754 // Get here with win->w_buffer == NULL when win_close() detects the tab
2755 // page changed.
2756 if (win->w_closing || (win->w_buffer != NULL
2757 && win->w_buffer->b_locked > 0))
2758 return; // window is already being closed
2759
2760 // Trigger WinClosed just before starting to free window-related resources.
2761 trigger_winclosed(win);
2762 // autocmd may have freed the window already.
2763 if (!win_valid_any_tab(win))
2764 return;
2765
2766 if (win->w_buffer != NULL)
2767 // Close the link to the buffer.
2768 close_buffer(win, win->w_buffer, free_buf ? DOBUF_UNLOAD : 0,
2769 FALSE, FALSE);
2770
2771 // Careful: Autocommands may have closed the tab page or made it the
2772 // current tab page.
2773 for (ptp = first_tabpage; ptp != NULL && ptp != tp; ptp = ptp->tp_next)
2774 ;
2775 if (ptp == NULL || tp == curtab)
2776 return;
2777
2778 // Autocommands may have closed the window already.
2779 for (wp = tp->tp_firstwin; wp != NULL && wp != win; wp = wp->w_next)
2780 ;
2781 if (wp == NULL)
2782 return;
2783
2784 // When closing the last window in a tab page remove the tab page.
2785 if (tp->tp_firstwin == tp->tp_lastwin)
2786 {
2787 if (tp == first_tabpage)
2788 first_tabpage = tp->tp_next;
2789 else
2790 {
2791 for (ptp = first_tabpage; ptp != NULL && ptp->tp_next != tp;
2792 ptp = ptp->tp_next)
2793 ;
2794 if (ptp == NULL)
2795 {
2796 internal_error("win_close_othertab()");
2797 return;
2798 }
2799 ptp->tp_next = tp->tp_next;
2800 }
2801 free_tp = TRUE;
2802 }
2803
2804 // Free the memory used for the window.
2805 win_free_mem(win, &dir, tp);
2806
2807 if (free_tp)
2808 free_tabpage(tp);
2809 }
2810
2811 /*
2812 * Free the memory used for a window.
2813 * Returns a pointer to the window that got the freed up space.
2814 */
2815 static win_T *
win_free_mem(win_T * win,int * dirp,tabpage_T * tp)2816 win_free_mem(
2817 win_T *win,
2818 int *dirp, // set to 'v' or 'h' for direction if 'ea'
2819 tabpage_T *tp) // tab page "win" is in, NULL for current
2820 {
2821 frame_T *frp;
2822 win_T *wp;
2823 tabpage_T *win_tp = tp == NULL ? curtab : tp;
2824
2825 // Remove the window and its frame from the tree of frames.
2826 frp = win->w_frame;
2827 wp = winframe_remove(win, dirp, tp);
2828 vim_free(frp);
2829 win_free(win, tp);
2830
2831 // When deleting the current window in the tab, select a new current
2832 // window.
2833 if (win == win_tp->tp_curwin)
2834 win_tp->tp_curwin = wp;
2835
2836 return wp;
2837 }
2838
2839 #if defined(EXITFREE) || defined(PROTO)
2840 void
win_free_all(void)2841 win_free_all(void)
2842 {
2843 int dummy;
2844
2845 while (first_tabpage->tp_next != NULL)
2846 tabpage_close(TRUE);
2847
2848 if (aucmd_win != NULL)
2849 {
2850 (void)win_free_mem(aucmd_win, &dummy, NULL);
2851 aucmd_win = NULL;
2852 }
2853
2854 while (firstwin != NULL)
2855 (void)win_free_mem(firstwin, &dummy, NULL);
2856
2857 // No window should be used after this. Set curwin to NULL to crash
2858 // instead of using freed memory.
2859 curwin = NULL;
2860 }
2861 #endif
2862
2863 /*
2864 * Remove a window and its frame from the tree of frames.
2865 * Returns a pointer to the window that got the freed up space.
2866 */
2867 win_T *
winframe_remove(win_T * win,int * dirp UNUSED,tabpage_T * tp)2868 winframe_remove(
2869 win_T *win,
2870 int *dirp UNUSED, // set to 'v' or 'h' for direction if 'ea'
2871 tabpage_T *tp) // tab page "win" is in, NULL for current
2872 {
2873 frame_T *frp, *frp2, *frp3;
2874 frame_T *frp_close = win->w_frame;
2875 win_T *wp;
2876
2877 /*
2878 * If there is only one window there is nothing to remove.
2879 */
2880 if (tp == NULL ? ONE_WINDOW : tp->tp_firstwin == tp->tp_lastwin)
2881 return NULL;
2882
2883 /*
2884 * Remove the window from its frame.
2885 */
2886 frp2 = win_altframe(win, tp);
2887 wp = frame2win(frp2);
2888
2889 // Remove this frame from the list of frames.
2890 frame_remove(frp_close);
2891
2892 if (frp_close->fr_parent->fr_layout == FR_COL)
2893 {
2894 // When 'winfixheight' is set, try to find another frame in the column
2895 // (as close to the closed frame as possible) to distribute the height
2896 // to.
2897 if (frp2->fr_win != NULL && frp2->fr_win->w_p_wfh)
2898 {
2899 frp = frp_close->fr_prev;
2900 frp3 = frp_close->fr_next;
2901 while (frp != NULL || frp3 != NULL)
2902 {
2903 if (frp != NULL)
2904 {
2905 if (!frame_fixed_height(frp))
2906 {
2907 frp2 = frp;
2908 wp = frame2win(frp2);
2909 break;
2910 }
2911 frp = frp->fr_prev;
2912 }
2913 if (frp3 != NULL)
2914 {
2915 if (frp3->fr_win != NULL && !frp3->fr_win->w_p_wfh)
2916 {
2917 frp2 = frp3;
2918 wp = frp3->fr_win;
2919 break;
2920 }
2921 frp3 = frp3->fr_next;
2922 }
2923 }
2924 }
2925 frame_new_height(frp2, frp2->fr_height + frp_close->fr_height,
2926 frp2 == frp_close->fr_next ? TRUE : FALSE, FALSE);
2927 *dirp = 'v';
2928 }
2929 else
2930 {
2931 // When 'winfixwidth' is set, try to find another frame in the column
2932 // (as close to the closed frame as possible) to distribute the width
2933 // to.
2934 if (frp2->fr_win != NULL && frp2->fr_win->w_p_wfw)
2935 {
2936 frp = frp_close->fr_prev;
2937 frp3 = frp_close->fr_next;
2938 while (frp != NULL || frp3 != NULL)
2939 {
2940 if (frp != NULL)
2941 {
2942 if (!frame_fixed_width(frp))
2943 {
2944 frp2 = frp;
2945 wp = frame2win(frp2);
2946 break;
2947 }
2948 frp = frp->fr_prev;
2949 }
2950 if (frp3 != NULL)
2951 {
2952 if (frp3->fr_win != NULL && !frp3->fr_win->w_p_wfw)
2953 {
2954 frp2 = frp3;
2955 wp = frp3->fr_win;
2956 break;
2957 }
2958 frp3 = frp3->fr_next;
2959 }
2960 }
2961 }
2962 frame_new_width(frp2, frp2->fr_width + frp_close->fr_width,
2963 frp2 == frp_close->fr_next ? TRUE : FALSE, FALSE);
2964 *dirp = 'h';
2965 }
2966
2967 // If rows/columns go to a window below/right its positions need to be
2968 // updated. Can only be done after the sizes have been updated.
2969 if (frp2 == frp_close->fr_next)
2970 {
2971 int row = win->w_winrow;
2972 int col = win->w_wincol;
2973
2974 frame_comp_pos(frp2, &row, &col);
2975 }
2976
2977 if (frp2->fr_next == NULL && frp2->fr_prev == NULL)
2978 {
2979 // There is no other frame in this list, move its info to the parent
2980 // and remove it.
2981 frp2->fr_parent->fr_layout = frp2->fr_layout;
2982 frp2->fr_parent->fr_child = frp2->fr_child;
2983 FOR_ALL_FRAMES(frp, frp2->fr_child)
2984 frp->fr_parent = frp2->fr_parent;
2985 frp2->fr_parent->fr_win = frp2->fr_win;
2986 if (frp2->fr_win != NULL)
2987 frp2->fr_win->w_frame = frp2->fr_parent;
2988 frp = frp2->fr_parent;
2989 if (topframe->fr_child == frp2)
2990 topframe->fr_child = frp;
2991 vim_free(frp2);
2992
2993 frp2 = frp->fr_parent;
2994 if (frp2 != NULL && frp2->fr_layout == frp->fr_layout)
2995 {
2996 // The frame above the parent has the same layout, have to merge
2997 // the frames into this list.
2998 if (frp2->fr_child == frp)
2999 frp2->fr_child = frp->fr_child;
3000 frp->fr_child->fr_prev = frp->fr_prev;
3001 if (frp->fr_prev != NULL)
3002 frp->fr_prev->fr_next = frp->fr_child;
3003 for (frp3 = frp->fr_child; ; frp3 = frp3->fr_next)
3004 {
3005 frp3->fr_parent = frp2;
3006 if (frp3->fr_next == NULL)
3007 {
3008 frp3->fr_next = frp->fr_next;
3009 if (frp->fr_next != NULL)
3010 frp->fr_next->fr_prev = frp3;
3011 break;
3012 }
3013 }
3014 if (topframe->fr_child == frp)
3015 topframe->fr_child = frp2;
3016 vim_free(frp);
3017 }
3018 }
3019
3020 return wp;
3021 }
3022
3023 /*
3024 * Return a pointer to the frame that will receive the empty screen space that
3025 * is left over after "win" is closed.
3026 *
3027 * If 'splitbelow' or 'splitright' is set, the space goes above or to the left
3028 * by default. Otherwise, the free space goes below or to the right. The
3029 * result is that opening a window and then immediately closing it will
3030 * preserve the initial window layout. The 'wfh' and 'wfw' settings are
3031 * respected when possible.
3032 */
3033 static frame_T *
win_altframe(win_T * win,tabpage_T * tp)3034 win_altframe(
3035 win_T *win,
3036 tabpage_T *tp) // tab page "win" is in, NULL for current
3037 {
3038 frame_T *frp;
3039 frame_T *other_fr, *target_fr;
3040
3041 if (tp == NULL ? ONE_WINDOW : tp->tp_firstwin == tp->tp_lastwin)
3042 return alt_tabpage()->tp_curwin->w_frame;
3043
3044 frp = win->w_frame;
3045
3046 if (frp->fr_prev == NULL)
3047 return frp->fr_next;
3048 if (frp->fr_next == NULL)
3049 return frp->fr_prev;
3050
3051 // By default the next window will get the space that was abandoned by this
3052 // window
3053 target_fr = frp->fr_next;
3054 other_fr = frp->fr_prev;
3055
3056 // If this is part of a column of windows and 'splitbelow' is true then the
3057 // previous window will get the space.
3058 if (frp->fr_parent != NULL && frp->fr_parent->fr_layout == FR_COL && p_sb)
3059 {
3060 target_fr = frp->fr_prev;
3061 other_fr = frp->fr_next;
3062 }
3063
3064 // If this is part of a row of windows, and 'splitright' is true then the
3065 // previous window will get the space.
3066 if (frp->fr_parent != NULL && frp->fr_parent->fr_layout == FR_ROW && p_spr)
3067 {
3068 target_fr = frp->fr_prev;
3069 other_fr = frp->fr_next;
3070 }
3071
3072 // If 'wfh' or 'wfw' is set for the target and not for the alternate
3073 // window, reverse the selection.
3074 if (frp->fr_parent != NULL && frp->fr_parent->fr_layout == FR_ROW)
3075 {
3076 if (frame_fixed_width(target_fr) && !frame_fixed_width(other_fr))
3077 target_fr = other_fr;
3078 }
3079 else
3080 {
3081 if (frame_fixed_height(target_fr) && !frame_fixed_height(other_fr))
3082 target_fr = other_fr;
3083 }
3084
3085 return target_fr;
3086 }
3087
3088 /*
3089 * Return the tabpage that will be used if the current one is closed.
3090 */
3091 static tabpage_T *
alt_tabpage(void)3092 alt_tabpage(void)
3093 {
3094 tabpage_T *tp;
3095
3096 // Use the next tab page if possible.
3097 if (curtab->tp_next != NULL)
3098 return curtab->tp_next;
3099
3100 // Find the last but one tab page.
3101 for (tp = first_tabpage; tp->tp_next != curtab; tp = tp->tp_next)
3102 ;
3103 return tp;
3104 }
3105
3106 /*
3107 * Find the left-upper window in frame "frp".
3108 */
3109 static win_T *
frame2win(frame_T * frp)3110 frame2win(frame_T *frp)
3111 {
3112 while (frp->fr_win == NULL)
3113 frp = frp->fr_child;
3114 return frp->fr_win;
3115 }
3116
3117 /*
3118 * Return TRUE if frame "frp" contains window "wp".
3119 */
3120 static int
frame_has_win(frame_T * frp,win_T * wp)3121 frame_has_win(frame_T *frp, win_T *wp)
3122 {
3123 frame_T *p;
3124
3125 if (frp->fr_layout == FR_LEAF)
3126 return frp->fr_win == wp;
3127
3128 FOR_ALL_FRAMES(p, frp->fr_child)
3129 if (frame_has_win(p, wp))
3130 return TRUE;
3131 return FALSE;
3132 }
3133
3134 /*
3135 * Set a new height for a frame. Recursively sets the height for contained
3136 * frames and windows. Caller must take care of positions.
3137 */
3138 static void
frame_new_height(frame_T * topfrp,int height,int topfirst,int wfh)3139 frame_new_height(
3140 frame_T *topfrp,
3141 int height,
3142 int topfirst, // resize topmost contained frame first
3143 int wfh) // obey 'winfixheight' when there is a choice;
3144 // may cause the height not to be set
3145 {
3146 frame_T *frp;
3147 int extra_lines;
3148 int h;
3149
3150 if (topfrp->fr_win != NULL)
3151 {
3152 // Simple case: just one window.
3153 win_new_height(topfrp->fr_win,
3154 height - topfrp->fr_win->w_status_height
3155 - WINBAR_HEIGHT(topfrp->fr_win));
3156 }
3157 else if (topfrp->fr_layout == FR_ROW)
3158 {
3159 do
3160 {
3161 // All frames in this row get the same new height.
3162 FOR_ALL_FRAMES(frp, topfrp->fr_child)
3163 {
3164 frame_new_height(frp, height, topfirst, wfh);
3165 if (frp->fr_height > height)
3166 {
3167 // Could not fit the windows, make the whole row higher.
3168 height = frp->fr_height;
3169 break;
3170 }
3171 }
3172 }
3173 while (frp != NULL);
3174 }
3175 else // fr_layout == FR_COL
3176 {
3177 // Complicated case: Resize a column of frames. Resize the bottom
3178 // frame first, frames above that when needed.
3179
3180 frp = topfrp->fr_child;
3181 if (wfh)
3182 // Advance past frames with one window with 'wfh' set.
3183 while (frame_fixed_height(frp))
3184 {
3185 frp = frp->fr_next;
3186 if (frp == NULL)
3187 return; // no frame without 'wfh', give up
3188 }
3189 if (!topfirst)
3190 {
3191 // Find the bottom frame of this column
3192 while (frp->fr_next != NULL)
3193 frp = frp->fr_next;
3194 if (wfh)
3195 // Advance back for frames with one window with 'wfh' set.
3196 while (frame_fixed_height(frp))
3197 frp = frp->fr_prev;
3198 }
3199
3200 extra_lines = height - topfrp->fr_height;
3201 if (extra_lines < 0)
3202 {
3203 // reduce height of contained frames, bottom or top frame first
3204 while (frp != NULL)
3205 {
3206 h = frame_minheight(frp, NULL);
3207 if (frp->fr_height + extra_lines < h)
3208 {
3209 extra_lines += frp->fr_height - h;
3210 frame_new_height(frp, h, topfirst, wfh);
3211 }
3212 else
3213 {
3214 frame_new_height(frp, frp->fr_height + extra_lines,
3215 topfirst, wfh);
3216 break;
3217 }
3218 if (topfirst)
3219 {
3220 do
3221 frp = frp->fr_next;
3222 while (wfh && frp != NULL && frame_fixed_height(frp));
3223 }
3224 else
3225 {
3226 do
3227 frp = frp->fr_prev;
3228 while (wfh && frp != NULL && frame_fixed_height(frp));
3229 }
3230 // Increase "height" if we could not reduce enough frames.
3231 if (frp == NULL)
3232 height -= extra_lines;
3233 }
3234 }
3235 else if (extra_lines > 0)
3236 {
3237 // increase height of bottom or top frame
3238 frame_new_height(frp, frp->fr_height + extra_lines, topfirst, wfh);
3239 }
3240 }
3241 topfrp->fr_height = height;
3242 }
3243
3244 /*
3245 * Return TRUE if height of frame "frp" should not be changed because of
3246 * the 'winfixheight' option.
3247 */
3248 static int
frame_fixed_height(frame_T * frp)3249 frame_fixed_height(frame_T *frp)
3250 {
3251 // frame with one window: fixed height if 'winfixheight' set.
3252 if (frp->fr_win != NULL)
3253 return frp->fr_win->w_p_wfh;
3254
3255 if (frp->fr_layout == FR_ROW)
3256 {
3257 // The frame is fixed height if one of the frames in the row is fixed
3258 // height.
3259 FOR_ALL_FRAMES(frp, frp->fr_child)
3260 if (frame_fixed_height(frp))
3261 return TRUE;
3262 return FALSE;
3263 }
3264
3265 // frp->fr_layout == FR_COL: The frame is fixed height if all of the
3266 // frames in the row are fixed height.
3267 FOR_ALL_FRAMES(frp, frp->fr_child)
3268 if (!frame_fixed_height(frp))
3269 return FALSE;
3270 return TRUE;
3271 }
3272
3273 /*
3274 * Return TRUE if width of frame "frp" should not be changed because of
3275 * the 'winfixwidth' option.
3276 */
3277 static int
frame_fixed_width(frame_T * frp)3278 frame_fixed_width(frame_T *frp)
3279 {
3280 // frame with one window: fixed width if 'winfixwidth' set.
3281 if (frp->fr_win != NULL)
3282 return frp->fr_win->w_p_wfw;
3283
3284 if (frp->fr_layout == FR_COL)
3285 {
3286 // The frame is fixed width if one of the frames in the row is fixed
3287 // width.
3288 FOR_ALL_FRAMES(frp, frp->fr_child)
3289 if (frame_fixed_width(frp))
3290 return TRUE;
3291 return FALSE;
3292 }
3293
3294 // frp->fr_layout == FR_ROW: The frame is fixed width if all of the
3295 // frames in the row are fixed width.
3296 FOR_ALL_FRAMES(frp, frp->fr_child)
3297 if (!frame_fixed_width(frp))
3298 return FALSE;
3299 return TRUE;
3300 }
3301
3302 /*
3303 * Add a status line to windows at the bottom of "frp".
3304 * Note: Does not check if there is room!
3305 */
3306 static void
frame_add_statusline(frame_T * frp)3307 frame_add_statusline(frame_T *frp)
3308 {
3309 win_T *wp;
3310
3311 if (frp->fr_layout == FR_LEAF)
3312 {
3313 wp = frp->fr_win;
3314 if (wp->w_status_height == 0)
3315 {
3316 if (wp->w_height > 0) // don't make it negative
3317 --wp->w_height;
3318 wp->w_status_height = STATUS_HEIGHT;
3319 }
3320 }
3321 else if (frp->fr_layout == FR_ROW)
3322 {
3323 // Handle all the frames in the row.
3324 FOR_ALL_FRAMES(frp, frp->fr_child)
3325 frame_add_statusline(frp);
3326 }
3327 else // frp->fr_layout == FR_COL
3328 {
3329 // Only need to handle the last frame in the column.
3330 for (frp = frp->fr_child; frp->fr_next != NULL; frp = frp->fr_next)
3331 ;
3332 frame_add_statusline(frp);
3333 }
3334 }
3335
3336 /*
3337 * Set width of a frame. Handles recursively going through contained frames.
3338 * May remove separator line for windows at the right side (for win_close()).
3339 */
3340 static void
frame_new_width(frame_T * topfrp,int width,int leftfirst,int wfw)3341 frame_new_width(
3342 frame_T *topfrp,
3343 int width,
3344 int leftfirst, // resize leftmost contained frame first
3345 int wfw) // obey 'winfixwidth' when there is a choice;
3346 // may cause the width not to be set
3347 {
3348 frame_T *frp;
3349 int extra_cols;
3350 int w;
3351 win_T *wp;
3352
3353 if (topfrp->fr_layout == FR_LEAF)
3354 {
3355 // Simple case: just one window.
3356 wp = topfrp->fr_win;
3357 // Find out if there are any windows right of this one.
3358 for (frp = topfrp; frp->fr_parent != NULL; frp = frp->fr_parent)
3359 if (frp->fr_parent->fr_layout == FR_ROW && frp->fr_next != NULL)
3360 break;
3361 if (frp->fr_parent == NULL)
3362 wp->w_vsep_width = 0;
3363 win_new_width(wp, width - wp->w_vsep_width);
3364 }
3365 else if (topfrp->fr_layout == FR_COL)
3366 {
3367 do
3368 {
3369 // All frames in this column get the same new width.
3370 FOR_ALL_FRAMES(frp, topfrp->fr_child)
3371 {
3372 frame_new_width(frp, width, leftfirst, wfw);
3373 if (frp->fr_width > width)
3374 {
3375 // Could not fit the windows, make whole column wider.
3376 width = frp->fr_width;
3377 break;
3378 }
3379 }
3380 } while (frp != NULL);
3381 }
3382 else // fr_layout == FR_ROW
3383 {
3384 // Complicated case: Resize a row of frames. Resize the rightmost
3385 // frame first, frames left of it when needed.
3386
3387 frp = topfrp->fr_child;
3388 if (wfw)
3389 // Advance past frames with one window with 'wfw' set.
3390 while (frame_fixed_width(frp))
3391 {
3392 frp = frp->fr_next;
3393 if (frp == NULL)
3394 return; // no frame without 'wfw', give up
3395 }
3396 if (!leftfirst)
3397 {
3398 // Find the rightmost frame of this row
3399 while (frp->fr_next != NULL)
3400 frp = frp->fr_next;
3401 if (wfw)
3402 // Advance back for frames with one window with 'wfw' set.
3403 while (frame_fixed_width(frp))
3404 frp = frp->fr_prev;
3405 }
3406
3407 extra_cols = width - topfrp->fr_width;
3408 if (extra_cols < 0)
3409 {
3410 // reduce frame width, rightmost frame first
3411 while (frp != NULL)
3412 {
3413 w = frame_minwidth(frp, NULL);
3414 if (frp->fr_width + extra_cols < w)
3415 {
3416 extra_cols += frp->fr_width - w;
3417 frame_new_width(frp, w, leftfirst, wfw);
3418 }
3419 else
3420 {
3421 frame_new_width(frp, frp->fr_width + extra_cols,
3422 leftfirst, wfw);
3423 break;
3424 }
3425 if (leftfirst)
3426 {
3427 do
3428 frp = frp->fr_next;
3429 while (wfw && frp != NULL && frame_fixed_width(frp));
3430 }
3431 else
3432 {
3433 do
3434 frp = frp->fr_prev;
3435 while (wfw && frp != NULL && frame_fixed_width(frp));
3436 }
3437 // Increase "width" if we could not reduce enough frames.
3438 if (frp == NULL)
3439 width -= extra_cols;
3440 }
3441 }
3442 else if (extra_cols > 0)
3443 {
3444 // increase width of rightmost frame
3445 frame_new_width(frp, frp->fr_width + extra_cols, leftfirst, wfw);
3446 }
3447 }
3448 topfrp->fr_width = width;
3449 }
3450
3451 /*
3452 * Add the vertical separator to windows at the right side of "frp".
3453 * Note: Does not check if there is room!
3454 */
3455 static void
frame_add_vsep(frame_T * frp)3456 frame_add_vsep(frame_T *frp)
3457 {
3458 win_T *wp;
3459
3460 if (frp->fr_layout == FR_LEAF)
3461 {
3462 wp = frp->fr_win;
3463 if (wp->w_vsep_width == 0)
3464 {
3465 if (wp->w_width > 0) // don't make it negative
3466 --wp->w_width;
3467 wp->w_vsep_width = 1;
3468 }
3469 }
3470 else if (frp->fr_layout == FR_COL)
3471 {
3472 // Handle all the frames in the column.
3473 FOR_ALL_FRAMES(frp, frp->fr_child)
3474 frame_add_vsep(frp);
3475 }
3476 else // frp->fr_layout == FR_ROW
3477 {
3478 // Only need to handle the last frame in the row.
3479 frp = frp->fr_child;
3480 while (frp->fr_next != NULL)
3481 frp = frp->fr_next;
3482 frame_add_vsep(frp);
3483 }
3484 }
3485
3486 /*
3487 * Set frame width from the window it contains.
3488 */
3489 static void
frame_fix_width(win_T * wp)3490 frame_fix_width(win_T *wp)
3491 {
3492 wp->w_frame->fr_width = wp->w_width + wp->w_vsep_width;
3493 }
3494
3495 /*
3496 * Set frame height from the window it contains.
3497 */
3498 static void
frame_fix_height(win_T * wp)3499 frame_fix_height(win_T *wp)
3500 {
3501 wp->w_frame->fr_height = VISIBLE_HEIGHT(wp) + wp->w_status_height;
3502 }
3503
3504 /*
3505 * Compute the minimal height for frame "topfrp".
3506 * Uses the 'winminheight' option.
3507 * When "next_curwin" isn't NULL, use p_wh for this window.
3508 * When "next_curwin" is NOWIN, don't use at least one line for the current
3509 * window.
3510 */
3511 static int
frame_minheight(frame_T * topfrp,win_T * next_curwin)3512 frame_minheight(frame_T *topfrp, win_T *next_curwin)
3513 {
3514 frame_T *frp;
3515 int m;
3516 int n;
3517
3518 if (topfrp->fr_win != NULL)
3519 {
3520 if (topfrp->fr_win == next_curwin)
3521 m = p_wh + topfrp->fr_win->w_status_height;
3522 else
3523 {
3524 // window: minimal height of the window plus status line
3525 m = p_wmh + topfrp->fr_win->w_status_height;
3526 if (topfrp->fr_win == curwin && next_curwin == NULL)
3527 {
3528 // Current window is minimal one line high and WinBar is
3529 // visible.
3530 if (p_wmh == 0)
3531 ++m;
3532 m += WINBAR_HEIGHT(curwin);
3533 }
3534 }
3535 }
3536 else if (topfrp->fr_layout == FR_ROW)
3537 {
3538 // get the minimal height from each frame in this row
3539 m = 0;
3540 FOR_ALL_FRAMES(frp, topfrp->fr_child)
3541 {
3542 n = frame_minheight(frp, next_curwin);
3543 if (n > m)
3544 m = n;
3545 }
3546 }
3547 else
3548 {
3549 // Add up the minimal heights for all frames in this column.
3550 m = 0;
3551 FOR_ALL_FRAMES(frp, topfrp->fr_child)
3552 m += frame_minheight(frp, next_curwin);
3553 }
3554
3555 return m;
3556 }
3557
3558 /*
3559 * Compute the minimal width for frame "topfrp".
3560 * When "next_curwin" isn't NULL, use p_wiw for this window.
3561 * When "next_curwin" is NOWIN, don't use at least one column for the current
3562 * window.
3563 */
3564 static int
frame_minwidth(frame_T * topfrp,win_T * next_curwin)3565 frame_minwidth(
3566 frame_T *topfrp,
3567 win_T *next_curwin) // use p_wh and p_wiw for next_curwin
3568 {
3569 frame_T *frp;
3570 int m, n;
3571
3572 if (topfrp->fr_win != NULL)
3573 {
3574 if (topfrp->fr_win == next_curwin)
3575 m = p_wiw + topfrp->fr_win->w_vsep_width;
3576 else
3577 {
3578 // window: minimal width of the window plus separator column
3579 m = p_wmw + topfrp->fr_win->w_vsep_width;
3580 // Current window is minimal one column wide
3581 if (p_wmw == 0 && topfrp->fr_win == curwin && next_curwin == NULL)
3582 ++m;
3583 }
3584 }
3585 else if (topfrp->fr_layout == FR_COL)
3586 {
3587 // get the minimal width from each frame in this column
3588 m = 0;
3589 FOR_ALL_FRAMES(frp, topfrp->fr_child)
3590 {
3591 n = frame_minwidth(frp, next_curwin);
3592 if (n > m)
3593 m = n;
3594 }
3595 }
3596 else
3597 {
3598 // Add up the minimal widths for all frames in this row.
3599 m = 0;
3600 FOR_ALL_FRAMES(frp, topfrp->fr_child)
3601 m += frame_minwidth(frp, next_curwin);
3602 }
3603
3604 return m;
3605 }
3606
3607
3608 /*
3609 * Try to close all windows except current one.
3610 * Buffers in the other windows become hidden if 'hidden' is set, or '!' is
3611 * used and the buffer was modified.
3612 *
3613 * Used by ":bdel" and ":only".
3614 */
3615 void
close_others(int message,int forceit)3616 close_others(
3617 int message,
3618 int forceit) // always hide all other windows
3619 {
3620 win_T *wp;
3621 win_T *nextwp;
3622 int r;
3623
3624 if (one_window())
3625 {
3626 if (message && !autocmd_busy)
3627 msg(_(m_onlyone));
3628 return;
3629 }
3630
3631 // Be very careful here: autocommands may change the window layout.
3632 for (wp = firstwin; win_valid(wp); wp = nextwp)
3633 {
3634 nextwp = wp->w_next;
3635 if (wp != curwin) // don't close current window
3636 {
3637
3638 // Check if it's allowed to abandon this window
3639 r = can_abandon(wp->w_buffer, forceit);
3640 if (!win_valid(wp)) // autocommands messed wp up
3641 {
3642 nextwp = firstwin;
3643 continue;
3644 }
3645 if (!r)
3646 {
3647 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
3648 if (message && (p_confirm
3649 || (cmdmod.cmod_flags & CMOD_CONFIRM)) && p_write)
3650 {
3651 dialog_changed(wp->w_buffer, FALSE);
3652 if (!win_valid(wp)) // autocommands messed wp up
3653 {
3654 nextwp = firstwin;
3655 continue;
3656 }
3657 }
3658 if (bufIsChanged(wp->w_buffer))
3659 #endif
3660 continue;
3661 }
3662 win_close(wp, !buf_hide(wp->w_buffer)
3663 && !bufIsChanged(wp->w_buffer));
3664 }
3665 }
3666
3667 if (message && !ONE_WINDOW)
3668 emsg(_("E445: Other window contains changes"));
3669 }
3670
3671 static void
win_init_empty(win_T * wp)3672 win_init_empty(win_T *wp)
3673 {
3674 redraw_win_later(wp, NOT_VALID);
3675 wp->w_lines_valid = 0;
3676 wp->w_cursor.lnum = 1;
3677 wp->w_curswant = wp->w_cursor.col = 0;
3678 wp->w_cursor.coladd = 0;
3679 wp->w_pcmark.lnum = 1; // pcmark not cleared but set to line 1
3680 wp->w_pcmark.col = 0;
3681 wp->w_prev_pcmark.lnum = 0;
3682 wp->w_prev_pcmark.col = 0;
3683 wp->w_topline = 1;
3684 #ifdef FEAT_DIFF
3685 wp->w_topfill = 0;
3686 #endif
3687 wp->w_botline = 2;
3688 #if defined(FEAT_SYN_HL) || defined(FEAT_SPELL)
3689 wp->w_s = &wp->w_buffer->b_s;
3690 #endif
3691 #ifdef FEAT_TERMINAL
3692 term_reset_wincolor(wp);
3693 #endif
3694 }
3695
3696 /*
3697 * Init the current window "curwin".
3698 * Called when a new file is being edited.
3699 */
3700 void
curwin_init(void)3701 curwin_init(void)
3702 {
3703 win_init_empty(curwin);
3704 }
3705
3706 /*
3707 * Allocate the first window and put an empty buffer in it.
3708 * Called from main().
3709 * Return FAIL when something goes wrong (out of memory).
3710 */
3711 int
win_alloc_first(void)3712 win_alloc_first(void)
3713 {
3714 if (win_alloc_firstwin(NULL) == FAIL)
3715 return FAIL;
3716
3717 first_tabpage = alloc_tabpage();
3718 if (first_tabpage == NULL)
3719 return FAIL;
3720 first_tabpage->tp_topframe = topframe;
3721 curtab = first_tabpage;
3722 curtab->tp_firstwin = firstwin;
3723 curtab->tp_lastwin = lastwin;
3724 curtab->tp_curwin = curwin;
3725
3726 return OK;
3727 }
3728
3729 /*
3730 * Allocate and init a window that is not a regular window.
3731 * This can only be done after the first window is fully initialized, thus it
3732 * can't be in win_alloc_first().
3733 */
3734 win_T *
win_alloc_popup_win(void)3735 win_alloc_popup_win(void)
3736 {
3737 win_T *wp;
3738
3739 wp = win_alloc(NULL, TRUE);
3740 if (wp != NULL)
3741 {
3742 // We need to initialize options with something, using the current
3743 // window makes most sense.
3744 win_init_some(wp, curwin);
3745
3746 RESET_BINDING(wp);
3747 new_frame(wp);
3748 }
3749 return wp;
3750 }
3751
3752 /*
3753 * Initialize window "wp" to display buffer "buf".
3754 */
3755 void
win_init_popup_win(win_T * wp,buf_T * buf)3756 win_init_popup_win(win_T *wp, buf_T *buf)
3757 {
3758 wp->w_buffer = buf;
3759 ++buf->b_nwindows;
3760 win_init_empty(wp); // set cursor and topline to safe values
3761
3762 // Make sure w_localdir and globaldir are NULL to avoid a chdir() in
3763 // win_enter_ext().
3764 VIM_CLEAR(wp->w_localdir);
3765 }
3766
3767 /*
3768 * Allocate the first window or the first window in a new tab page.
3769 * When "oldwin" is NULL create an empty buffer for it.
3770 * When "oldwin" is not NULL copy info from it to the new window.
3771 * Return FAIL when something goes wrong (out of memory).
3772 */
3773 static int
win_alloc_firstwin(win_T * oldwin)3774 win_alloc_firstwin(win_T *oldwin)
3775 {
3776 curwin = win_alloc(NULL, FALSE);
3777 if (oldwin == NULL)
3778 {
3779 // Very first window, need to create an empty buffer for it and
3780 // initialize from scratch.
3781 curbuf = buflist_new(NULL, NULL, 1L, BLN_LISTED);
3782 if (curwin == NULL || curbuf == NULL)
3783 return FAIL;
3784 curwin->w_buffer = curbuf;
3785 #ifdef FEAT_SYN_HL
3786 curwin->w_s = &(curbuf->b_s);
3787 #endif
3788 curbuf->b_nwindows = 1; // there is one window
3789 curwin->w_alist = &global_alist;
3790 curwin_init(); // init current window
3791 }
3792 else
3793 {
3794 // First window in new tab page, initialize it from "oldwin".
3795 win_init(curwin, oldwin, 0);
3796
3797 // We don't want cursor- and scroll-binding in the first window.
3798 RESET_BINDING(curwin);
3799 }
3800
3801 new_frame(curwin);
3802 if (curwin->w_frame == NULL)
3803 return FAIL;
3804 topframe = curwin->w_frame;
3805 topframe->fr_width = Columns;
3806 topframe->fr_height = Rows - p_ch;
3807
3808 return OK;
3809 }
3810
3811 /*
3812 * Create a frame for window "wp".
3813 */
3814 static void
new_frame(win_T * wp)3815 new_frame(win_T *wp)
3816 {
3817 frame_T *frp = ALLOC_CLEAR_ONE(frame_T);
3818
3819 wp->w_frame = frp;
3820 if (frp != NULL)
3821 {
3822 frp->fr_layout = FR_LEAF;
3823 frp->fr_win = wp;
3824 }
3825 }
3826
3827 /*
3828 * Initialize the window and frame size to the maximum.
3829 */
3830 void
win_init_size(void)3831 win_init_size(void)
3832 {
3833 firstwin->w_height = ROWS_AVAIL;
3834 topframe->fr_height = ROWS_AVAIL;
3835 firstwin->w_width = Columns;
3836 topframe->fr_width = Columns;
3837 }
3838
3839 /*
3840 * Allocate a new tabpage_T and init the values.
3841 * Returns NULL when out of memory.
3842 */
3843 static tabpage_T *
alloc_tabpage(void)3844 alloc_tabpage(void)
3845 {
3846 tabpage_T *tp;
3847 # ifdef FEAT_GUI
3848 int i;
3849 # endif
3850
3851
3852 tp = ALLOC_CLEAR_ONE(tabpage_T);
3853 if (tp == NULL)
3854 return NULL;
3855
3856 # ifdef FEAT_EVAL
3857 // init t: variables
3858 tp->tp_vars = dict_alloc();
3859 if (tp->tp_vars == NULL)
3860 {
3861 vim_free(tp);
3862 return NULL;
3863 }
3864 init_var_dict(tp->tp_vars, &tp->tp_winvar, VAR_SCOPE);
3865 # endif
3866
3867 # ifdef FEAT_GUI
3868 for (i = 0; i < 3; i++)
3869 tp->tp_prev_which_scrollbars[i] = -1;
3870 # endif
3871 # ifdef FEAT_DIFF
3872 tp->tp_diff_invalid = TRUE;
3873 # endif
3874 tp->tp_ch_used = p_ch;
3875
3876 return tp;
3877 }
3878
3879 void
free_tabpage(tabpage_T * tp)3880 free_tabpage(tabpage_T *tp)
3881 {
3882 int idx;
3883
3884 # ifdef FEAT_DIFF
3885 diff_clear(tp);
3886 # endif
3887 # ifdef FEAT_PROP_POPUP
3888 while (tp->tp_first_popupwin != NULL)
3889 popup_close_tabpage(tp, tp->tp_first_popupwin->w_id, TRUE);
3890 #endif
3891 for (idx = 0; idx < SNAP_COUNT; ++idx)
3892 clear_snapshot(tp, idx);
3893 #ifdef FEAT_EVAL
3894 vars_clear(&tp->tp_vars->dv_hashtab); // free all t: variables
3895 hash_init(&tp->tp_vars->dv_hashtab);
3896 unref_var_dict(tp->tp_vars);
3897 #endif
3898
3899 if (tp == lastused_tabpage)
3900 lastused_tabpage = NULL;
3901
3902 vim_free(tp->tp_localdir);
3903 vim_free(tp->tp_prevdir);
3904
3905 #ifdef FEAT_PYTHON
3906 python_tabpage_free(tp);
3907 #endif
3908
3909 #ifdef FEAT_PYTHON3
3910 python3_tabpage_free(tp);
3911 #endif
3912
3913 vim_free(tp);
3914 }
3915
3916 /*
3917 * Create a new Tab page with one window.
3918 * It will edit the current buffer, like after ":split".
3919 * When "after" is 0 put it just after the current Tab page.
3920 * Otherwise put it just before tab page "after".
3921 * Return FAIL or OK.
3922 */
3923 int
win_new_tabpage(int after)3924 win_new_tabpage(int after)
3925 {
3926 tabpage_T *tp = curtab;
3927 tabpage_T *prev_tp = curtab;
3928 tabpage_T *newtp;
3929 int n;
3930
3931 newtp = alloc_tabpage();
3932 if (newtp == NULL)
3933 return FAIL;
3934
3935 // Remember the current windows in this Tab page.
3936 if (leave_tabpage(curbuf, TRUE) == FAIL)
3937 {
3938 vim_free(newtp);
3939 return FAIL;
3940 }
3941 curtab = newtp;
3942
3943 newtp->tp_localdir = (tp->tp_localdir == NULL)
3944 ? NULL : vim_strsave(tp->tp_localdir);
3945 // Create a new empty window.
3946 if (win_alloc_firstwin(tp->tp_curwin) == OK)
3947 {
3948 // Make the new Tab page the new topframe.
3949 if (after == 1)
3950 {
3951 // New tab page becomes the first one.
3952 newtp->tp_next = first_tabpage;
3953 first_tabpage = newtp;
3954 }
3955 else
3956 {
3957 if (after > 0)
3958 {
3959 // Put new tab page before tab page "after".
3960 n = 2;
3961 for (tp = first_tabpage; tp->tp_next != NULL
3962 && n < after; tp = tp->tp_next)
3963 ++n;
3964 }
3965 newtp->tp_next = tp->tp_next;
3966 tp->tp_next = newtp;
3967 }
3968 newtp->tp_firstwin = newtp->tp_lastwin = newtp->tp_curwin = curwin;
3969
3970 win_init_size();
3971 firstwin->w_winrow = tabline_height();
3972 win_comp_scroll(curwin);
3973
3974 newtp->tp_topframe = topframe;
3975 last_status(FALSE);
3976
3977 lastused_tabpage = prev_tp;
3978
3979 #if defined(FEAT_GUI)
3980 // When 'guioptions' includes 'L' or 'R' may have to remove or add
3981 // scrollbars. Have to update them anyway.
3982 gui_may_update_scrollbars();
3983 #endif
3984 #ifdef FEAT_JOB_CHANNEL
3985 entering_window(curwin);
3986 #endif
3987
3988 redraw_all_later(NOT_VALID);
3989 apply_autocmds(EVENT_WINNEW, NULL, NULL, FALSE, curbuf);
3990 apply_autocmds(EVENT_WINENTER, NULL, NULL, FALSE, curbuf);
3991 apply_autocmds(EVENT_TABNEW, NULL, NULL, FALSE, curbuf);
3992 apply_autocmds(EVENT_TABENTER, NULL, NULL, FALSE, curbuf);
3993 return OK;
3994 }
3995
3996 // Failed, get back the previous Tab page
3997 enter_tabpage(curtab, curbuf, TRUE, TRUE);
3998 return FAIL;
3999 }
4000
4001 /*
4002 * Open a new tab page if ":tab cmd" was used. It will edit the same buffer,
4003 * like with ":split".
4004 * Returns OK if a new tab page was created, FAIL otherwise.
4005 */
4006 static int
may_open_tabpage(void)4007 may_open_tabpage(void)
4008 {
4009 int n = (cmdmod.cmod_tab == 0)
4010 ? postponed_split_tab : cmdmod.cmod_tab;
4011
4012 if (n != 0)
4013 {
4014 cmdmod.cmod_tab = 0; // reset it to avoid doing it twice
4015 postponed_split_tab = 0;
4016 return win_new_tabpage(n);
4017 }
4018 return FAIL;
4019 }
4020
4021 /*
4022 * Create up to "maxcount" tabpages with empty windows.
4023 * Returns the number of resulting tab pages.
4024 */
4025 int
make_tabpages(int maxcount)4026 make_tabpages(int maxcount)
4027 {
4028 int count = maxcount;
4029 int todo;
4030
4031 // Limit to 'tabpagemax' tabs.
4032 if (count > p_tpm)
4033 count = p_tpm;
4034
4035 /*
4036 * Don't execute autocommands while creating the tab pages. Must do that
4037 * when putting the buffers in the windows.
4038 */
4039 block_autocmds();
4040
4041 for (todo = count - 1; todo > 0; --todo)
4042 if (win_new_tabpage(0) == FAIL)
4043 break;
4044
4045 unblock_autocmds();
4046
4047 // return actual number of tab pages
4048 return (count - todo);
4049 }
4050
4051 /*
4052 * Return TRUE when "tpc" points to a valid tab page.
4053 */
4054 int
valid_tabpage(tabpage_T * tpc)4055 valid_tabpage(tabpage_T *tpc)
4056 {
4057 tabpage_T *tp;
4058
4059 FOR_ALL_TABPAGES(tp)
4060 if (tp == tpc)
4061 return TRUE;
4062 return FALSE;
4063 }
4064
4065 /*
4066 * Return TRUE when "tpc" points to a valid tab page and at least one window is
4067 * valid.
4068 */
4069 int
valid_tabpage_win(tabpage_T * tpc)4070 valid_tabpage_win(tabpage_T *tpc)
4071 {
4072 tabpage_T *tp;
4073 win_T *wp;
4074
4075 FOR_ALL_TABPAGES(tp)
4076 {
4077 if (tp == tpc)
4078 {
4079 FOR_ALL_WINDOWS_IN_TAB(tp, wp)
4080 {
4081 if (win_valid_any_tab(wp))
4082 return TRUE;
4083 }
4084 return FALSE;
4085 }
4086 }
4087 // shouldn't happen
4088 return FALSE;
4089 }
4090
4091 /*
4092 * Close tabpage "tab", assuming it has no windows in it.
4093 * There must be another tabpage or this will crash.
4094 */
4095 void
close_tabpage(tabpage_T * tab)4096 close_tabpage(tabpage_T *tab)
4097 {
4098 tabpage_T *ptp;
4099
4100 if (tab == first_tabpage)
4101 {
4102 first_tabpage = tab->tp_next;
4103 ptp = first_tabpage;
4104 }
4105 else
4106 {
4107 for (ptp = first_tabpage; ptp != NULL && ptp->tp_next != tab;
4108 ptp = ptp->tp_next)
4109 ;
4110 assert(ptp != NULL);
4111 ptp->tp_next = tab->tp_next;
4112 }
4113
4114 goto_tabpage_tp(ptp, FALSE, FALSE);
4115 free_tabpage(tab);
4116 }
4117
4118 /*
4119 * Find tab page "n" (first one is 1). Returns NULL when not found.
4120 */
4121 tabpage_T *
find_tabpage(int n)4122 find_tabpage(int n)
4123 {
4124 tabpage_T *tp;
4125 int i = 1;
4126
4127 if (n == 0)
4128 return curtab;
4129
4130 for (tp = first_tabpage; tp != NULL && i != n; tp = tp->tp_next)
4131 ++i;
4132 return tp;
4133 }
4134
4135 /*
4136 * Get index of tab page "tp". First one has index 1.
4137 * When not found returns number of tab pages plus one.
4138 */
4139 int
tabpage_index(tabpage_T * ftp)4140 tabpage_index(tabpage_T *ftp)
4141 {
4142 int i = 1;
4143 tabpage_T *tp;
4144
4145 for (tp = first_tabpage; tp != NULL && tp != ftp; tp = tp->tp_next)
4146 ++i;
4147 return i;
4148 }
4149
4150 /*
4151 * Prepare for leaving the current tab page.
4152 * When autocommands change "curtab" we don't leave the tab page and return
4153 * FAIL.
4154 * Careful: When OK is returned need to get a new tab page very very soon!
4155 */
4156 static int
leave_tabpage(buf_T * new_curbuf UNUSED,int trigger_leave_autocmds UNUSED)4157 leave_tabpage(
4158 buf_T *new_curbuf UNUSED, // what is going to be the new curbuf,
4159 // NULL if unknown
4160 int trigger_leave_autocmds UNUSED)
4161 {
4162 tabpage_T *tp = curtab;
4163
4164 #ifdef FEAT_JOB_CHANNEL
4165 leaving_window(curwin);
4166 #endif
4167 reset_VIsual_and_resel(); // stop Visual mode
4168 if (trigger_leave_autocmds)
4169 {
4170 if (new_curbuf != curbuf)
4171 {
4172 apply_autocmds(EVENT_BUFLEAVE, NULL, NULL, FALSE, curbuf);
4173 if (curtab != tp)
4174 return FAIL;
4175 }
4176 apply_autocmds(EVENT_WINLEAVE, NULL, NULL, FALSE, curbuf);
4177 if (curtab != tp)
4178 return FAIL;
4179 apply_autocmds(EVENT_TABLEAVE, NULL, NULL, FALSE, curbuf);
4180 if (curtab != tp)
4181 return FAIL;
4182 }
4183 #if defined(FEAT_GUI)
4184 // Remove the scrollbars. They may be added back later.
4185 if (gui.in_use)
4186 gui_remove_scrollbars();
4187 #endif
4188 tp->tp_curwin = curwin;
4189 tp->tp_prevwin = prevwin;
4190 tp->tp_firstwin = firstwin;
4191 tp->tp_lastwin = lastwin;
4192 tp->tp_old_Rows = Rows;
4193 tp->tp_old_Columns = Columns;
4194 firstwin = NULL;
4195 lastwin = NULL;
4196 return OK;
4197 }
4198
4199 /*
4200 * Start using tab page "tp".
4201 * Only to be used after leave_tabpage() or freeing the current tab page.
4202 * Only trigger *Enter autocommands when trigger_enter_autocmds is TRUE.
4203 * Only trigger *Leave autocommands when trigger_leave_autocmds is TRUE.
4204 */
4205 static void
enter_tabpage(tabpage_T * tp,buf_T * old_curbuf UNUSED,int trigger_enter_autocmds,int trigger_leave_autocmds)4206 enter_tabpage(
4207 tabpage_T *tp,
4208 buf_T *old_curbuf UNUSED,
4209 int trigger_enter_autocmds,
4210 int trigger_leave_autocmds)
4211 {
4212 int row;
4213 int old_off = tp->tp_firstwin->w_winrow;
4214 win_T *next_prevwin = tp->tp_prevwin;
4215 tabpage_T *last_tab = curtab;
4216
4217 curtab = tp;
4218 firstwin = tp->tp_firstwin;
4219 lastwin = tp->tp_lastwin;
4220 topframe = tp->tp_topframe;
4221
4222 // We would like doing the TabEnter event first, but we don't have a
4223 // valid current window yet, which may break some commands.
4224 // This triggers autocommands, thus may make "tp" invalid.
4225 (void)win_enter_ext(tp->tp_curwin, WEE_CURWIN_INVALID
4226 | (trigger_enter_autocmds ? WEE_TRIGGER_ENTER_AUTOCMDS : 0)
4227 | (trigger_leave_autocmds ? WEE_TRIGGER_LEAVE_AUTOCMDS : 0));
4228 prevwin = next_prevwin;
4229
4230 last_status(FALSE); // status line may appear or disappear
4231 row = win_comp_pos(); // recompute w_winrow for all windows
4232 #ifdef FEAT_DIFF
4233 diff_need_scrollbind = TRUE;
4234 #endif
4235
4236 // The tabpage line may have appeared or disappeared, may need to resize
4237 // the frames for that. When the Vim window was resized need to update
4238 // frame sizes too. Use the stored value of p_ch, so that it can be
4239 // different for each tab page.
4240 if (p_ch != curtab->tp_ch_used)
4241 clear_cmdline = TRUE;
4242 p_ch = curtab->tp_ch_used;
4243
4244 // When cmdheight is changed in a tab page with '<C-w>-', cmdline_row is
4245 // changed but p_ch and tp_ch_used are not changed. Thus we also need to
4246 // check cmdline_row.
4247 if ((row < cmdline_row) && (cmdline_row <= Rows - p_ch))
4248 clear_cmdline = TRUE;
4249
4250 if (curtab->tp_old_Rows != Rows || (old_off != firstwin->w_winrow
4251 #ifdef FEAT_GUI_TABLINE
4252 && !gui_use_tabline()
4253 #endif
4254 ))
4255 shell_new_rows();
4256 if (curtab->tp_old_Columns != Columns && starting == 0)
4257 shell_new_columns(); // update window widths
4258
4259 lastused_tabpage = last_tab;
4260
4261 #if defined(FEAT_GUI)
4262 // When 'guioptions' includes 'L' or 'R' may have to remove or add
4263 // scrollbars. Have to update them anyway.
4264 gui_may_update_scrollbars();
4265 #endif
4266
4267 // Apply autocommands after updating the display, when 'rows' and
4268 // 'columns' have been set correctly.
4269 if (trigger_enter_autocmds)
4270 {
4271 apply_autocmds(EVENT_TABENTER, NULL, NULL, FALSE, curbuf);
4272 if (old_curbuf != curbuf)
4273 apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf);
4274 }
4275
4276 redraw_all_later(NOT_VALID);
4277 }
4278
4279 /*
4280 * Go to tab page "n". For ":tab N" and "Ngt".
4281 * When "n" is 9999 go to the last tab page.
4282 */
4283 void
goto_tabpage(int n)4284 goto_tabpage(int n)
4285 {
4286 tabpage_T *tp = NULL; // shut up compiler
4287 tabpage_T *ttp;
4288 int i;
4289
4290 if (text_locked())
4291 {
4292 // Not allowed when editing the command line.
4293 text_locked_msg();
4294 return;
4295 }
4296
4297 // If there is only one it can't work.
4298 if (first_tabpage->tp_next == NULL)
4299 {
4300 if (n > 1)
4301 beep_flush();
4302 return;
4303 }
4304
4305 if (n == 0)
4306 {
4307 // No count, go to next tab page, wrap around end.
4308 if (curtab->tp_next == NULL)
4309 tp = first_tabpage;
4310 else
4311 tp = curtab->tp_next;
4312 }
4313 else if (n < 0)
4314 {
4315 // "gT": go to previous tab page, wrap around end. "N gT" repeats
4316 // this N times.
4317 ttp = curtab;
4318 for (i = n; i < 0; ++i)
4319 {
4320 for (tp = first_tabpage; tp->tp_next != ttp && tp->tp_next != NULL;
4321 tp = tp->tp_next)
4322 ;
4323 ttp = tp;
4324 }
4325 }
4326 else if (n == 9999)
4327 {
4328 // Go to last tab page.
4329 for (tp = first_tabpage; tp->tp_next != NULL; tp = tp->tp_next)
4330 ;
4331 }
4332 else
4333 {
4334 // Go to tab page "n".
4335 tp = find_tabpage(n);
4336 if (tp == NULL)
4337 {
4338 beep_flush();
4339 return;
4340 }
4341 }
4342
4343 goto_tabpage_tp(tp, TRUE, TRUE);
4344
4345 #ifdef FEAT_GUI_TABLINE
4346 if (gui_use_tabline())
4347 gui_mch_set_curtab(tabpage_index(curtab));
4348 #endif
4349 }
4350
4351 /*
4352 * Go to tabpage "tp".
4353 * Only trigger *Enter autocommands when trigger_enter_autocmds is TRUE.
4354 * Only trigger *Leave autocommands when trigger_leave_autocmds is TRUE.
4355 * Note: doesn't update the GUI tab.
4356 */
4357 void
goto_tabpage_tp(tabpage_T * tp,int trigger_enter_autocmds,int trigger_leave_autocmds)4358 goto_tabpage_tp(
4359 tabpage_T *tp,
4360 int trigger_enter_autocmds,
4361 int trigger_leave_autocmds)
4362 {
4363 // Don't repeat a message in another tab page.
4364 set_keep_msg(NULL, 0);
4365
4366 if (tp != curtab && leave_tabpage(tp->tp_curwin->w_buffer,
4367 trigger_leave_autocmds) == OK)
4368 {
4369 if (valid_tabpage(tp))
4370 enter_tabpage(tp, curbuf, trigger_enter_autocmds,
4371 trigger_leave_autocmds);
4372 else
4373 enter_tabpage(curtab, curbuf, trigger_enter_autocmds,
4374 trigger_leave_autocmds);
4375 }
4376 }
4377
4378 /*
4379 * Go to the last accessed tab page, if there is one.
4380 * Return OK or FAIL
4381 */
4382 int
goto_tabpage_lastused(void)4383 goto_tabpage_lastused(void)
4384 {
4385 if (valid_tabpage(lastused_tabpage))
4386 {
4387 goto_tabpage_tp(lastused_tabpage, TRUE, TRUE);
4388 return OK;
4389 }
4390 return FAIL;
4391 }
4392
4393 /*
4394 * Enter window "wp" in tab page "tp".
4395 * Also updates the GUI tab.
4396 */
4397 void
goto_tabpage_win(tabpage_T * tp,win_T * wp)4398 goto_tabpage_win(tabpage_T *tp, win_T *wp)
4399 {
4400 goto_tabpage_tp(tp, TRUE, TRUE);
4401 if (curtab == tp && win_valid(wp))
4402 {
4403 win_enter(wp, TRUE);
4404 # ifdef FEAT_GUI_TABLINE
4405 if (gui_use_tabline())
4406 gui_mch_set_curtab(tabpage_index(curtab));
4407 # endif
4408 }
4409 }
4410
4411 /*
4412 * Move the current tab page to after tab page "nr".
4413 */
4414 void
tabpage_move(int nr)4415 tabpage_move(int nr)
4416 {
4417 int n = 1;
4418 tabpage_T *tp, *tp_dst;
4419
4420 if (first_tabpage->tp_next == NULL)
4421 return;
4422
4423 for (tp = first_tabpage; tp->tp_next != NULL && n < nr; tp = tp->tp_next)
4424 ++n;
4425
4426 if (tp == curtab || (nr > 0 && tp->tp_next != NULL
4427 && tp->tp_next == curtab))
4428 return;
4429
4430 tp_dst = tp;
4431
4432 // Remove the current tab page from the list of tab pages.
4433 if (curtab == first_tabpage)
4434 first_tabpage = curtab->tp_next;
4435 else
4436 {
4437 FOR_ALL_TABPAGES(tp)
4438 if (tp->tp_next == curtab)
4439 break;
4440 if (tp == NULL) // "cannot happen"
4441 return;
4442 tp->tp_next = curtab->tp_next;
4443 }
4444
4445 // Re-insert it at the specified position.
4446 if (nr <= 0)
4447 {
4448 curtab->tp_next = first_tabpage;
4449 first_tabpage = curtab;
4450 }
4451 else
4452 {
4453 curtab->tp_next = tp_dst->tp_next;
4454 tp_dst->tp_next = curtab;
4455 }
4456
4457 // Need to redraw the tabline. Tab page contents doesn't change.
4458 redraw_tabline = TRUE;
4459 }
4460
4461
4462 /*
4463 * Go to another window.
4464 * When jumping to another buffer, stop Visual mode. Do this before
4465 * changing windows so we can yank the selection into the '*' register.
4466 * When jumping to another window on the same buffer, adjust its cursor
4467 * position to keep the same Visual area.
4468 */
4469 void
win_goto(win_T * wp)4470 win_goto(win_T *wp)
4471 {
4472 #ifdef FEAT_CONCEAL
4473 win_T *owp = curwin;
4474 #endif
4475
4476 #ifdef FEAT_PROP_POPUP
4477 if (ERROR_IF_ANY_POPUP_WINDOW)
4478 return;
4479 if (popup_is_popup(wp))
4480 {
4481 emsg(_("E366: Not allowed to enter a popup window"));
4482 return;
4483 }
4484 #endif
4485 if (text_and_win_locked())
4486 {
4487 beep_flush();
4488 text_locked_msg();
4489 return;
4490 }
4491 if (curbuf_locked())
4492 return;
4493
4494 if (wp->w_buffer != curbuf)
4495 reset_VIsual_and_resel();
4496 else if (VIsual_active)
4497 wp->w_cursor = curwin->w_cursor;
4498
4499 #ifdef FEAT_GUI
4500 need_mouse_correct = TRUE;
4501 #endif
4502 win_enter(wp, TRUE);
4503
4504 #ifdef FEAT_CONCEAL
4505 // Conceal cursor line in previous window, unconceal in current window.
4506 if (win_valid(owp) && owp->w_p_cole > 0 && !msg_scrolled)
4507 redrawWinline(owp, owp->w_cursor.lnum);
4508 if (curwin->w_p_cole > 0 && !msg_scrolled)
4509 need_cursor_line_redraw = TRUE;
4510 #endif
4511 }
4512
4513 #if defined(FEAT_PERL) || defined(PROTO)
4514 /*
4515 * Find window number "winnr" (counting top to bottom).
4516 */
4517 win_T *
win_find_nr(int winnr)4518 win_find_nr(int winnr)
4519 {
4520 win_T *wp;
4521
4522 FOR_ALL_WINDOWS(wp)
4523 if (--winnr == 0)
4524 break;
4525 return wp;
4526 }
4527 #endif
4528
4529 #if ((defined(FEAT_PYTHON) || defined(FEAT_PYTHON3))) || defined(PROTO)
4530 /*
4531 * Find the tabpage for window "win".
4532 */
4533 tabpage_T *
win_find_tabpage(win_T * win)4534 win_find_tabpage(win_T *win)
4535 {
4536 win_T *wp;
4537 tabpage_T *tp;
4538
4539 FOR_ALL_TAB_WINDOWS(tp, wp)
4540 if (wp == win)
4541 return tp;
4542 return NULL;
4543 }
4544 #endif
4545
4546 /*
4547 * Get the above or below neighbor window of the specified window.
4548 * up - TRUE for the above neighbor
4549 * count - nth neighbor window
4550 * Returns the specified window if the neighbor is not found.
4551 */
4552 win_T *
win_vert_neighbor(tabpage_T * tp,win_T * wp,int up,long count)4553 win_vert_neighbor(tabpage_T *tp, win_T *wp, int up, long count)
4554 {
4555 frame_T *fr;
4556 frame_T *nfr;
4557 frame_T *foundfr;
4558
4559 #ifdef FEAT_PROP_POPUP
4560 if (popup_is_popup(wp))
4561 // popups don't have neighbors.
4562 return NULL;
4563 #endif
4564 foundfr = wp->w_frame;
4565 while (count--)
4566 {
4567 /*
4568 * First go upwards in the tree of frames until we find a upwards or
4569 * downwards neighbor.
4570 */
4571 fr = foundfr;
4572 for (;;)
4573 {
4574 if (fr == tp->tp_topframe)
4575 goto end;
4576 if (up)
4577 nfr = fr->fr_prev;
4578 else
4579 nfr = fr->fr_next;
4580 if (fr->fr_parent->fr_layout == FR_COL && nfr != NULL)
4581 break;
4582 fr = fr->fr_parent;
4583 }
4584
4585 /*
4586 * Now go downwards to find the bottom or top frame in it.
4587 */
4588 for (;;)
4589 {
4590 if (nfr->fr_layout == FR_LEAF)
4591 {
4592 foundfr = nfr;
4593 break;
4594 }
4595 fr = nfr->fr_child;
4596 if (nfr->fr_layout == FR_ROW)
4597 {
4598 // Find the frame at the cursor row.
4599 while (fr->fr_next != NULL
4600 && frame2win(fr)->w_wincol + fr->fr_width
4601 <= wp->w_wincol + wp->w_wcol)
4602 fr = fr->fr_next;
4603 }
4604 if (nfr->fr_layout == FR_COL && up)
4605 while (fr->fr_next != NULL)
4606 fr = fr->fr_next;
4607 nfr = fr;
4608 }
4609 }
4610 end:
4611 return foundfr != NULL ? foundfr->fr_win : NULL;
4612 }
4613
4614 /*
4615 * Move to window above or below "count" times.
4616 */
4617 static void
win_goto_ver(int up,long count)4618 win_goto_ver(
4619 int up, // TRUE to go to win above
4620 long count)
4621 {
4622 win_T *win;
4623
4624 #ifdef FEAT_PROP_POPUP
4625 if (ERROR_IF_TERM_POPUP_WINDOW)
4626 return;
4627 #endif
4628 win = win_vert_neighbor(curtab, curwin, up, count);
4629 if (win != NULL)
4630 win_goto(win);
4631 }
4632
4633 /*
4634 * Get the left or right neighbor window of the specified window.
4635 * left - TRUE for the left neighbor
4636 * count - nth neighbor window
4637 * Returns the specified window if the neighbor is not found.
4638 */
4639 win_T *
win_horz_neighbor(tabpage_T * tp,win_T * wp,int left,long count)4640 win_horz_neighbor(tabpage_T *tp, win_T *wp, int left, long count)
4641 {
4642 frame_T *fr;
4643 frame_T *nfr;
4644 frame_T *foundfr;
4645
4646 #ifdef FEAT_PROP_POPUP
4647 if (popup_is_popup(wp))
4648 // popups don't have neighbors.
4649 return NULL;
4650 #endif
4651 foundfr = wp->w_frame;
4652 while (count--)
4653 {
4654 /*
4655 * First go upwards in the tree of frames until we find a left or
4656 * right neighbor.
4657 */
4658 fr = foundfr;
4659 for (;;)
4660 {
4661 if (fr == tp->tp_topframe)
4662 goto end;
4663 if (left)
4664 nfr = fr->fr_prev;
4665 else
4666 nfr = fr->fr_next;
4667 if (fr->fr_parent->fr_layout == FR_ROW && nfr != NULL)
4668 break;
4669 fr = fr->fr_parent;
4670 }
4671
4672 /*
4673 * Now go downwards to find the leftmost or rightmost frame in it.
4674 */
4675 for (;;)
4676 {
4677 if (nfr->fr_layout == FR_LEAF)
4678 {
4679 foundfr = nfr;
4680 break;
4681 }
4682 fr = nfr->fr_child;
4683 if (nfr->fr_layout == FR_COL)
4684 {
4685 // Find the frame at the cursor row.
4686 while (fr->fr_next != NULL
4687 && frame2win(fr)->w_winrow + fr->fr_height
4688 <= wp->w_winrow + wp->w_wrow)
4689 fr = fr->fr_next;
4690 }
4691 if (nfr->fr_layout == FR_ROW && left)
4692 while (fr->fr_next != NULL)
4693 fr = fr->fr_next;
4694 nfr = fr;
4695 }
4696 }
4697 end:
4698 return foundfr != NULL ? foundfr->fr_win : NULL;
4699 }
4700
4701 /*
4702 * Move to left or right window.
4703 */
4704 static void
win_goto_hor(int left,long count)4705 win_goto_hor(
4706 int left, // TRUE to go to left win
4707 long count)
4708 {
4709 win_T *win;
4710
4711 #ifdef FEAT_PROP_POPUP
4712 if (ERROR_IF_TERM_POPUP_WINDOW)
4713 return;
4714 #endif
4715 win = win_horz_neighbor(curtab, curwin, left, count);
4716 if (win != NULL)
4717 win_goto(win);
4718 }
4719
4720 /*
4721 * Make window "wp" the current window.
4722 */
4723 void
win_enter(win_T * wp,int undo_sync)4724 win_enter(win_T *wp, int undo_sync)
4725 {
4726 (void)win_enter_ext(wp, (undo_sync ? WEE_UNDO_SYNC : 0)
4727 | WEE_TRIGGER_ENTER_AUTOCMDS | WEE_TRIGGER_LEAVE_AUTOCMDS);
4728 }
4729
4730 /*
4731 * Make window "wp" the current window.
4732 * Can be called with "flags" containing WEE_CURWIN_INVALID, which means that
4733 * curwin has just been closed and isn't valid.
4734 * Returns TRUE when dont_parse_messages was decremented.
4735 */
4736 static int
win_enter_ext(win_T * wp,int flags)4737 win_enter_ext(win_T *wp, int flags)
4738 {
4739 int other_buffer = FALSE;
4740 int curwin_invalid = (flags & WEE_CURWIN_INVALID);
4741 int did_decrement = FALSE;
4742
4743 if (wp == curwin && !curwin_invalid) // nothing to do
4744 return FALSE;
4745
4746 #ifdef FEAT_JOB_CHANNEL
4747 if (!curwin_invalid)
4748 leaving_window(curwin);
4749 #endif
4750
4751 if (!curwin_invalid && (flags & WEE_TRIGGER_LEAVE_AUTOCMDS))
4752 {
4753 /*
4754 * Be careful: If autocommands delete the window, return now.
4755 */
4756 if (wp->w_buffer != curbuf)
4757 {
4758 apply_autocmds(EVENT_BUFLEAVE, NULL, NULL, FALSE, curbuf);
4759 other_buffer = TRUE;
4760 if (!win_valid(wp))
4761 return FALSE;
4762 }
4763 apply_autocmds(EVENT_WINLEAVE, NULL, NULL, FALSE, curbuf);
4764 if (!win_valid(wp))
4765 return FALSE;
4766 #ifdef FEAT_EVAL
4767 // autocmds may abort script processing
4768 if (aborting())
4769 return FALSE;
4770 #endif
4771 }
4772
4773 // sync undo before leaving the current buffer
4774 if ((flags & WEE_UNDO_SYNC) && curbuf != wp->w_buffer)
4775 u_sync(FALSE);
4776
4777 // Might need to scroll the old window before switching, e.g., when the
4778 // cursor was moved.
4779 update_topline();
4780
4781 // may have to copy the buffer options when 'cpo' contains 'S'
4782 if (wp->w_buffer != curbuf)
4783 buf_copy_options(wp->w_buffer, BCO_ENTER | BCO_NOHELP);
4784 if (!curwin_invalid)
4785 {
4786 prevwin = curwin; // remember for CTRL-W p
4787 curwin->w_redr_status = TRUE;
4788 }
4789 curwin = wp;
4790 curbuf = wp->w_buffer;
4791 check_cursor();
4792 if (!virtual_active())
4793 curwin->w_cursor.coladd = 0;
4794 changed_line_abv_curs(); // assume cursor position needs updating
4795
4796 // Now it is OK to parse messages again, which may be needed in
4797 // autocommands.
4798 #ifdef MESSAGE_QUEUE
4799 if (flags & WEE_ALLOW_PARSE_MESSAGES)
4800 {
4801 --dont_parse_messages;
4802 did_decrement = TRUE;
4803 }
4804 #endif
4805
4806 fix_current_dir();
4807
4808 #ifdef FEAT_JOB_CHANNEL
4809 entering_window(curwin);
4810 #endif
4811 // Careful: autocommands may close the window and make "wp" invalid
4812 if (flags & WEE_TRIGGER_NEW_AUTOCMDS)
4813 apply_autocmds(EVENT_WINNEW, NULL, NULL, FALSE, curbuf);
4814 if (flags & WEE_TRIGGER_ENTER_AUTOCMDS)
4815 {
4816 apply_autocmds(EVENT_WINENTER, NULL, NULL, FALSE, curbuf);
4817 if (other_buffer)
4818 apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf);
4819 }
4820
4821 maketitle();
4822 curwin->w_redr_status = TRUE;
4823 #ifdef FEAT_TERMINAL
4824 if (bt_terminal(curwin->w_buffer))
4825 // terminal is likely in another mode
4826 redraw_mode = TRUE;
4827 #endif
4828 redraw_tabline = TRUE;
4829 if (restart_edit)
4830 redraw_later(VALID); // causes status line redraw
4831
4832 // set window height to desired minimal value
4833 if (curwin->w_height < p_wh && !curwin->w_p_wfh
4834 #ifdef FEAT_PROP_POPUP
4835 && !popup_is_popup(curwin)
4836 #endif
4837 )
4838 win_setheight((int)p_wh);
4839 else if (curwin->w_height == 0)
4840 win_setheight(1);
4841
4842 // set window width to desired minimal value
4843 if (curwin->w_width < p_wiw && !curwin->w_p_wfw)
4844 win_setwidth((int)p_wiw);
4845
4846 setmouse(); // in case jumped to/from help buffer
4847
4848 // Change directories when the 'acd' option is set.
4849 DO_AUTOCHDIR;
4850
4851 return did_decrement;
4852 }
4853
4854 /*
4855 * Used after making another window the current one: change directory if
4856 * needed.
4857 */
4858 void
fix_current_dir(void)4859 fix_current_dir(void)
4860 {
4861 #ifdef FEAT_AUTOCHDIR
4862 if (p_acd)
4863 do_autochdir();
4864 else
4865 #endif
4866 if (curwin->w_localdir != NULL || curtab->tp_localdir != NULL)
4867 {
4868 char_u *dirname;
4869
4870 // Window or tab has a local directory: Save current directory as
4871 // global directory (unless that was done already) and change to the
4872 // local directory.
4873 if (globaldir == NULL)
4874 {
4875 char_u cwd[MAXPATHL];
4876
4877 if (mch_dirname(cwd, MAXPATHL) == OK)
4878 globaldir = vim_strsave(cwd);
4879 }
4880 if (curwin->w_localdir != NULL)
4881 dirname = curwin->w_localdir;
4882 else
4883 dirname = curtab->tp_localdir;
4884
4885 if (mch_chdir((char *)dirname) == 0)
4886 {
4887 last_chdir_reason = NULL;
4888 shorten_fnames(TRUE);
4889 }
4890 }
4891 else if (globaldir != NULL)
4892 {
4893 // Window doesn't have a local directory and we are not in the global
4894 // directory: Change to the global directory.
4895 vim_ignored = mch_chdir((char *)globaldir);
4896 VIM_CLEAR(globaldir);
4897 last_chdir_reason = NULL;
4898 shorten_fnames(TRUE);
4899 }
4900 }
4901
4902 /*
4903 * Jump to the first open window that contains buffer "buf", if one exists.
4904 * Returns a pointer to the window found, otherwise NULL.
4905 */
4906 win_T *
buf_jump_open_win(buf_T * buf)4907 buf_jump_open_win(buf_T *buf)
4908 {
4909 win_T *wp = NULL;
4910
4911 if (curwin->w_buffer == buf)
4912 wp = curwin;
4913 else
4914 FOR_ALL_WINDOWS(wp)
4915 if (wp->w_buffer == buf)
4916 break;
4917 if (wp != NULL)
4918 win_enter(wp, FALSE);
4919 return wp;
4920 }
4921
4922 /*
4923 * Jump to the first open window in any tab page that contains buffer "buf",
4924 * if one exists.
4925 * Returns a pointer to the window found, otherwise NULL.
4926 */
4927 win_T *
buf_jump_open_tab(buf_T * buf)4928 buf_jump_open_tab(buf_T *buf)
4929 {
4930 win_T *wp = buf_jump_open_win(buf);
4931 tabpage_T *tp;
4932
4933 if (wp != NULL)
4934 return wp;
4935
4936 FOR_ALL_TABPAGES(tp)
4937 if (tp != curtab)
4938 {
4939 FOR_ALL_WINDOWS_IN_TAB(tp, wp)
4940 if (wp->w_buffer == buf)
4941 break;
4942 if (wp != NULL)
4943 {
4944 goto_tabpage_win(tp, wp);
4945 if (curwin != wp)
4946 wp = NULL; // something went wrong
4947 break;
4948 }
4949 }
4950 return wp;
4951 }
4952
4953 static int last_win_id = LOWEST_WIN_ID - 1;
4954
4955 /*
4956 * Allocate a window structure and link it in the window list when "hidden" is
4957 * FALSE.
4958 */
4959 static win_T *
win_alloc(win_T * after UNUSED,int hidden UNUSED)4960 win_alloc(win_T *after UNUSED, int hidden UNUSED)
4961 {
4962 win_T *new_wp;
4963
4964 /*
4965 * allocate window structure and linesizes arrays
4966 */
4967 new_wp = ALLOC_CLEAR_ONE(win_T);
4968 if (new_wp == NULL)
4969 return NULL;
4970
4971 if (win_alloc_lines(new_wp) == FAIL)
4972 {
4973 vim_free(new_wp);
4974 return NULL;
4975 }
4976
4977 new_wp->w_id = ++last_win_id;
4978
4979 #ifdef FEAT_EVAL
4980 // init w: variables
4981 new_wp->w_vars = dict_alloc();
4982 if (new_wp->w_vars == NULL)
4983 {
4984 win_free_lsize(new_wp);
4985 vim_free(new_wp);
4986 return NULL;
4987 }
4988 init_var_dict(new_wp->w_vars, &new_wp->w_winvar, VAR_SCOPE);
4989 #endif
4990
4991 // Don't execute autocommands while the window is not properly
4992 // initialized yet. gui_create_scrollbar() may trigger a FocusGained
4993 // event.
4994 block_autocmds();
4995
4996 /*
4997 * link the window in the window list
4998 */
4999 if (!hidden)
5000 win_append(after, new_wp);
5001 new_wp->w_wincol = 0;
5002 new_wp->w_width = Columns;
5003
5004 // position the display and the cursor at the top of the file.
5005 new_wp->w_topline = 1;
5006 #ifdef FEAT_DIFF
5007 new_wp->w_topfill = 0;
5008 #endif
5009 new_wp->w_botline = 2;
5010 new_wp->w_cursor.lnum = 1;
5011 new_wp->w_scbind_pos = 1;
5012
5013 // use global option value for global-local options
5014 new_wp->w_p_so = -1;
5015 new_wp->w_p_siso = -1;
5016
5017 // We won't calculate w_fraction until resizing the window
5018 new_wp->w_fraction = 0;
5019 new_wp->w_prev_fraction_row = -1;
5020
5021 #ifdef FEAT_GUI
5022 if (gui.in_use)
5023 {
5024 gui_create_scrollbar(&new_wp->w_scrollbars[SBAR_LEFT],
5025 SBAR_LEFT, new_wp);
5026 gui_create_scrollbar(&new_wp->w_scrollbars[SBAR_RIGHT],
5027 SBAR_RIGHT, new_wp);
5028 }
5029 #endif
5030 #ifdef FEAT_FOLDING
5031 foldInitWin(new_wp);
5032 #endif
5033 unblock_autocmds();
5034 #ifdef FEAT_SEARCH_EXTRA
5035 new_wp->w_match_head = NULL;
5036 new_wp->w_next_match_id = 4;
5037 #endif
5038 return new_wp;
5039 }
5040
5041 /*
5042 * Remove window 'wp' from the window list and free the structure.
5043 */
5044 static void
win_free(win_T * wp,tabpage_T * tp)5045 win_free(
5046 win_T *wp,
5047 tabpage_T *tp) // tab page "win" is in, NULL for current
5048 {
5049 int i;
5050 buf_T *buf;
5051 wininfo_T *wip;
5052
5053 #ifdef FEAT_FOLDING
5054 clearFolding(wp);
5055 #endif
5056
5057 // reduce the reference count to the argument list.
5058 alist_unlink(wp->w_alist);
5059
5060 // Don't execute autocommands while the window is halfway being deleted.
5061 // gui_mch_destroy_scrollbar() may trigger a FocusGained event.
5062 block_autocmds();
5063
5064 #ifdef FEAT_LUA
5065 lua_window_free(wp);
5066 #endif
5067
5068 #ifdef FEAT_MZSCHEME
5069 mzscheme_window_free(wp);
5070 #endif
5071
5072 #ifdef FEAT_PERL
5073 perl_win_free(wp);
5074 #endif
5075
5076 #ifdef FEAT_PYTHON
5077 python_window_free(wp);
5078 #endif
5079
5080 #ifdef FEAT_PYTHON3
5081 python3_window_free(wp);
5082 #endif
5083
5084 #ifdef FEAT_TCL
5085 tcl_window_free(wp);
5086 #endif
5087
5088 #ifdef FEAT_RUBY
5089 ruby_window_free(wp);
5090 #endif
5091
5092 clear_winopt(&wp->w_onebuf_opt);
5093 clear_winopt(&wp->w_allbuf_opt);
5094
5095 vim_free(wp->w_lcs_chars.multispace);
5096
5097 #ifdef FEAT_EVAL
5098 vars_clear(&wp->w_vars->dv_hashtab); // free all w: variables
5099 hash_init(&wp->w_vars->dv_hashtab);
5100 unref_var_dict(wp->w_vars);
5101 #endif
5102
5103 {
5104 tabpage_T *ttp;
5105
5106 if (prevwin == wp)
5107 prevwin = NULL;
5108 FOR_ALL_TABPAGES(ttp)
5109 if (ttp->tp_prevwin == wp)
5110 ttp->tp_prevwin = NULL;
5111 }
5112 win_free_lsize(wp);
5113
5114 for (i = 0; i < wp->w_tagstacklen; ++i)
5115 {
5116 vim_free(wp->w_tagstack[i].tagname);
5117 vim_free(wp->w_tagstack[i].user_data);
5118 }
5119 vim_free(wp->w_localdir);
5120 vim_free(wp->w_prevdir);
5121
5122 // Remove the window from the b_wininfo lists, it may happen that the
5123 // freed memory is re-used for another window.
5124 FOR_ALL_BUFFERS(buf)
5125 FOR_ALL_BUF_WININFO(buf, wip)
5126 if (wip->wi_win == wp)
5127 {
5128 wininfo_T *wip2;
5129
5130 // If there already is an entry with "wi_win" set to NULL it
5131 // must be removed, it would never be used.
5132 // Skip "wip" itself, otherwise Coverity complains.
5133 for (wip2 = buf->b_wininfo; wip2 != NULL; wip2 = wip2->wi_next)
5134 if (wip2 != wip && wip2->wi_win == NULL)
5135 {
5136 if (wip2->wi_next != NULL)
5137 wip2->wi_next->wi_prev = wip2->wi_prev;
5138 if (wip2->wi_prev == NULL)
5139 buf->b_wininfo = wip2->wi_next;
5140 else
5141 wip2->wi_prev->wi_next = wip2->wi_next;
5142 free_wininfo(wip2);
5143 break;
5144 }
5145
5146 wip->wi_win = NULL;
5147 }
5148
5149 #ifdef FEAT_SEARCH_EXTRA
5150 clear_matches(wp);
5151 #endif
5152
5153 #ifdef FEAT_JUMPLIST
5154 free_jumplist(wp);
5155 #endif
5156
5157 #ifdef FEAT_QUICKFIX
5158 qf_free_all(wp);
5159 #endif
5160
5161 #ifdef FEAT_GUI
5162 if (gui.in_use)
5163 {
5164 gui_mch_destroy_scrollbar(&wp->w_scrollbars[SBAR_LEFT]);
5165 gui_mch_destroy_scrollbar(&wp->w_scrollbars[SBAR_RIGHT]);
5166 }
5167 #endif // FEAT_GUI
5168
5169 #ifdef FEAT_MENU
5170 remove_winbar(wp);
5171 #endif
5172 #ifdef FEAT_PROP_POPUP
5173 free_callback(&wp->w_close_cb);
5174 free_callback(&wp->w_filter_cb);
5175 for (i = 0; i < 4; ++i)
5176 VIM_CLEAR(wp->w_border_highlight[i]);
5177 vim_free(wp->w_scrollbar_highlight);
5178 vim_free(wp->w_thumb_highlight);
5179 vim_free(wp->w_popup_title);
5180 list_unref(wp->w_popup_mask);
5181 vim_free(wp->w_popup_mask_cells);
5182 #endif
5183
5184 #ifdef FEAT_SYN_HL
5185 vim_free(wp->w_p_cc_cols);
5186 #endif
5187
5188 if (win_valid_any_tab(wp))
5189 win_remove(wp, tp);
5190 if (autocmd_busy)
5191 {
5192 wp->w_next = au_pending_free_win;
5193 au_pending_free_win = wp;
5194 }
5195 else
5196 vim_free(wp);
5197
5198 unblock_autocmds();
5199 }
5200
5201 /*
5202 * Return TRUE if "wp" is not in the list of windows: the autocmd window or a
5203 * popup window.
5204 */
5205 static int
win_unlisted(win_T * wp)5206 win_unlisted(win_T *wp)
5207 {
5208 return wp == aucmd_win || WIN_IS_POPUP(wp);
5209 }
5210
5211 #if defined(FEAT_PROP_POPUP) || defined(PROTO)
5212 /*
5213 * Free a popup window. This does not take the window out of the window list
5214 * and assumes there is only one toplevel frame, no split.
5215 */
5216 void
win_free_popup(win_T * win)5217 win_free_popup(win_T *win)
5218 {
5219 if (bt_popup(win->w_buffer))
5220 win_close_buffer(win, DOBUF_WIPE_REUSE, FALSE);
5221 else
5222 close_buffer(win, win->w_buffer, 0, FALSE, FALSE);
5223 # if defined(FEAT_TIMERS)
5224 if (win->w_popup_timer != NULL)
5225 stop_timer(win->w_popup_timer);
5226 # endif
5227 vim_free(win->w_frame);
5228 win_free(win, NULL);
5229 }
5230 #endif
5231
5232 /*
5233 * Append window "wp" in the window list after window "after".
5234 */
5235 static void
win_append(win_T * after,win_T * wp)5236 win_append(win_T *after, win_T *wp)
5237 {
5238 win_T *before;
5239
5240 if (after == NULL) // after NULL is in front of the first
5241 before = firstwin;
5242 else
5243 before = after->w_next;
5244
5245 wp->w_next = before;
5246 wp->w_prev = after;
5247 if (after == NULL)
5248 firstwin = wp;
5249 else
5250 after->w_next = wp;
5251 if (before == NULL)
5252 lastwin = wp;
5253 else
5254 before->w_prev = wp;
5255 }
5256
5257 /*
5258 * Remove a window from the window list.
5259 */
5260 void
win_remove(win_T * wp,tabpage_T * tp)5261 win_remove(
5262 win_T *wp,
5263 tabpage_T *tp) // tab page "win" is in, NULL for current
5264 {
5265 if (wp->w_prev != NULL)
5266 wp->w_prev->w_next = wp->w_next;
5267 else if (tp == NULL)
5268 firstwin = curtab->tp_firstwin = wp->w_next;
5269 else
5270 tp->tp_firstwin = wp->w_next;
5271
5272 if (wp->w_next != NULL)
5273 wp->w_next->w_prev = wp->w_prev;
5274 else if (tp == NULL)
5275 lastwin = curtab->tp_lastwin = wp->w_prev;
5276 else
5277 tp->tp_lastwin = wp->w_prev;
5278 }
5279
5280 /*
5281 * Append frame "frp" in a frame list after frame "after".
5282 */
5283 static void
frame_append(frame_T * after,frame_T * frp)5284 frame_append(frame_T *after, frame_T *frp)
5285 {
5286 frp->fr_next = after->fr_next;
5287 after->fr_next = frp;
5288 if (frp->fr_next != NULL)
5289 frp->fr_next->fr_prev = frp;
5290 frp->fr_prev = after;
5291 }
5292
5293 /*
5294 * Insert frame "frp" in a frame list before frame "before".
5295 */
5296 static void
frame_insert(frame_T * before,frame_T * frp)5297 frame_insert(frame_T *before, frame_T *frp)
5298 {
5299 frp->fr_next = before;
5300 frp->fr_prev = before->fr_prev;
5301 before->fr_prev = frp;
5302 if (frp->fr_prev != NULL)
5303 frp->fr_prev->fr_next = frp;
5304 else
5305 frp->fr_parent->fr_child = frp;
5306 }
5307
5308 /*
5309 * Remove a frame from a frame list.
5310 */
5311 static void
frame_remove(frame_T * frp)5312 frame_remove(frame_T *frp)
5313 {
5314 if (frp->fr_prev != NULL)
5315 frp->fr_prev->fr_next = frp->fr_next;
5316 else
5317 frp->fr_parent->fr_child = frp->fr_next;
5318 if (frp->fr_next != NULL)
5319 frp->fr_next->fr_prev = frp->fr_prev;
5320 }
5321
5322 /*
5323 * Allocate w_lines[] for window "wp".
5324 * Return FAIL for failure, OK for success.
5325 */
5326 int
win_alloc_lines(win_T * wp)5327 win_alloc_lines(win_T *wp)
5328 {
5329 wp->w_lines_valid = 0;
5330 wp->w_lines = ALLOC_CLEAR_MULT(wline_T, Rows );
5331 if (wp->w_lines == NULL)
5332 return FAIL;
5333 return OK;
5334 }
5335
5336 /*
5337 * free lsize arrays for a window
5338 */
5339 void
win_free_lsize(win_T * wp)5340 win_free_lsize(win_T *wp)
5341 {
5342 // TODO: why would wp be NULL here?
5343 if (wp != NULL)
5344 VIM_CLEAR(wp->w_lines);
5345 }
5346
5347 /*
5348 * Called from win_new_shellsize() after Rows changed.
5349 * This only does the current tab page, others must be done when made active.
5350 */
5351 void
shell_new_rows(void)5352 shell_new_rows(void)
5353 {
5354 int h = (int)ROWS_AVAIL;
5355
5356 if (firstwin == NULL) // not initialized yet
5357 return;
5358 if (h < frame_minheight(topframe, NULL))
5359 h = frame_minheight(topframe, NULL);
5360
5361 // First try setting the heights of windows with 'winfixheight'. If
5362 // that doesn't result in the right height, forget about that option.
5363 frame_new_height(topframe, h, FALSE, TRUE);
5364 if (!frame_check_height(topframe, h))
5365 frame_new_height(topframe, h, FALSE, FALSE);
5366
5367 (void)win_comp_pos(); // recompute w_winrow and w_wincol
5368 compute_cmdrow();
5369 curtab->tp_ch_used = p_ch;
5370
5371 #if 0
5372 // Disabled: don't want making the screen smaller make a window larger.
5373 if (p_ea)
5374 win_equal(curwin, FALSE, 'v');
5375 #endif
5376 }
5377
5378 /*
5379 * Called from win_new_shellsize() after Columns changed.
5380 */
5381 void
shell_new_columns(void)5382 shell_new_columns(void)
5383 {
5384 if (firstwin == NULL) // not initialized yet
5385 return;
5386
5387 // First try setting the widths of windows with 'winfixwidth'. If that
5388 // doesn't result in the right width, forget about that option.
5389 frame_new_width(topframe, (int)Columns, FALSE, TRUE);
5390 if (!frame_check_width(topframe, Columns))
5391 frame_new_width(topframe, (int)Columns, FALSE, FALSE);
5392
5393 (void)win_comp_pos(); // recompute w_winrow and w_wincol
5394 #if 0
5395 // Disabled: don't want making the screen smaller make a window larger.
5396 if (p_ea)
5397 win_equal(curwin, FALSE, 'h');
5398 #endif
5399 }
5400
5401 #if defined(FEAT_CMDWIN) || defined(PROTO)
5402 /*
5403 * Save the size of all windows in "gap".
5404 */
5405 void
win_size_save(garray_T * gap)5406 win_size_save(garray_T *gap)
5407
5408 {
5409 win_T *wp;
5410
5411 ga_init2(gap, (int)sizeof(int), 1);
5412 if (ga_grow(gap, win_count() * 2 + 1) == OK)
5413 {
5414 // first entry is value of 'lines'
5415 ((int *)gap->ga_data)[gap->ga_len++] = Rows;
5416
5417 FOR_ALL_WINDOWS(wp)
5418 {
5419 ((int *)gap->ga_data)[gap->ga_len++] =
5420 wp->w_width + wp->w_vsep_width;
5421 ((int *)gap->ga_data)[gap->ga_len++] = wp->w_height;
5422 }
5423 }
5424 }
5425
5426 /*
5427 * Restore window sizes, but only if the number of windows is still the same
5428 * and 'lines' didn't change.
5429 * Does not free the growarray.
5430 */
5431 void
win_size_restore(garray_T * gap)5432 win_size_restore(garray_T *gap)
5433 {
5434 win_T *wp;
5435 int i, j;
5436
5437 if (win_count() * 2 + 1 == gap->ga_len
5438 && ((int *)gap->ga_data)[0] == Rows)
5439 {
5440 // The order matters, because frames contain other frames, but it's
5441 // difficult to get right. The easy way out is to do it twice.
5442 for (j = 0; j < 2; ++j)
5443 {
5444 i = 1;
5445 FOR_ALL_WINDOWS(wp)
5446 {
5447 frame_setwidth(wp->w_frame, ((int *)gap->ga_data)[i++]);
5448 win_setheight_win(((int *)gap->ga_data)[i++], wp);
5449 }
5450 }
5451 // recompute the window positions
5452 (void)win_comp_pos();
5453 }
5454 }
5455 #endif // FEAT_CMDWIN
5456
5457 /*
5458 * Update the position for all windows, using the width and height of the
5459 * frames.
5460 * Returns the row just after the last window.
5461 */
5462 int
win_comp_pos(void)5463 win_comp_pos(void)
5464 {
5465 int row = tabline_height();
5466 int col = 0;
5467
5468 frame_comp_pos(topframe, &row, &col);
5469 return row;
5470 }
5471
5472 /*
5473 * Update the position of the windows in frame "topfrp", using the width and
5474 * height of the frames.
5475 * "*row" and "*col" are the top-left position of the frame. They are updated
5476 * to the bottom-right position plus one.
5477 */
5478 static void
frame_comp_pos(frame_T * topfrp,int * row,int * col)5479 frame_comp_pos(frame_T *topfrp, int *row, int *col)
5480 {
5481 win_T *wp;
5482 frame_T *frp;
5483 int startcol;
5484 int startrow;
5485 int h;
5486
5487 wp = topfrp->fr_win;
5488 if (wp != NULL)
5489 {
5490 if (wp->w_winrow != *row || wp->w_wincol != *col)
5491 {
5492 // position changed, redraw
5493 wp->w_winrow = *row;
5494 wp->w_wincol = *col;
5495 redraw_win_later(wp, NOT_VALID);
5496 wp->w_redr_status = TRUE;
5497 }
5498 // WinBar will not show if the window height is zero
5499 h = VISIBLE_HEIGHT(wp) + wp->w_status_height;
5500 *row += h > topfrp->fr_height ? topfrp->fr_height : h;
5501 *col += wp->w_width + wp->w_vsep_width;
5502 }
5503 else
5504 {
5505 startrow = *row;
5506 startcol = *col;
5507 FOR_ALL_FRAMES(frp, topfrp->fr_child)
5508 {
5509 if (topfrp->fr_layout == FR_ROW)
5510 *row = startrow; // all frames are at the same row
5511 else
5512 *col = startcol; // all frames are at the same col
5513 frame_comp_pos(frp, row, col);
5514 }
5515 }
5516 }
5517
5518 /*
5519 * Set current window height and take care of repositioning other windows to
5520 * fit around it.
5521 */
5522 void
win_setheight(int height)5523 win_setheight(int height)
5524 {
5525 win_setheight_win(height, curwin);
5526 }
5527
5528 /*
5529 * Set the window height of window "win" and take care of repositioning other
5530 * windows to fit around it.
5531 */
5532 void
win_setheight_win(int height,win_T * win)5533 win_setheight_win(int height, win_T *win)
5534 {
5535 int row;
5536
5537 if (win == curwin)
5538 {
5539 // Always keep current window at least one line high, even when
5540 // 'winminheight' is zero.
5541 if (height < p_wmh)
5542 height = p_wmh;
5543 if (height == 0)
5544 height = 1;
5545 height += WINBAR_HEIGHT(curwin);
5546 }
5547
5548 frame_setheight(win->w_frame, height + win->w_status_height);
5549
5550 // recompute the window positions
5551 row = win_comp_pos();
5552
5553 /*
5554 * If there is extra space created between the last window and the command
5555 * line, clear it.
5556 */
5557 if (full_screen && msg_scrolled == 0 && row < cmdline_row)
5558 screen_fill(row, cmdline_row, 0, (int)Columns, ' ', ' ', 0);
5559 cmdline_row = row;
5560 msg_row = row;
5561 msg_col = 0;
5562
5563 redraw_all_later(NOT_VALID);
5564 }
5565
5566 /*
5567 * Set the height of a frame to "height" and take care that all frames and
5568 * windows inside it are resized. Also resize frames on the left and right if
5569 * the are in the same FR_ROW frame.
5570 *
5571 * Strategy:
5572 * If the frame is part of a FR_COL frame, try fitting the frame in that
5573 * frame. If that doesn't work (the FR_COL frame is too small), recursively
5574 * go to containing frames to resize them and make room.
5575 * If the frame is part of a FR_ROW frame, all frames must be resized as well.
5576 * Check for the minimal height of the FR_ROW frame.
5577 * At the top level we can also use change the command line height.
5578 */
5579 static void
frame_setheight(frame_T * curfrp,int height)5580 frame_setheight(frame_T *curfrp, int height)
5581 {
5582 int room; // total number of lines available
5583 int take; // number of lines taken from other windows
5584 int room_cmdline; // lines available from cmdline
5585 int run;
5586 frame_T *frp;
5587 int h;
5588 int room_reserved;
5589
5590 // If the height already is the desired value, nothing to do.
5591 if (curfrp->fr_height == height)
5592 return;
5593
5594 if (curfrp->fr_parent == NULL)
5595 {
5596 // topframe: can only change the command line
5597 if (height > ROWS_AVAIL)
5598 height = ROWS_AVAIL;
5599 if (height > 0)
5600 frame_new_height(curfrp, height, FALSE, FALSE);
5601 }
5602 else if (curfrp->fr_parent->fr_layout == FR_ROW)
5603 {
5604 // Row of frames: Also need to resize frames left and right of this
5605 // one. First check for the minimal height of these.
5606 h = frame_minheight(curfrp->fr_parent, NULL);
5607 if (height < h)
5608 height = h;
5609 frame_setheight(curfrp->fr_parent, height);
5610 }
5611 else
5612 {
5613 /*
5614 * Column of frames: try to change only frames in this column.
5615 */
5616 /*
5617 * Do this twice:
5618 * 1: compute room available, if it's not enough try resizing the
5619 * containing frame.
5620 * 2: compute the room available and adjust the height to it.
5621 * Try not to reduce the height of a window with 'winfixheight' set.
5622 */
5623 for (run = 1; run <= 2; ++run)
5624 {
5625 room = 0;
5626 room_reserved = 0;
5627 FOR_ALL_FRAMES(frp, curfrp->fr_parent->fr_child)
5628 {
5629 if (frp != curfrp
5630 && frp->fr_win != NULL
5631 && frp->fr_win->w_p_wfh)
5632 room_reserved += frp->fr_height;
5633 room += frp->fr_height;
5634 if (frp != curfrp)
5635 room -= frame_minheight(frp, NULL);
5636 }
5637 if (curfrp->fr_width != Columns)
5638 room_cmdline = 0;
5639 else
5640 {
5641 room_cmdline = Rows - p_ch - (lastwin->w_winrow
5642 + VISIBLE_HEIGHT(lastwin)
5643 + lastwin->w_status_height);
5644 if (room_cmdline < 0)
5645 room_cmdline = 0;
5646 }
5647
5648 if (height <= room + room_cmdline)
5649 break;
5650 if (run == 2 || curfrp->fr_width == Columns)
5651 {
5652 if (height > room + room_cmdline)
5653 height = room + room_cmdline;
5654 break;
5655 }
5656 frame_setheight(curfrp->fr_parent, height
5657 + frame_minheight(curfrp->fr_parent, NOWIN) - (int)p_wmh - 1);
5658 }
5659
5660 /*
5661 * Compute the number of lines we will take from others frames (can be
5662 * negative!).
5663 */
5664 take = height - curfrp->fr_height;
5665
5666 // If there is not enough room, also reduce the height of a window
5667 // with 'winfixheight' set.
5668 if (height > room + room_cmdline - room_reserved)
5669 room_reserved = room + room_cmdline - height;
5670 // If there is only a 'winfixheight' window and making the
5671 // window smaller, need to make the other window taller.
5672 if (take < 0 && room - curfrp->fr_height < room_reserved)
5673 room_reserved = 0;
5674
5675 if (take > 0 && room_cmdline > 0)
5676 {
5677 // use lines from cmdline first
5678 if (take < room_cmdline)
5679 room_cmdline = take;
5680 take -= room_cmdline;
5681 topframe->fr_height += room_cmdline;
5682 }
5683
5684 /*
5685 * set the current frame to the new height
5686 */
5687 frame_new_height(curfrp, height, FALSE, FALSE);
5688
5689 /*
5690 * First take lines from the frames after the current frame. If
5691 * that is not enough, takes lines from frames above the current
5692 * frame.
5693 */
5694 for (run = 0; run < 2; ++run)
5695 {
5696 if (run == 0)
5697 frp = curfrp->fr_next; // 1st run: start with next window
5698 else
5699 frp = curfrp->fr_prev; // 2nd run: start with prev window
5700 while (frp != NULL && take != 0)
5701 {
5702 h = frame_minheight(frp, NULL);
5703 if (room_reserved > 0
5704 && frp->fr_win != NULL
5705 && frp->fr_win->w_p_wfh)
5706 {
5707 if (room_reserved >= frp->fr_height)
5708 room_reserved -= frp->fr_height;
5709 else
5710 {
5711 if (frp->fr_height - room_reserved > take)
5712 room_reserved = frp->fr_height - take;
5713 take -= frp->fr_height - room_reserved;
5714 frame_new_height(frp, room_reserved, FALSE, FALSE);
5715 room_reserved = 0;
5716 }
5717 }
5718 else
5719 {
5720 if (frp->fr_height - take < h)
5721 {
5722 take -= frp->fr_height - h;
5723 frame_new_height(frp, h, FALSE, FALSE);
5724 }
5725 else
5726 {
5727 frame_new_height(frp, frp->fr_height - take,
5728 FALSE, FALSE);
5729 take = 0;
5730 }
5731 }
5732 if (run == 0)
5733 frp = frp->fr_next;
5734 else
5735 frp = frp->fr_prev;
5736 }
5737 }
5738 }
5739 }
5740
5741 /*
5742 * Set current window width and take care of repositioning other windows to
5743 * fit around it.
5744 */
5745 void
win_setwidth(int width)5746 win_setwidth(int width)
5747 {
5748 win_setwidth_win(width, curwin);
5749 }
5750
5751 void
win_setwidth_win(int width,win_T * wp)5752 win_setwidth_win(int width, win_T *wp)
5753 {
5754 // Always keep current window at least one column wide, even when
5755 // 'winminwidth' is zero.
5756 if (wp == curwin)
5757 {
5758 if (width < p_wmw)
5759 width = p_wmw;
5760 if (width == 0)
5761 width = 1;
5762 }
5763 else if (width < 0)
5764 width = 0;
5765
5766 frame_setwidth(wp->w_frame, width + wp->w_vsep_width);
5767
5768 // recompute the window positions
5769 (void)win_comp_pos();
5770
5771 redraw_all_later(NOT_VALID);
5772 }
5773
5774 /*
5775 * Set the width of a frame to "width" and take care that all frames and
5776 * windows inside it are resized. Also resize frames above and below if the
5777 * are in the same FR_ROW frame.
5778 *
5779 * Strategy is similar to frame_setheight().
5780 */
5781 static void
frame_setwidth(frame_T * curfrp,int width)5782 frame_setwidth(frame_T *curfrp, int width)
5783 {
5784 int room; // total number of lines available
5785 int take; // number of lines taken from other windows
5786 int run;
5787 frame_T *frp;
5788 int w;
5789 int room_reserved;
5790
5791 // If the width already is the desired value, nothing to do.
5792 if (curfrp->fr_width == width)
5793 return;
5794
5795 if (curfrp->fr_parent == NULL)
5796 // topframe: can't change width
5797 return;
5798
5799 if (curfrp->fr_parent->fr_layout == FR_COL)
5800 {
5801 // Column of frames: Also need to resize frames above and below of
5802 // this one. First check for the minimal width of these.
5803 w = frame_minwidth(curfrp->fr_parent, NULL);
5804 if (width < w)
5805 width = w;
5806 frame_setwidth(curfrp->fr_parent, width);
5807 }
5808 else
5809 {
5810 /*
5811 * Row of frames: try to change only frames in this row.
5812 *
5813 * Do this twice:
5814 * 1: compute room available, if it's not enough try resizing the
5815 * containing frame.
5816 * 2: compute the room available and adjust the width to it.
5817 */
5818 for (run = 1; run <= 2; ++run)
5819 {
5820 room = 0;
5821 room_reserved = 0;
5822 FOR_ALL_FRAMES(frp, curfrp->fr_parent->fr_child)
5823 {
5824 if (frp != curfrp
5825 && frp->fr_win != NULL
5826 && frp->fr_win->w_p_wfw)
5827 room_reserved += frp->fr_width;
5828 room += frp->fr_width;
5829 if (frp != curfrp)
5830 room -= frame_minwidth(frp, NULL);
5831 }
5832
5833 if (width <= room)
5834 break;
5835 if (run == 2 || curfrp->fr_height >= ROWS_AVAIL)
5836 {
5837 if (width > room)
5838 width = room;
5839 break;
5840 }
5841 frame_setwidth(curfrp->fr_parent, width
5842 + frame_minwidth(curfrp->fr_parent, NOWIN) - (int)p_wmw - 1);
5843 }
5844
5845 /*
5846 * Compute the number of lines we will take from others frames (can be
5847 * negative!).
5848 */
5849 take = width - curfrp->fr_width;
5850
5851 // If there is not enough room, also reduce the width of a window
5852 // with 'winfixwidth' set.
5853 if (width > room - room_reserved)
5854 room_reserved = room - width;
5855 // If there is only a 'winfixwidth' window and making the
5856 // window smaller, need to make the other window narrower.
5857 if (take < 0 && room - curfrp->fr_width < room_reserved)
5858 room_reserved = 0;
5859
5860 /*
5861 * set the current frame to the new width
5862 */
5863 frame_new_width(curfrp, width, FALSE, FALSE);
5864
5865 /*
5866 * First take lines from the frames right of the current frame. If
5867 * that is not enough, takes lines from frames left of the current
5868 * frame.
5869 */
5870 for (run = 0; run < 2; ++run)
5871 {
5872 if (run == 0)
5873 frp = curfrp->fr_next; // 1st run: start with next window
5874 else
5875 frp = curfrp->fr_prev; // 2nd run: start with prev window
5876 while (frp != NULL && take != 0)
5877 {
5878 w = frame_minwidth(frp, NULL);
5879 if (room_reserved > 0
5880 && frp->fr_win != NULL
5881 && frp->fr_win->w_p_wfw)
5882 {
5883 if (room_reserved >= frp->fr_width)
5884 room_reserved -= frp->fr_width;
5885 else
5886 {
5887 if (frp->fr_width - room_reserved > take)
5888 room_reserved = frp->fr_width - take;
5889 take -= frp->fr_width - room_reserved;
5890 frame_new_width(frp, room_reserved, FALSE, FALSE);
5891 room_reserved = 0;
5892 }
5893 }
5894 else
5895 {
5896 if (frp->fr_width - take < w)
5897 {
5898 take -= frp->fr_width - w;
5899 frame_new_width(frp, w, FALSE, FALSE);
5900 }
5901 else
5902 {
5903 frame_new_width(frp, frp->fr_width - take,
5904 FALSE, FALSE);
5905 take = 0;
5906 }
5907 }
5908 if (run == 0)
5909 frp = frp->fr_next;
5910 else
5911 frp = frp->fr_prev;
5912 }
5913 }
5914 }
5915 }
5916
5917 /*
5918 * Check 'winminheight' for a valid value and reduce it if needed.
5919 */
5920 void
win_setminheight(void)5921 win_setminheight(void)
5922 {
5923 int room;
5924 int needed;
5925 int first = TRUE;
5926
5927 // loop until there is a 'winminheight' that is possible
5928 while (p_wmh > 0)
5929 {
5930 room = Rows - p_ch;
5931 needed = min_rows() - 1; // 1 was added for the cmdline
5932 if (room >= needed)
5933 break;
5934 --p_wmh;
5935 if (first)
5936 {
5937 emsg(_(e_not_enough_room));
5938 first = FALSE;
5939 }
5940 }
5941 }
5942
5943 /*
5944 * Check 'winminwidth' for a valid value and reduce it if needed.
5945 */
5946 void
win_setminwidth(void)5947 win_setminwidth(void)
5948 {
5949 int room;
5950 int needed;
5951 int first = TRUE;
5952
5953 // loop until there is a 'winminheight' that is possible
5954 while (p_wmw > 0)
5955 {
5956 room = Columns;
5957 needed = frame_minwidth(topframe, NULL);
5958 if (room >= needed)
5959 break;
5960 --p_wmw;
5961 if (first)
5962 {
5963 emsg(_(e_not_enough_room));
5964 first = FALSE;
5965 }
5966 }
5967 }
5968
5969 /*
5970 * Status line of dragwin is dragged "offset" lines down (negative is up).
5971 */
5972 void
win_drag_status_line(win_T * dragwin,int offset)5973 win_drag_status_line(win_T *dragwin, int offset)
5974 {
5975 frame_T *curfr;
5976 frame_T *fr;
5977 int room;
5978 int row;
5979 int up; // if TRUE, drag status line up, otherwise down
5980 int n;
5981
5982 fr = dragwin->w_frame;
5983 curfr = fr;
5984 if (fr != topframe) // more than one window
5985 {
5986 fr = fr->fr_parent;
5987 // When the parent frame is not a column of frames, its parent should
5988 // be.
5989 if (fr->fr_layout != FR_COL)
5990 {
5991 curfr = fr;
5992 if (fr != topframe) // only a row of windows, may drag statusline
5993 fr = fr->fr_parent;
5994 }
5995 }
5996
5997 // If this is the last frame in a column, may want to resize the parent
5998 // frame instead (go two up to skip a row of frames).
5999 while (curfr != topframe && curfr->fr_next == NULL)
6000 {
6001 if (fr != topframe)
6002 fr = fr->fr_parent;
6003 curfr = fr;
6004 if (fr != topframe)
6005 fr = fr->fr_parent;
6006 }
6007
6008 if (offset < 0) // drag up
6009 {
6010 up = TRUE;
6011 offset = -offset;
6012 // sum up the room of the current frame and above it
6013 if (fr == curfr)
6014 {
6015 // only one window
6016 room = fr->fr_height - frame_minheight(fr, NULL);
6017 }
6018 else
6019 {
6020 room = 0;
6021 for (fr = fr->fr_child; ; fr = fr->fr_next)
6022 {
6023 room += fr->fr_height - frame_minheight(fr, NULL);
6024 if (fr == curfr)
6025 break;
6026 }
6027 }
6028 fr = curfr->fr_next; // put fr at frame that grows
6029 }
6030 else // drag down
6031 {
6032 up = FALSE;
6033 /*
6034 * Only dragging the last status line can reduce p_ch.
6035 */
6036 room = Rows - cmdline_row;
6037 if (curfr->fr_next == NULL)
6038 room -= 1;
6039 else
6040 room -= p_ch;
6041 if (room < 0)
6042 room = 0;
6043 // sum up the room of frames below of the current one
6044 FOR_ALL_FRAMES(fr, curfr->fr_next)
6045 room += fr->fr_height - frame_minheight(fr, NULL);
6046 fr = curfr; // put fr at window that grows
6047 }
6048
6049 if (room < offset) // Not enough room
6050 offset = room; // Move as far as we can
6051 if (offset <= 0)
6052 return;
6053
6054 /*
6055 * Grow frame fr by "offset" lines.
6056 * Doesn't happen when dragging the last status line up.
6057 */
6058 if (fr != NULL)
6059 frame_new_height(fr, fr->fr_height + offset, up, FALSE);
6060
6061 if (up)
6062 fr = curfr; // current frame gets smaller
6063 else
6064 fr = curfr->fr_next; // next frame gets smaller
6065
6066 /*
6067 * Now make the other frames smaller.
6068 */
6069 while (fr != NULL && offset > 0)
6070 {
6071 n = frame_minheight(fr, NULL);
6072 if (fr->fr_height - offset <= n)
6073 {
6074 offset -= fr->fr_height - n;
6075 frame_new_height(fr, n, !up, FALSE);
6076 }
6077 else
6078 {
6079 frame_new_height(fr, fr->fr_height - offset, !up, FALSE);
6080 break;
6081 }
6082 if (up)
6083 fr = fr->fr_prev;
6084 else
6085 fr = fr->fr_next;
6086 }
6087 row = win_comp_pos();
6088 screen_fill(row, cmdline_row, 0, (int)Columns, ' ', ' ', 0);
6089 cmdline_row = row;
6090 p_ch = Rows - cmdline_row;
6091 if (p_ch < 1)
6092 p_ch = 1;
6093 curtab->tp_ch_used = p_ch;
6094 redraw_all_later(SOME_VALID);
6095 showmode();
6096 }
6097
6098 /*
6099 * Separator line of dragwin is dragged "offset" lines right (negative is left).
6100 */
6101 void
win_drag_vsep_line(win_T * dragwin,int offset)6102 win_drag_vsep_line(win_T *dragwin, int offset)
6103 {
6104 frame_T *curfr;
6105 frame_T *fr;
6106 int room;
6107 int left; // if TRUE, drag separator line left, otherwise right
6108 int n;
6109
6110 fr = dragwin->w_frame;
6111 if (fr == topframe) // only one window (cannot happen?)
6112 return;
6113 curfr = fr;
6114 fr = fr->fr_parent;
6115 // When the parent frame is not a row of frames, its parent should be.
6116 if (fr->fr_layout != FR_ROW)
6117 {
6118 if (fr == topframe) // only a column of windows (cannot happen?)
6119 return;
6120 curfr = fr;
6121 fr = fr->fr_parent;
6122 }
6123
6124 // If this is the last frame in a row, may want to resize a parent
6125 // frame instead.
6126 while (curfr->fr_next == NULL)
6127 {
6128 if (fr == topframe)
6129 break;
6130 curfr = fr;
6131 fr = fr->fr_parent;
6132 if (fr != topframe)
6133 {
6134 curfr = fr;
6135 fr = fr->fr_parent;
6136 }
6137 }
6138
6139 if (offset < 0) // drag left
6140 {
6141 left = TRUE;
6142 offset = -offset;
6143 // sum up the room of the current frame and left of it
6144 room = 0;
6145 for (fr = fr->fr_child; ; fr = fr->fr_next)
6146 {
6147 room += fr->fr_width - frame_minwidth(fr, NULL);
6148 if (fr == curfr)
6149 break;
6150 }
6151 fr = curfr->fr_next; // put fr at frame that grows
6152 }
6153 else // drag right
6154 {
6155 left = FALSE;
6156 // sum up the room of frames right of the current one
6157 room = 0;
6158 FOR_ALL_FRAMES(fr, curfr->fr_next)
6159 room += fr->fr_width - frame_minwidth(fr, NULL);
6160 fr = curfr; // put fr at window that grows
6161 }
6162
6163 if (room < offset) // Not enough room
6164 offset = room; // Move as far as we can
6165 if (offset <= 0) // No room at all, quit.
6166 return;
6167 if (fr == NULL)
6168 return; // Safety check, should not happen.
6169
6170 // grow frame fr by offset lines
6171 frame_new_width(fr, fr->fr_width + offset, left, FALSE);
6172
6173 // shrink other frames: current and at the left or at the right
6174 if (left)
6175 fr = curfr; // current frame gets smaller
6176 else
6177 fr = curfr->fr_next; // next frame gets smaller
6178
6179 while (fr != NULL && offset > 0)
6180 {
6181 n = frame_minwidth(fr, NULL);
6182 if (fr->fr_width - offset <= n)
6183 {
6184 offset -= fr->fr_width - n;
6185 frame_new_width(fr, n, !left, FALSE);
6186 }
6187 else
6188 {
6189 frame_new_width(fr, fr->fr_width - offset, !left, FALSE);
6190 break;
6191 }
6192 if (left)
6193 fr = fr->fr_prev;
6194 else
6195 fr = fr->fr_next;
6196 }
6197 (void)win_comp_pos();
6198 redraw_all_later(NOT_VALID);
6199 }
6200
6201 #define FRACTION_MULT 16384L
6202
6203 /*
6204 * Set wp->w_fraction for the current w_wrow and w_height.
6205 * Has no effect when the window is less than two lines.
6206 */
6207 void
set_fraction(win_T * wp)6208 set_fraction(win_T *wp)
6209 {
6210 if (wp->w_height > 1)
6211 // When cursor is in the first line the percentage is computed as if
6212 // it's halfway that line. Thus with two lines it is 25%, with three
6213 // lines 17%, etc. Similarly for the last line: 75%, 83%, etc.
6214 wp->w_fraction = ((long)wp->w_wrow * FRACTION_MULT
6215 + FRACTION_MULT / 2) / (long)wp->w_height;
6216 }
6217
6218 /*
6219 * Set the height of a window.
6220 * "height" excludes any window toolbar.
6221 * This takes care of the things inside the window, not what happens to the
6222 * window position, the frame or to other windows.
6223 */
6224 void
win_new_height(win_T * wp,int height)6225 win_new_height(win_T *wp, int height)
6226 {
6227 int prev_height = wp->w_height;
6228
6229 // Don't want a negative height. Happens when splitting a tiny window.
6230 // Will equalize heights soon to fix it.
6231 if (height < 0)
6232 height = 0;
6233 if (wp->w_height == height)
6234 return; // nothing to do
6235
6236 if (wp->w_height > 0)
6237 {
6238 if (wp == curwin)
6239 // w_wrow needs to be valid. When setting 'laststatus' this may
6240 // call win_new_height() recursively.
6241 validate_cursor();
6242 if (wp->w_height != prev_height)
6243 return; // Recursive call already changed the size, bail out here
6244 // to avoid the following to mess things up.
6245 if (wp->w_wrow != wp->w_prev_fraction_row)
6246 set_fraction(wp);
6247 }
6248
6249 wp->w_height = height;
6250 wp->w_skipcol = 0;
6251
6252 // There is no point in adjusting the scroll position when exiting. Some
6253 // values might be invalid.
6254 if (!exiting)
6255 scroll_to_fraction(wp, prev_height);
6256 }
6257
6258 void
scroll_to_fraction(win_T * wp,int prev_height)6259 scroll_to_fraction(win_T *wp, int prev_height)
6260 {
6261 linenr_T lnum;
6262 int sline, line_size;
6263 int height = wp->w_height;
6264
6265 // Don't change w_topline in any of these cases:
6266 // - window height is 0
6267 // - 'scrollbind' is set and this isn't the current window
6268 // - window height is sufficient to display the whole buffer and first line
6269 // is visible.
6270 if (height > 0
6271 && (!wp->w_p_scb || wp == curwin)
6272 && (height < wp->w_buffer->b_ml.ml_line_count || wp->w_topline > 1))
6273 {
6274 /*
6275 * Find a value for w_topline that shows the cursor at the same
6276 * relative position in the window as before (more or less).
6277 */
6278 lnum = wp->w_cursor.lnum;
6279 if (lnum < 1) // can happen when starting up
6280 lnum = 1;
6281 wp->w_wrow = ((long)wp->w_fraction * (long)height - 1L)
6282 / FRACTION_MULT;
6283 line_size = plines_win_col(wp, lnum, (long)(wp->w_cursor.col)) - 1;
6284 sline = wp->w_wrow - line_size;
6285
6286 if (sline >= 0)
6287 {
6288 // Make sure the whole cursor line is visible, if possible.
6289 int rows = plines_win(wp, lnum, FALSE);
6290
6291 if (sline > wp->w_height - rows)
6292 {
6293 sline = wp->w_height - rows;
6294 wp->w_wrow -= rows - line_size;
6295 }
6296 }
6297
6298 if (sline < 0)
6299 {
6300 /*
6301 * Cursor line would go off top of screen if w_wrow was this high.
6302 * Make cursor line the first line in the window. If not enough
6303 * room use w_skipcol;
6304 */
6305 wp->w_wrow = line_size;
6306 if (wp->w_wrow >= wp->w_height
6307 && (wp->w_width - win_col_off(wp)) > 0)
6308 {
6309 wp->w_skipcol += wp->w_width - win_col_off(wp);
6310 --wp->w_wrow;
6311 while (wp->w_wrow >= wp->w_height)
6312 {
6313 wp->w_skipcol += wp->w_width - win_col_off(wp)
6314 + win_col_off2(wp);
6315 --wp->w_wrow;
6316 }
6317 }
6318 }
6319 else if (sline > 0)
6320 {
6321 while (sline > 0 && lnum > 1)
6322 {
6323 #ifdef FEAT_FOLDING
6324 hasFoldingWin(wp, lnum, &lnum, NULL, TRUE, NULL);
6325 if (lnum == 1)
6326 {
6327 // first line in buffer is folded
6328 line_size = 1;
6329 --sline;
6330 break;
6331 }
6332 #endif
6333 --lnum;
6334 #ifdef FEAT_DIFF
6335 if (lnum == wp->w_topline)
6336 line_size = plines_win_nofill(wp, lnum, TRUE)
6337 + wp->w_topfill;
6338 else
6339 #endif
6340 line_size = plines_win(wp, lnum, TRUE);
6341 sline -= line_size;
6342 }
6343
6344 if (sline < 0)
6345 {
6346 /*
6347 * Line we want at top would go off top of screen. Use next
6348 * line instead.
6349 */
6350 #ifdef FEAT_FOLDING
6351 hasFoldingWin(wp, lnum, NULL, &lnum, TRUE, NULL);
6352 #endif
6353 lnum++;
6354 wp->w_wrow -= line_size + sline;
6355 }
6356 else if (sline > 0)
6357 {
6358 // First line of file reached, use that as topline.
6359 lnum = 1;
6360 wp->w_wrow -= sline;
6361 }
6362 }
6363 set_topline(wp, lnum);
6364 }
6365
6366 if (wp == curwin)
6367 {
6368 if (get_scrolloff_value())
6369 update_topline();
6370 curs_columns(FALSE); // validate w_wrow
6371 }
6372 if (prev_height > 0)
6373 wp->w_prev_fraction_row = wp->w_wrow;
6374
6375 win_comp_scroll(wp);
6376 redraw_win_later(wp, SOME_VALID);
6377 wp->w_redr_status = TRUE;
6378 invalidate_botline_win(wp);
6379 }
6380
6381 /*
6382 * Set the width of a window.
6383 */
6384 void
win_new_width(win_T * wp,int width)6385 win_new_width(win_T *wp, int width)
6386 {
6387 wp->w_width = width;
6388 wp->w_lines_valid = 0;
6389 changed_line_abv_curs_win(wp);
6390 invalidate_botline_win(wp);
6391 if (wp == curwin)
6392 {
6393 update_topline();
6394 curs_columns(TRUE); // validate w_wrow
6395 }
6396 redraw_win_later(wp, NOT_VALID);
6397 wp->w_redr_status = TRUE;
6398 }
6399
6400 void
win_comp_scroll(win_T * wp)6401 win_comp_scroll(win_T *wp)
6402 {
6403 #if defined(FEAT_EVAL)
6404 int old_w_p_scr = wp->w_p_scr;
6405 #endif
6406
6407 wp->w_p_scr = ((unsigned)wp->w_height >> 1);
6408 if (wp->w_p_scr == 0)
6409 wp->w_p_scr = 1;
6410 #if defined(FEAT_EVAL)
6411 if (wp->w_p_scr != old_w_p_scr)
6412 {
6413 // Used by "verbose set scroll".
6414 wp->w_p_script_ctx[WV_SCROLL].sc_sid = SID_WINLAYOUT;
6415 wp->w_p_script_ctx[WV_SCROLL].sc_lnum = 0;
6416 }
6417 #endif
6418 }
6419
6420 /*
6421 * command_height: called whenever p_ch has been changed
6422 */
6423 void
command_height(void)6424 command_height(void)
6425 {
6426 int h;
6427 frame_T *frp;
6428 int old_p_ch = curtab->tp_ch_used;
6429
6430 // Use the value of p_ch that we remembered. This is needed for when the
6431 // GUI starts up, we can't be sure in what order things happen. And when
6432 // p_ch was changed in another tab page.
6433 curtab->tp_ch_used = p_ch;
6434
6435 // Find bottom frame with width of screen.
6436 frp = lastwin->w_frame;
6437 while (frp->fr_width != Columns && frp->fr_parent != NULL)
6438 frp = frp->fr_parent;
6439
6440 // Avoid changing the height of a window with 'winfixheight' set.
6441 while (frp->fr_prev != NULL && frp->fr_layout == FR_LEAF
6442 && frp->fr_win->w_p_wfh)
6443 frp = frp->fr_prev;
6444
6445 if (starting != NO_SCREEN)
6446 {
6447 cmdline_row = Rows - p_ch;
6448
6449 if (p_ch > old_p_ch) // p_ch got bigger
6450 {
6451 while (p_ch > old_p_ch)
6452 {
6453 if (frp == NULL)
6454 {
6455 emsg(_(e_not_enough_room));
6456 p_ch = old_p_ch;
6457 curtab->tp_ch_used = p_ch;
6458 cmdline_row = Rows - p_ch;
6459 break;
6460 }
6461 h = frp->fr_height - frame_minheight(frp, NULL);
6462 if (h > p_ch - old_p_ch)
6463 h = p_ch - old_p_ch;
6464 old_p_ch += h;
6465 frame_add_height(frp, -h);
6466 frp = frp->fr_prev;
6467 }
6468
6469 // Recompute window positions.
6470 (void)win_comp_pos();
6471
6472 // clear the lines added to cmdline
6473 if (full_screen)
6474 screen_fill((int)(cmdline_row), (int)Rows, 0,
6475 (int)Columns, ' ', ' ', 0);
6476 msg_row = cmdline_row;
6477 redraw_cmdline = TRUE;
6478 return;
6479 }
6480
6481 if (msg_row < cmdline_row)
6482 msg_row = cmdline_row;
6483 redraw_cmdline = TRUE;
6484 }
6485 frame_add_height(frp, (int)(old_p_ch - p_ch));
6486
6487 // Recompute window positions.
6488 if (frp != lastwin->w_frame)
6489 (void)win_comp_pos();
6490 }
6491
6492 /*
6493 * Resize frame "frp" to be "n" lines higher (negative for less high).
6494 * Also resize the frames it is contained in.
6495 */
6496 static void
frame_add_height(frame_T * frp,int n)6497 frame_add_height(frame_T *frp, int n)
6498 {
6499 frame_new_height(frp, frp->fr_height + n, FALSE, FALSE);
6500 for (;;)
6501 {
6502 frp = frp->fr_parent;
6503 if (frp == NULL)
6504 break;
6505 frp->fr_height += n;
6506 }
6507 }
6508
6509 /*
6510 * Add or remove a status line for the bottom window(s), according to the
6511 * value of 'laststatus'.
6512 */
6513 void
last_status(int morewin)6514 last_status(
6515 int morewin) // pretend there are two or more windows
6516 {
6517 // Don't make a difference between horizontal or vertical split.
6518 last_status_rec(topframe, (p_ls == 2
6519 || (p_ls == 1 && (morewin || !ONE_WINDOW))));
6520 }
6521
6522 static void
last_status_rec(frame_T * fr,int statusline)6523 last_status_rec(frame_T *fr, int statusline)
6524 {
6525 frame_T *fp;
6526 win_T *wp;
6527
6528 if (fr->fr_layout == FR_LEAF)
6529 {
6530 wp = fr->fr_win;
6531 if (wp->w_status_height != 0 && !statusline)
6532 {
6533 // remove status line
6534 win_new_height(wp, wp->w_height + 1);
6535 wp->w_status_height = 0;
6536 comp_col();
6537 }
6538 else if (wp->w_status_height == 0 && statusline)
6539 {
6540 // Find a frame to take a line from.
6541 fp = fr;
6542 while (fp->fr_height <= frame_minheight(fp, NULL))
6543 {
6544 if (fp == topframe)
6545 {
6546 emsg(_(e_not_enough_room));
6547 return;
6548 }
6549 // In a column of frames: go to frame above. If already at
6550 // the top or in a row of frames: go to parent.
6551 if (fp->fr_parent->fr_layout == FR_COL && fp->fr_prev != NULL)
6552 fp = fp->fr_prev;
6553 else
6554 fp = fp->fr_parent;
6555 }
6556 wp->w_status_height = 1;
6557 if (fp != fr)
6558 {
6559 frame_new_height(fp, fp->fr_height - 1, FALSE, FALSE);
6560 frame_fix_height(wp);
6561 (void)win_comp_pos();
6562 }
6563 else
6564 win_new_height(wp, wp->w_height - 1);
6565 comp_col();
6566 redraw_all_later(SOME_VALID);
6567 }
6568 }
6569 else if (fr->fr_layout == FR_ROW)
6570 {
6571 // vertically split windows, set status line for each one
6572 FOR_ALL_FRAMES(fp, fr->fr_child)
6573 last_status_rec(fp, statusline);
6574 }
6575 else
6576 {
6577 // horizontally split window, set status line for last one
6578 for (fp = fr->fr_child; fp->fr_next != NULL; fp = fp->fr_next)
6579 ;
6580 last_status_rec(fp, statusline);
6581 }
6582 }
6583
6584 /*
6585 * Return the number of lines used by the tab page line.
6586 */
6587 int
tabline_height(void)6588 tabline_height(void)
6589 {
6590 #ifdef FEAT_GUI_TABLINE
6591 // When the GUI has the tabline then this always returns zero.
6592 if (gui_use_tabline())
6593 return 0;
6594 #endif
6595 switch (p_stal)
6596 {
6597 case 0: return 0;
6598 case 1: return (first_tabpage->tp_next == NULL) ? 0 : 1;
6599 }
6600 return 1;
6601 }
6602
6603 /*
6604 * Return the minimal number of rows that is needed on the screen to display
6605 * the current number of windows.
6606 */
6607 int
min_rows(void)6608 min_rows(void)
6609 {
6610 int total;
6611 tabpage_T *tp;
6612 int n;
6613
6614 if (firstwin == NULL) // not initialized yet
6615 return MIN_LINES;
6616
6617 total = 0;
6618 FOR_ALL_TABPAGES(tp)
6619 {
6620 n = frame_minheight(tp->tp_topframe, NULL);
6621 if (total < n)
6622 total = n;
6623 }
6624 total += tabline_height();
6625 total += 1; // count the room for the command line
6626 return total;
6627 }
6628
6629 /*
6630 * Return TRUE if there is only one window and only one tab page, not
6631 * counting a help or preview window, unless it is the current window.
6632 * Does not count unlisted windows.
6633 */
6634 int
only_one_window(void)6635 only_one_window(void)
6636 {
6637 int count = 0;
6638 win_T *wp;
6639
6640 #if defined(FEAT_PROP_POPUP)
6641 // If the current window is a popup then there always is another window.
6642 if (popup_is_popup(curwin))
6643 return FALSE;
6644 #endif
6645
6646 // If there is another tab page there always is another window.
6647 if (first_tabpage->tp_next != NULL)
6648 return FALSE;
6649
6650 FOR_ALL_WINDOWS(wp)
6651 if (wp->w_buffer != NULL
6652 && (!((bt_help(wp->w_buffer) && !bt_help(curbuf))
6653 # ifdef FEAT_QUICKFIX
6654 || wp->w_p_pvw
6655 # endif
6656 ) || wp == curwin) && wp != aucmd_win)
6657 ++count;
6658 return (count <= 1);
6659 }
6660
6661 /*
6662 * Correct the cursor line number in other windows. Used after changing the
6663 * current buffer, and before applying autocommands.
6664 * When "do_curwin" is TRUE, also check current window.
6665 */
6666 void
check_lnums(int do_curwin)6667 check_lnums(int do_curwin)
6668 {
6669 win_T *wp;
6670 tabpage_T *tp;
6671
6672 FOR_ALL_TAB_WINDOWS(tp, wp)
6673 if ((do_curwin || wp != curwin) && wp->w_buffer == curbuf)
6674 {
6675 // save the original cursor position and topline
6676 wp->w_save_cursor.w_cursor_save = wp->w_cursor;
6677 wp->w_save_cursor.w_topline_save = wp->w_topline;
6678
6679 if (wp->w_cursor.lnum > curbuf->b_ml.ml_line_count)
6680 wp->w_cursor.lnum = curbuf->b_ml.ml_line_count;
6681 if (wp->w_topline > curbuf->b_ml.ml_line_count)
6682 wp->w_topline = curbuf->b_ml.ml_line_count;
6683
6684 // save the corrected cursor position and topline
6685 wp->w_save_cursor.w_cursor_corr = wp->w_cursor;
6686 wp->w_save_cursor.w_topline_corr = wp->w_topline;
6687 }
6688 }
6689
6690 /*
6691 * Reset cursor and topline to its stored values from check_lnums().
6692 * check_lnums() must have been called first!
6693 */
6694 void
reset_lnums()6695 reset_lnums()
6696 {
6697 win_T *wp;
6698 tabpage_T *tp;
6699
6700 FOR_ALL_TAB_WINDOWS(tp, wp)
6701 if (wp->w_buffer == curbuf)
6702 {
6703 // Restore the value if the autocommand didn't change it.
6704 if (EQUAL_POS(wp->w_save_cursor.w_cursor_corr, wp->w_cursor))
6705 wp->w_cursor = wp->w_save_cursor.w_cursor_save;
6706 if (wp->w_save_cursor.w_topline_corr == wp->w_topline)
6707 wp->w_topline = wp->w_save_cursor.w_topline_save;
6708 }
6709 }
6710
6711 /*
6712 * A snapshot of the window sizes, to restore them after closing the help
6713 * window.
6714 * Only these fields are used:
6715 * fr_layout
6716 * fr_width
6717 * fr_height
6718 * fr_next
6719 * fr_child
6720 * fr_win (only valid for the old curwin, NULL otherwise)
6721 */
6722
6723 /*
6724 * Create a snapshot of the current frame sizes.
6725 */
6726 void
make_snapshot(int idx)6727 make_snapshot(int idx)
6728 {
6729 clear_snapshot(curtab, idx);
6730 make_snapshot_rec(topframe, &curtab->tp_snapshot[idx]);
6731 }
6732
6733 static void
make_snapshot_rec(frame_T * fr,frame_T ** frp)6734 make_snapshot_rec(frame_T *fr, frame_T **frp)
6735 {
6736 *frp = ALLOC_CLEAR_ONE(frame_T);
6737 if (*frp == NULL)
6738 return;
6739 (*frp)->fr_layout = fr->fr_layout;
6740 (*frp)->fr_width = fr->fr_width;
6741 (*frp)->fr_height = fr->fr_height;
6742 if (fr->fr_next != NULL)
6743 make_snapshot_rec(fr->fr_next, &((*frp)->fr_next));
6744 if (fr->fr_child != NULL)
6745 make_snapshot_rec(fr->fr_child, &((*frp)->fr_child));
6746 if (fr->fr_layout == FR_LEAF && fr->fr_win == curwin)
6747 (*frp)->fr_win = curwin;
6748 }
6749
6750 /*
6751 * Remove any existing snapshot.
6752 */
6753 static void
clear_snapshot(tabpage_T * tp,int idx)6754 clear_snapshot(tabpage_T *tp, int idx)
6755 {
6756 clear_snapshot_rec(tp->tp_snapshot[idx]);
6757 tp->tp_snapshot[idx] = NULL;
6758 }
6759
6760 static void
clear_snapshot_rec(frame_T * fr)6761 clear_snapshot_rec(frame_T *fr)
6762 {
6763 if (fr != NULL)
6764 {
6765 clear_snapshot_rec(fr->fr_next);
6766 clear_snapshot_rec(fr->fr_child);
6767 vim_free(fr);
6768 }
6769 }
6770
6771 /*
6772 * Restore a previously created snapshot, if there is any.
6773 * This is only done if the screen size didn't change and the window layout is
6774 * still the same.
6775 */
6776 void
restore_snapshot(int idx,int close_curwin)6777 restore_snapshot(
6778 int idx,
6779 int close_curwin) // closing current window
6780 {
6781 win_T *wp;
6782
6783 if (curtab->tp_snapshot[idx] != NULL
6784 && curtab->tp_snapshot[idx]->fr_width == topframe->fr_width
6785 && curtab->tp_snapshot[idx]->fr_height == topframe->fr_height
6786 && check_snapshot_rec(curtab->tp_snapshot[idx], topframe) == OK)
6787 {
6788 wp = restore_snapshot_rec(curtab->tp_snapshot[idx], topframe);
6789 win_comp_pos();
6790 if (wp != NULL && close_curwin)
6791 win_goto(wp);
6792 redraw_all_later(NOT_VALID);
6793 }
6794 clear_snapshot(curtab, idx);
6795 }
6796
6797 /*
6798 * Check if frames "sn" and "fr" have the same layout, same following frames
6799 * and same children. And the window pointer is valid.
6800 */
6801 static int
check_snapshot_rec(frame_T * sn,frame_T * fr)6802 check_snapshot_rec(frame_T *sn, frame_T *fr)
6803 {
6804 if (sn->fr_layout != fr->fr_layout
6805 || (sn->fr_next == NULL) != (fr->fr_next == NULL)
6806 || (sn->fr_child == NULL) != (fr->fr_child == NULL)
6807 || (sn->fr_next != NULL
6808 && check_snapshot_rec(sn->fr_next, fr->fr_next) == FAIL)
6809 || (sn->fr_child != NULL
6810 && check_snapshot_rec(sn->fr_child, fr->fr_child) == FAIL)
6811 || (sn->fr_win != NULL && !win_valid(sn->fr_win)))
6812 return FAIL;
6813 return OK;
6814 }
6815
6816 /*
6817 * Copy the size of snapshot frame "sn" to frame "fr". Do the same for all
6818 * following frames and children.
6819 * Returns a pointer to the old current window, or NULL.
6820 */
6821 static win_T *
restore_snapshot_rec(frame_T * sn,frame_T * fr)6822 restore_snapshot_rec(frame_T *sn, frame_T *fr)
6823 {
6824 win_T *wp = NULL;
6825 win_T *wp2;
6826
6827 fr->fr_height = sn->fr_height;
6828 fr->fr_width = sn->fr_width;
6829 if (fr->fr_layout == FR_LEAF)
6830 {
6831 frame_new_height(fr, fr->fr_height, FALSE, FALSE);
6832 frame_new_width(fr, fr->fr_width, FALSE, FALSE);
6833 wp = sn->fr_win;
6834 }
6835 if (sn->fr_next != NULL)
6836 {
6837 wp2 = restore_snapshot_rec(sn->fr_next, fr->fr_next);
6838 if (wp2 != NULL)
6839 wp = wp2;
6840 }
6841 if (sn->fr_child != NULL)
6842 {
6843 wp2 = restore_snapshot_rec(sn->fr_child, fr->fr_child);
6844 if (wp2 != NULL)
6845 wp = wp2;
6846 }
6847 return wp;
6848 }
6849
6850 #if defined(FEAT_GUI) || defined(PROTO)
6851 /*
6852 * Return TRUE if there is any vertically split window.
6853 */
6854 int
win_hasvertsplit(void)6855 win_hasvertsplit(void)
6856 {
6857 frame_T *fr;
6858
6859 if (topframe->fr_layout == FR_ROW)
6860 return TRUE;
6861
6862 if (topframe->fr_layout == FR_COL)
6863 FOR_ALL_FRAMES(fr, topframe->fr_child)
6864 if (fr->fr_layout == FR_ROW)
6865 return TRUE;
6866
6867 return FALSE;
6868 }
6869 #endif
6870
6871 #if defined(FEAT_PYTHON) || defined(FEAT_PYTHON3) || defined(PROTO)
6872 int
get_win_number(win_T * wp,win_T * first_win)6873 get_win_number(win_T *wp, win_T *first_win)
6874 {
6875 int i = 1;
6876 win_T *w;
6877
6878 for (w = first_win; w != NULL && w != wp; w = W_NEXT(w))
6879 ++i;
6880
6881 if (w == NULL)
6882 return 0;
6883 else
6884 return i;
6885 }
6886
6887 int
get_tab_number(tabpage_T * tp UNUSED)6888 get_tab_number(tabpage_T *tp UNUSED)
6889 {
6890 int i = 1;
6891 tabpage_T *t;
6892
6893 for (t = first_tabpage; t != NULL && t != tp; t = t->tp_next)
6894 ++i;
6895
6896 if (t == NULL)
6897 return 0;
6898 else
6899 return i;
6900 }
6901 #endif
6902
6903 /*
6904 * Return TRUE if "topfrp" and its children are at the right height.
6905 */
6906 static int
frame_check_height(frame_T * topfrp,int height)6907 frame_check_height(frame_T *topfrp, int height)
6908 {
6909 frame_T *frp;
6910
6911 if (topfrp->fr_height != height)
6912 return FALSE;
6913
6914 if (topfrp->fr_layout == FR_ROW)
6915 FOR_ALL_FRAMES(frp, topfrp->fr_child)
6916 if (frp->fr_height != height)
6917 return FALSE;
6918
6919 return TRUE;
6920 }
6921
6922 /*
6923 * Return TRUE if "topfrp" and its children are at the right width.
6924 */
6925 static int
frame_check_width(frame_T * topfrp,int width)6926 frame_check_width(frame_T *topfrp, int width)
6927 {
6928 frame_T *frp;
6929
6930 if (topfrp->fr_width != width)
6931 return FALSE;
6932
6933 if (topfrp->fr_layout == FR_COL)
6934 FOR_ALL_FRAMES(frp, topfrp->fr_child)
6935 if (frp->fr_width != width)
6936 return FALSE;
6937
6938 return TRUE;
6939 }
6940
6941 #if defined(FEAT_SYN_HL) || defined(PROTO)
6942 /*
6943 * Simple int comparison function for use with qsort()
6944 */
6945 static int
int_cmp(const void * a,const void * b)6946 int_cmp(const void *a, const void *b)
6947 {
6948 return *(const int *)a - *(const int *)b;
6949 }
6950
6951 /*
6952 * Handle setting 'colorcolumn' or 'textwidth' in window "wp".
6953 * Returns error message, NULL if it's OK.
6954 */
6955 char *
check_colorcolumn(win_T * wp)6956 check_colorcolumn(win_T *wp)
6957 {
6958 char_u *s;
6959 int col;
6960 int count = 0;
6961 int color_cols[256];
6962 int i;
6963 int j = 0;
6964
6965 if (wp->w_buffer == NULL)
6966 return NULL; // buffer was closed
6967
6968 for (s = wp->w_p_cc; *s != NUL && count < 255;)
6969 {
6970 if (*s == '-' || *s == '+')
6971 {
6972 // -N and +N: add to 'textwidth'
6973 col = (*s == '-') ? -1 : 1;
6974 ++s;
6975 if (!VIM_ISDIGIT(*s))
6976 return e_invarg;
6977 col = col * getdigits(&s);
6978 if (wp->w_buffer->b_p_tw == 0)
6979 goto skip; // 'textwidth' not set, skip this item
6980 col += wp->w_buffer->b_p_tw;
6981 if (col < 0)
6982 goto skip;
6983 }
6984 else if (VIM_ISDIGIT(*s))
6985 col = getdigits(&s);
6986 else
6987 return e_invarg;
6988 color_cols[count++] = col - 1; // 1-based to 0-based
6989 skip:
6990 if (*s == NUL)
6991 break;
6992 if (*s != ',')
6993 return e_invarg;
6994 if (*++s == NUL)
6995 return e_invarg; // illegal trailing comma as in "set cc=80,"
6996 }
6997
6998 vim_free(wp->w_p_cc_cols);
6999 if (count == 0)
7000 wp->w_p_cc_cols = NULL;
7001 else
7002 {
7003 wp->w_p_cc_cols = ALLOC_MULT(int, count + 1);
7004 if (wp->w_p_cc_cols != NULL)
7005 {
7006 // sort the columns for faster usage on screen redraw inside
7007 // win_line()
7008 qsort(color_cols, count, sizeof(int), int_cmp);
7009
7010 for (i = 0; i < count; ++i)
7011 // skip duplicates
7012 if (j == 0 || wp->w_p_cc_cols[j - 1] != color_cols[i])
7013 wp->w_p_cc_cols[j++] = color_cols[i];
7014 wp->w_p_cc_cols[j] = -1; // end marker
7015 }
7016 }
7017
7018 return NULL; // no error
7019 }
7020 #endif
7021