Annotation of src/usr.bin/vim/window.c, Revision 1.1
1.1 ! downsj 1: /* $OpenBSD$ */
! 2: /* vi:set ts=4 sw=4:
! 3: *
! 4: * VIM - Vi IMproved by Bram Moolenaar
! 5: *
! 6: * Do ":help uganda" in Vim to read a list of people who contributed.
! 7: * Do ":help credits" in Vim to see a list of people who contributed.
! 8: */
! 9:
! 10: #include "vim.h"
! 11: #include "globals.h"
! 12: #include "proto.h"
! 13: #include "option.h"
! 14:
! 15: static void reset_VIsual __ARGS((void));
! 16: static int win_comp_pos __ARGS((void));
! 17: static void win_exchange __ARGS((long));
! 18: static void win_rotate __ARGS((int, int));
! 19: static void win_append __ARGS((WIN *, WIN *));
! 20: static void win_remove __ARGS((WIN *));
! 21: static void win_new_height __ARGS((WIN *, int));
! 22:
! 23: static WIN *prevwin = NULL; /* previous window */
! 24:
! 25: /*
! 26: * all CTRL-W window commands are handled here, called from normal().
! 27: */
! 28: void
! 29: do_window(nchar, Prenum)
! 30: int nchar;
! 31: long Prenum;
! 32: {
! 33: long Prenum1;
! 34: WIN *wp;
! 35: char_u *ptr;
! 36: int len;
! 37: int type = -1;
! 38: WIN *wp2;
! 39:
! 40: if (Prenum == 0)
! 41: Prenum1 = 1;
! 42: else
! 43: Prenum1 = Prenum;
! 44:
! 45: switch (nchar)
! 46: {
! 47: /* split current window in two parts */
! 48: case 'S':
! 49: case Ctrl('S'):
! 50: case 's': reset_VIsual(); /* stop Visual mode */
! 51: win_split((int)Prenum, TRUE);
! 52: break;
! 53:
! 54: /* split current window and edit alternate file */
! 55: case K_CCIRCM:
! 56: case '^':
! 57: reset_VIsual(); /* stop Visual mode */
! 58: stuffReadbuff((char_u *)":split #");
! 59: if (Prenum)
! 60: stuffnumReadbuff(Prenum); /* buffer number */
! 61: stuffcharReadbuff('\n');
! 62: break;
! 63:
! 64: /* open new window */
! 65: case Ctrl('N'):
! 66: case 'n': reset_VIsual(); /* stop Visual mode */
! 67: stuffcharReadbuff(':');
! 68: if (Prenum)
! 69: stuffnumReadbuff(Prenum); /* window height */
! 70: stuffReadbuff((char_u *)"new\n"); /* it is cmdline.c */
! 71: break;
! 72:
! 73: /* quit current window */
! 74: case Ctrl('Q'):
! 75: case 'q': reset_VIsual(); /* stop Visual mode */
! 76: stuffReadbuff((char_u *)":quit\n"); /* it is cmdline.c */
! 77: break;
! 78:
! 79: /* close current window */
! 80: case Ctrl('C'):
! 81: case 'c': reset_VIsual(); /* stop Visual mode */
! 82: stuffReadbuff((char_u *)":close\n"); /* it is cmdline.c */
! 83: break;
! 84:
! 85: /* close all but current window */
! 86: case Ctrl('O'):
! 87: case 'o': reset_VIsual(); /* stop Visual mode */
! 88: stuffReadbuff((char_u *)":only\n"); /* it is cmdline.c */
! 89: break;
! 90:
! 91: /* cursor to next window */
! 92: case 'j':
! 93: case K_DOWN:
! 94: case Ctrl('J'):
! 95: for (wp = curwin; wp->w_next != NULL && Prenum1-- > 0;
! 96: wp = wp->w_next)
! 97: ;
! 98: new_win:
! 99: /*
! 100: * When jumping to another buffer, stop visual mode
! 101: * Do this before changing windows so we can yank the
! 102: * selection into the '"*' register.
! 103: */
! 104: if (wp->w_buffer != curbuf && VIsual_active)
! 105: {
! 106: end_visual_mode();
! 107: for (wp2 = firstwin; wp2 != NULL; wp2 = wp2->w_next)
! 108: if (wp2->w_buffer == curbuf &&
! 109: wp2->w_redr_type < NOT_VALID)
! 110: {
! 111: wp2->w_redr_type = NOT_VALID;
! 112: redraw_later(NOT_VALID);
! 113: }
! 114: }
! 115: win_enter(wp, TRUE);
! 116: cursupdate();
! 117: break;
! 118:
! 119: /* cursor to next window with wrap around */
! 120: case Ctrl('W'):
! 121: case 'w':
! 122: /* cursor to previous window with wrap around */
! 123: case 'W':
! 124: if (lastwin == firstwin) /* just one window */
! 125: beep_flush();
! 126: else
! 127: {
! 128: if (Prenum) /* go to specified window */
! 129: {
! 130: for (wp = firstwin; --Prenum > 0; )
! 131: {
! 132: if (wp->w_next == NULL)
! 133: break;
! 134: else
! 135: wp = wp->w_next;
! 136: }
! 137: }
! 138: else
! 139: {
! 140: if (nchar == 'W') /* go to previous window */
! 141: {
! 142: wp = curwin->w_prev;
! 143: if (wp == NULL)
! 144: wp = lastwin; /* wrap around */
! 145: }
! 146: else /* go to next window */
! 147: {
! 148: wp = curwin->w_next;
! 149: if (wp == NULL)
! 150: wp = firstwin; /* wrap around */
! 151: }
! 152: }
! 153: goto new_win;
! 154: }
! 155: break;
! 156:
! 157: /* cursor to window above */
! 158: case 'k':
! 159: case K_UP:
! 160: case Ctrl('K'):
! 161: for (wp = curwin; wp->w_prev != NULL && Prenum1-- > 0;
! 162: wp = wp->w_prev)
! 163: ;
! 164: goto new_win;
! 165:
! 166: /* cursor to top window */
! 167: case 't':
! 168: case Ctrl('T'):
! 169: wp = firstwin;
! 170: goto new_win;
! 171:
! 172: /* cursor to bottom window */
! 173: case 'b':
! 174: case Ctrl('B'):
! 175: wp = lastwin;
! 176: goto new_win;
! 177:
! 178: /* cursor to last accessed (previous) window */
! 179: case 'p':
! 180: case Ctrl('P'):
! 181: if (prevwin == NULL)
! 182: beep_flush();
! 183: else
! 184: {
! 185: wp = prevwin;
! 186: goto new_win;
! 187: }
! 188: break;
! 189:
! 190: /* exchange current and next window */
! 191: case 'x':
! 192: case Ctrl('X'):
! 193: win_exchange(Prenum);
! 194: break;
! 195:
! 196: /* rotate windows downwards */
! 197: case Ctrl('R'):
! 198: case 'r': reset_VIsual(); /* stop Visual mode */
! 199: win_rotate(FALSE, (int)Prenum1); /* downwards */
! 200: break;
! 201:
! 202: /* rotate windows upwards */
! 203: case 'R': reset_VIsual(); /* stop Visual mode */
! 204: win_rotate(TRUE, (int)Prenum1); /* upwards */
! 205: break;
! 206:
! 207: /* make all windows the same height */
! 208: case '=': win_equal(NULL, TRUE);
! 209: break;
! 210:
! 211: /* increase current window height */
! 212: case '+': win_setheight(curwin->w_height + (int)Prenum1);
! 213: break;
! 214:
! 215: /* decrease current window height */
! 216: case '-': win_setheight(curwin->w_height - (int)Prenum1);
! 217: break;
! 218:
! 219: /* set current window height */
! 220: case Ctrl('_'):
! 221: case '_': win_setheight(Prenum ? (int)Prenum : 9999);
! 222: break;
! 223:
! 224: /* jump to tag and split window if tag exists */
! 225: case ']':
! 226: case Ctrl(']'):
! 227: reset_VIsual(); /* stop Visual mode */
! 228: postponed_split = TRUE;
! 229: stuffcharReadbuff(Ctrl(']'));
! 230: break;
! 231:
! 232: /* edit file name under cursor in a new window */
! 233: case 'f':
! 234: case Ctrl('F'):
! 235: reset_VIsual(); /* stop Visual mode */
! 236: ptr = file_name_at_cursor(FNAME_MESS|FNAME_HYP|FNAME_EXP);
! 237: if (ptr != NULL)
! 238: {
! 239: setpcmark();
! 240: if (win_split(0, FALSE) == OK)
! 241: (void)do_ecmd(0, ptr, NULL, NULL, p_hid, (linenr_t)0, FALSE);
! 242: vim_free(ptr);
! 243: }
! 244: break;
! 245:
! 246: /* Go to the first occurence of the identifier under cursor along path in a
! 247: * new window -- webb
! 248: */
! 249: case 'i': /* Go to any match */
! 250: case Ctrl('I'):
! 251: type = FIND_ANY;
! 252: /* FALLTHROUGH */
! 253: case 'd': /* Go to definition, using p_def */
! 254: case Ctrl('D'):
! 255: if (type == -1)
! 256: type = FIND_DEFINE;
! 257:
! 258: if ((len = find_ident_under_cursor(&ptr, FIND_IDENT)) == 0)
! 259: break;
! 260: find_pattern_in_path(ptr, len, TRUE, TRUE, type,
! 261: Prenum1, ACTION_SPLIT, (linenr_t)1, (linenr_t)MAXLNUM);
! 262: curwin->w_set_curswant = TRUE;
! 263: break;
! 264:
! 265: default: beep_flush();
! 266: break;
! 267: }
! 268: }
! 269:
! 270: static void
! 271: reset_VIsual()
! 272: {
! 273: if (VIsual_active)
! 274: {
! 275: end_visual_mode();
! 276: update_curbuf(NOT_VALID); /* delete the inversion */
! 277: }
! 278: }
! 279:
! 280: /*
! 281: * split the current window, implements CTRL-W s and :split
! 282: *
! 283: * new_height is the height for the new window, 0 to make half of current
! 284: * height redraw is TRUE when redraw now
! 285: *
! 286: * return FAIL for failure, OK otherwise
! 287: */
! 288: int
! 289: win_split(new_height, redraw)
! 290: int new_height;
! 291: int redraw;
! 292: {
! 293: WIN *wp;
! 294: linenr_t lnum;
! 295: int h;
! 296: int i;
! 297: int need_status;
! 298: int do_equal = (p_ea && new_height == 0);
! 299: int needed;
! 300: int available;
! 301: int curwin_height;
! 302:
! 303: /* add a status line when p_ls == 1 and splitting the first window */
! 304: if (lastwin == firstwin && p_ls == 1 && curwin->w_status_height == 0)
! 305: need_status = STATUS_HEIGHT;
! 306: else
! 307: need_status = 0;
! 308:
! 309: /*
! 310: * check if we are able to split the current window and compute its height
! 311: */
! 312: available = curwin->w_height;
! 313: needed = 2 * MIN_ROWS + STATUS_HEIGHT + need_status;
! 314: if (p_ea)
! 315: {
! 316: for (wp = firstwin; wp != NULL; wp = wp->w_next)
! 317: if (wp != curwin)
! 318: {
! 319: available += wp->w_height;
! 320: needed += MIN_ROWS;
! 321: }
! 322: }
! 323: if (available < needed)
! 324: {
! 325: EMSG(e_noroom);
! 326: return FAIL;
! 327: }
! 328: curwin_height = curwin->w_height;
! 329: if (need_status)
! 330: {
! 331: curwin->w_status_height = STATUS_HEIGHT;
! 332: curwin_height -= STATUS_HEIGHT;
! 333: }
! 334: if (new_height == 0)
! 335: new_height = curwin_height / 2;
! 336:
! 337: if (new_height > curwin_height - MIN_ROWS - STATUS_HEIGHT)
! 338: new_height = curwin_height - MIN_ROWS - STATUS_HEIGHT;
! 339:
! 340: if (new_height < MIN_ROWS)
! 341: new_height = MIN_ROWS;
! 342:
! 343: /* if it doesn't fit in the current window, need win_equal() */
! 344: if (curwin_height - new_height - STATUS_HEIGHT < MIN_ROWS)
! 345: do_equal = TRUE;
! 346: /*
! 347: * allocate new window structure and link it in the window list
! 348: */
! 349: if (p_sb) /* new window below current one */
! 350: wp = win_alloc(curwin);
! 351: else
! 352: wp = win_alloc(curwin->w_prev);
! 353: if (wp == NULL)
! 354: return FAIL;
! 355: /*
! 356: * compute the new screen positions
! 357: */
! 358: win_new_height(wp, new_height);
! 359: win_new_height(curwin, curwin_height - (new_height + STATUS_HEIGHT));
! 360: if (p_sb) /* new window below current one */
! 361: {
! 362: wp->w_winpos = curwin->w_winpos + curwin->w_height + STATUS_HEIGHT;
! 363: wp->w_status_height = curwin->w_status_height;
! 364: curwin->w_status_height = STATUS_HEIGHT;
! 365: }
! 366: else /* new window above current one */
! 367: {
! 368: wp->w_winpos = curwin->w_winpos;
! 369: wp->w_status_height = STATUS_HEIGHT;
! 370: curwin->w_winpos = wp->w_winpos + wp->w_height + STATUS_HEIGHT;
! 371: }
! 372: /*
! 373: * make the contents of the new window the same as the current one
! 374: */
! 375: wp->w_buffer = curbuf;
! 376: curbuf->b_nwindows++;
! 377: wp->w_cursor = curwin->w_cursor;
! 378: wp->w_row = curwin->w_row;
! 379: wp->w_col = curwin->w_col;
! 380: wp->w_virtcol = curwin->w_virtcol;
! 381: wp->w_curswant = curwin->w_curswant;
! 382: wp->w_set_curswant = curwin->w_set_curswant;
! 383: wp->w_empty_rows = curwin->w_empty_rows;
! 384: wp->w_leftcol = curwin->w_leftcol;
! 385: wp->w_pcmark = curwin->w_pcmark;
! 386: wp->w_prev_pcmark = curwin->w_prev_pcmark;
! 387: wp->w_alt_fnum = curwin->w_alt_fnum;
! 388:
! 389: wp->w_arg_idx = curwin->w_arg_idx;
! 390: /*
! 391: * copy tagstack and options from existing window
! 392: */
! 393: for (i = 0; i < curwin->w_tagstacklen; i++)
! 394: {
! 395: wp->w_tagstack[i].fmark = curwin->w_tagstack[i].fmark;
! 396: wp->w_tagstack[i].tagname = strsave(curwin->w_tagstack[i].tagname);
! 397: }
! 398: wp->w_tagstackidx = curwin->w_tagstackidx;
! 399: wp->w_tagstacklen = curwin->w_tagstacklen;
! 400: win_copy_options(curwin, wp);
! 401: /*
! 402: * Both windows need redrawing
! 403: */
! 404: wp->w_redr_type = NOT_VALID;
! 405: wp->w_redr_status = TRUE;
! 406: curwin->w_redr_type = NOT_VALID;
! 407: curwin->w_redr_status = TRUE;
! 408: /*
! 409: * Cursor is put in middle of window in both windows
! 410: */
! 411: if (wp->w_height < curwin->w_height) /* use smallest of two heights */
! 412: h = wp->w_height;
! 413: else
! 414: h = curwin->w_height;
! 415: h >>= 1;
! 416: for (lnum = wp->w_cursor.lnum; lnum > 1; --lnum)
! 417: {
! 418: h -= plines(lnum);
! 419: if (h <= 0)
! 420: break;
! 421: }
! 422: wp->w_topline = lnum;
! 423: curwin->w_topline = lnum;
! 424: if (need_status)
! 425: {
! 426: msg_pos((int)Rows - 1, sc_col);
! 427: msg_clr_eos(); /* Old command/ruler may still be there -- webb */
! 428: comp_col();
! 429: msg_pos((int)Rows - 1, 0); /* put position back at start of line */
! 430: }
! 431: /*
! 432: * make the new window the current window and redraw
! 433: */
! 434: if (do_equal)
! 435: win_equal(wp, FALSE);
! 436: win_enter(wp, FALSE);
! 437:
! 438: if (redraw)
! 439: updateScreen(NOT_VALID);
! 440:
! 441: return OK;
! 442: }
! 443:
! 444: /*
! 445: * Return the number of windows.
! 446: */
! 447: int
! 448: win_count()
! 449: {
! 450: WIN *wp;
! 451: int count = 0;
! 452:
! 453: for (wp = firstwin; wp != NULL; wp = wp->w_next)
! 454: ++count;
! 455: return count;
! 456: }
! 457:
! 458: /*
! 459: * Make 'count' windows on the screen.
! 460: * Return actual number of windows on the screen.
! 461: * Must be called when there is just one window, filling the whole screen
! 462: * (excluding the command line).
! 463: */
! 464: int
! 465: make_windows(count)
! 466: int count;
! 467: {
! 468: int maxcount;
! 469: int todo;
! 470: int p_sb_save;
! 471:
! 472: /*
! 473: * Each window needs at least MIN_ROWS lines and a status line.
! 474: * Add 4 lines for one window, otherwise we may end up with all one-line
! 475: * windows. Use value of 'winheight' if it is set
! 476: */
! 477: maxcount = (curwin->w_height + curwin->w_status_height -
! 478: (p_wh ? (p_wh - 1) : 4)) / (MIN_ROWS + STATUS_HEIGHT);
! 479: if (maxcount < 2)
! 480: maxcount = 2;
! 481: if (count > maxcount)
! 482: count = maxcount;
! 483:
! 484: /*
! 485: * add status line now, otherwise first window will be too big
! 486: */
! 487: if ((p_ls == 2 || (count > 1 && p_ls == 1)) && curwin->w_status_height == 0)
! 488: {
! 489: curwin->w_status_height = STATUS_HEIGHT;
! 490: win_new_height(curwin, curwin->w_height - STATUS_HEIGHT);
! 491: }
! 492:
! 493: /*
! 494: * set 'splitbelow' off for a moment, don't want that now
! 495: */
! 496: p_sb_save = p_sb;
! 497: p_sb = FALSE;
! 498: /* todo is number of windows left to create */
! 499: for (todo = count - 1; todo > 0; --todo)
! 500: if (win_split(curwin->w_height - (curwin->w_height - todo
! 501: * STATUS_HEIGHT) / (todo + 1) - STATUS_HEIGHT, FALSE) == FAIL)
! 502: break;
! 503: p_sb = p_sb_save;
! 504:
! 505: /* return actual number of windows */
! 506: return (count - todo);
! 507: }
! 508:
! 509: /*
! 510: * Exchange current and next window
! 511: */
! 512: static void
! 513: win_exchange(Prenum)
! 514: long Prenum;
! 515: {
! 516: WIN *wp;
! 517: WIN *wp2;
! 518: int temp;
! 519:
! 520: if (lastwin == firstwin) /* just one window */
! 521: {
! 522: beep_flush();
! 523: return;
! 524: }
! 525:
! 526: /*
! 527: * find window to exchange with
! 528: */
! 529: if (Prenum)
! 530: {
! 531: wp = firstwin;
! 532: while (wp != NULL && --Prenum > 0)
! 533: wp = wp->w_next;
! 534: }
! 535: else if (curwin->w_next != NULL) /* Swap with next */
! 536: wp = curwin->w_next;
! 537: else /* Swap last window with previous */
! 538: wp = curwin->w_prev;
! 539:
! 540: if (wp == curwin || wp == NULL)
! 541: return;
! 542:
! 543: /*
! 544: * 1. remove curwin from the list. Remember after which window it was in wp2
! 545: * 2. insert curwin before wp in the list
! 546: * if wp != wp2
! 547: * 3. remove wp from the list
! 548: * 4. insert wp after wp2
! 549: * 5. exchange the status line height
! 550: */
! 551: wp2 = curwin->w_prev;
! 552: win_remove(curwin);
! 553: win_append(wp->w_prev, curwin);
! 554: if (wp != wp2)
! 555: {
! 556: win_remove(wp);
! 557: win_append(wp2, wp);
! 558: }
! 559: temp = curwin->w_status_height;
! 560: curwin->w_status_height = wp->w_status_height;
! 561: wp->w_status_height = temp;
! 562:
! 563: win_comp_pos(); /* recompute window positions */
! 564:
! 565: win_enter(wp, TRUE);
! 566: cursupdate();
! 567: updateScreen(CLEAR);
! 568:
! 569: #ifdef USE_GUI
! 570: if (gui.in_use)
! 571: {
! 572: if (gui.which_scrollbars[SB_LEFT])
! 573: gui_mch_reorder_scrollbars(SB_LEFT);
! 574: if (gui.which_scrollbars[SB_RIGHT])
! 575: gui_mch_reorder_scrollbars(SB_RIGHT);
! 576: }
! 577: #endif
! 578: }
! 579:
! 580: /*
! 581: * rotate windows: if upwards TRUE the second window becomes the first one
! 582: * if upwards FALSE the first window becomes the second one
! 583: */
! 584: static void
! 585: win_rotate(upwards, count)
! 586: int upwards;
! 587: int count;
! 588: {
! 589: WIN *wp;
! 590: int height;
! 591:
! 592: if (firstwin == lastwin) /* nothing to do */
! 593: {
! 594: beep_flush();
! 595: return;
! 596: }
! 597: while (count--)
! 598: {
! 599: if (upwards) /* first window becomes last window */
! 600: {
! 601: wp = firstwin;
! 602: win_remove(wp);
! 603: win_append(lastwin, wp);
! 604: wp = lastwin->w_prev; /* previously last window */
! 605: }
! 606: else /* last window becomes first window */
! 607: {
! 608: wp = lastwin;
! 609: win_remove(lastwin);
! 610: win_append(NULL, wp);
! 611: wp = firstwin; /* previously last window */
! 612: }
! 613: /* exchange status height of old and new last window */
! 614: height = lastwin->w_status_height;
! 615: lastwin->w_status_height = wp->w_status_height;
! 616: wp->w_status_height = height;
! 617:
! 618: /* recompute w_winpos for all windows */
! 619: (void) win_comp_pos();
! 620: }
! 621:
! 622: cursupdate();
! 623: updateScreen(CLEAR);
! 624:
! 625: #ifdef USE_GUI
! 626: if (gui.in_use)
! 627: {
! 628: if (gui.which_scrollbars[SB_LEFT])
! 629: gui_mch_reorder_scrollbars(SB_LEFT);
! 630: if (gui.which_scrollbars[SB_RIGHT])
! 631: gui_mch_reorder_scrollbars(SB_RIGHT);
! 632: }
! 633: #endif
! 634: }
! 635:
! 636: /*
! 637: * Make all windows the same height.
! 638: * 'next_curwin' will soon be the current window, make sure it has enough
! 639: * rows.
! 640: */
! 641: void
! 642: win_equal(next_curwin, redraw)
! 643: WIN *next_curwin; /* pointer to current window to be */
! 644: int redraw;
! 645: {
! 646: int total;
! 647: int less;
! 648: int wincount;
! 649: int winpos;
! 650: int temp;
! 651: WIN *wp;
! 652: int new_height;
! 653:
! 654: /*
! 655: * count the number of lines available
! 656: */
! 657: total = 0;
! 658: wincount = 0;
! 659: for (wp = firstwin; wp; wp = wp->w_next)
! 660: {
! 661: total += wp->w_height - MIN_ROWS;
! 662: wincount++;
! 663: }
! 664:
! 665: /*
! 666: * If next_curwin given and 'winheight' set, make next_curwin p_wh lines.
! 667: */
! 668: less = 0;
! 669: if (next_curwin != NULL)
! 670: {
! 671: if (p_wh)
! 672: {
! 673: if (p_wh - MIN_ROWS > total) /* all lines go to current window */
! 674: less = total;
! 675: else
! 676: {
! 677: less = p_wh - MIN_ROWS - total / wincount;
! 678: if (less < 0)
! 679: less = 0;
! 680: }
! 681: }
! 682: }
! 683:
! 684: /*
! 685: * spread the available lines over the windows
! 686: */
! 687: winpos = 0;
! 688: for (wp = firstwin; wp != NULL; wp = wp->w_next)
! 689: {
! 690: if (wp == next_curwin && less)
! 691: {
! 692: less = 0;
! 693: temp = p_wh - MIN_ROWS;
! 694: if (temp > total)
! 695: temp = total;
! 696: }
! 697: else
! 698: temp = (total - less + (wincount >> 1)) / wincount;
! 699: new_height = MIN_ROWS + temp;
! 700: if (wp->w_winpos != winpos || wp->w_height != new_height)
! 701: {
! 702: wp->w_redr_type = NOT_VALID;
! 703: wp->w_redr_status = TRUE;
! 704: }
! 705: wp->w_winpos = winpos;
! 706: win_new_height(wp, new_height);
! 707: total -= temp;
! 708: --wincount;
! 709: winpos += wp->w_height + wp->w_status_height;
! 710: }
! 711: if (redraw)
! 712: {
! 713: cursupdate();
! 714: updateScreen(CLEAR);
! 715: }
! 716: }
! 717:
! 718: /*
! 719: * close all windows for buffer 'buf'
! 720: */
! 721: void
! 722: close_windows(buf)
! 723: BUF *buf;
! 724: {
! 725: WIN *win;
! 726:
! 727: ++RedrawingDisabled;
! 728: for (win = firstwin; win != NULL && lastwin != firstwin; )
! 729: {
! 730: if (win->w_buffer == buf)
! 731: {
! 732: close_window(win, FALSE);
! 733: win = firstwin; /* go back to the start */
! 734: }
! 735: else
! 736: win = win->w_next;
! 737: }
! 738: --RedrawingDisabled;
! 739: }
! 740:
! 741: /*
! 742: * close window "win"
! 743: * If "free_buf" is TRUE related buffer may be freed.
! 744: *
! 745: * called by :quit, :close, :xit, :wq and findtag()
! 746: */
! 747: void
! 748: close_window(win, free_buf)
! 749: WIN *win;
! 750: int free_buf;
! 751: {
! 752: WIN *wp;
! 753:
! 754: if (lastwin == firstwin)
! 755: {
! 756: EMSG("Cannot close last window");
! 757: return;
! 758: }
! 759:
! 760: /*
! 761: * Remove the window.
! 762: * if 'splitbelow' the free space goes to the window above it.
! 763: * if 'nosplitbelow' the free space goes to the window below it.
! 764: * This makes opening a window and closing it immediately keep the same window
! 765: * layout.
! 766: */
! 767: /* freed space goes to next window */
! 768: if ((!p_sb && win->w_next != NULL) || win->w_prev == NULL)
! 769: {
! 770: wp = win->w_next;
! 771: wp->w_winpos = win->w_winpos;
! 772: }
! 773: else /* freed space goes to previous window */
! 774: wp = win->w_prev;
! 775: win_new_height(wp, wp->w_height + win->w_height + win->w_status_height);
! 776:
! 777: #ifdef AUTOCMD
! 778: if (win == curwin)
! 779: {
! 780: if (wp->w_buffer != curbuf)
! 781: apply_autocmds(EVENT_BUFLEAVE, NULL, NULL);
! 782: apply_autocmds(EVENT_WINLEAVE, NULL, NULL);
! 783: }
! 784: #endif
! 785:
! 786: /*
! 787: * Close the link to the buffer.
! 788: */
! 789: close_buffer(win, win->w_buffer, free_buf, FALSE);
! 790:
! 791: win_free(win);
! 792: if (win == curwin)
! 793: curwin = NULL;
! 794: if (p_ea)
! 795: win_equal(wp, FALSE);
! 796: if (curwin == NULL)
! 797: win_enter(wp, FALSE);
! 798: /*
! 799: * if last window has status line now and we don't want one,
! 800: * remove the status line
! 801: */
! 802: if (lastwin->w_status_height &&
! 803: (p_ls == 0 || (p_ls == 1 && firstwin == lastwin)))
! 804: {
! 805: win_new_height(lastwin, lastwin->w_height + lastwin->w_status_height);
! 806: lastwin->w_status_height = 0;
! 807: comp_col();
! 808: }
! 809:
! 810: updateScreen(NOT_VALID);
! 811: if (RedrawingDisabled)
! 812: comp_Botline(wp); /* need to do this before cursupdate() */
! 813: }
! 814:
! 815: /*
! 816: * close all windows except current one
! 817: * buffers in the windows become hidden
! 818: *
! 819: * called by :only and do_arg_all();
! 820: */
! 821: void
! 822: close_others(message)
! 823: int message;
! 824: {
! 825: WIN *wp;
! 826: WIN *nextwp;
! 827:
! 828: if (lastwin == firstwin)
! 829: {
! 830: if (message
! 831: #ifdef AUTOCMD
! 832: && !autocmd_busy
! 833: #endif
! 834: )
! 835: MSG("Already only one window");
! 836: return;
! 837: }
! 838:
! 839: for (wp = firstwin; wp != NULL; wp = nextwp)
! 840: {
! 841: nextwp = wp->w_next;
! 842: if (wp == curwin) /* don't close current window */
! 843: continue;
! 844: /*
! 845: * Close the link to the buffer.
! 846: */
! 847: close_buffer(wp, wp->w_buffer, FALSE, FALSE);
! 848:
! 849: /*
! 850: * Remove the window. All lines go to current window.
! 851: */
! 852: win_new_height(curwin,
! 853: curwin->w_height + wp->w_height + wp->w_status_height);
! 854: win_free(wp);
! 855: }
! 856:
! 857: /*
! 858: * If current window has status line and we don't want one,
! 859: * remove the status line.
! 860: */
! 861: if (curwin->w_status_height && p_ls != 2)
! 862: {
! 863: win_new_height(curwin, curwin->w_height + curwin->w_status_height);
! 864: curwin->w_status_height = 0;
! 865: }
! 866: curwin->w_winpos = 0; /* put current window at top of the screen */
! 867: if (message)
! 868: updateScreen(NOT_VALID);
! 869: }
! 870:
! 871: /*
! 872: * init the cursor in the window
! 873: *
! 874: * called when a new file is being edited
! 875: */
! 876: void
! 877: win_init(wp)
! 878: WIN *wp;
! 879: {
! 880: wp->w_redr_type = NOT_VALID;
! 881: wp->w_cursor.lnum = 1;
! 882: wp->w_curswant = wp->w_cursor.col = 0;
! 883: wp->w_pcmark.lnum = 1; /* pcmark not cleared but set to line 1 */
! 884: wp->w_pcmark.col = 0;
! 885: wp->w_prev_pcmark.lnum = 0;
! 886: wp->w_prev_pcmark.col = 0;
! 887: wp->w_topline = 1;
! 888: wp->w_botline = 2;
! 889: }
! 890:
! 891: /*
! 892: * make window wp the current window
! 893: */
! 894: void
! 895: win_enter(wp, undo_sync)
! 896: WIN *wp;
! 897: int undo_sync;
! 898: {
! 899: #ifdef AUTOCMD
! 900: int other_buffer = FALSE;
! 901: #endif
! 902:
! 903: if (wp == curwin) /* nothing to do */
! 904: return;
! 905:
! 906: #ifdef AUTOCMD
! 907: if (curwin != NULL)
! 908: {
! 909: if (wp->w_buffer != curbuf)
! 910: {
! 911: apply_autocmds(EVENT_BUFLEAVE, NULL, NULL);
! 912: other_buffer = TRUE;
! 913: }
! 914: apply_autocmds(EVENT_WINLEAVE, NULL, NULL);
! 915: }
! 916: #endif
! 917:
! 918: /* sync undo before leaving the current buffer */
! 919: if (undo_sync && curbuf != wp->w_buffer)
! 920: u_sync();
! 921: /* may have to copy the buffer options when 'cpo' contains 'S' */
! 922: if (wp->w_buffer != curbuf)
! 923: buf_copy_options(curbuf, wp->w_buffer, TRUE);
! 924: if (curwin != NULL)
! 925: prevwin = curwin; /* remember for CTRL-W p */
! 926: curwin = wp;
! 927: curbuf = wp->w_buffer;
! 928:
! 929: #ifdef AUTOCMD
! 930: apply_autocmds(EVENT_WINENTER, NULL, NULL);
! 931: if (other_buffer)
! 932: apply_autocmds(EVENT_BUFENTER, NULL, NULL);
! 933: #endif
! 934:
! 935: maketitle();
! 936: /* set window height to desired minimal value */
! 937: if (p_wh && curwin->w_height < p_wh)
! 938: win_setheight((int)p_wh);
! 939: #ifdef USE_MOUSE
! 940: setmouse(); /* in case jumped to/from help buffer */
! 941: #endif
! 942: }
! 943:
! 944: /*
! 945: * allocate a window structure and link it in the window list
! 946: */
! 947: WIN *
! 948: win_alloc(after)
! 949: WIN *after;
! 950: {
! 951: WIN *newwin;
! 952:
! 953: /*
! 954: * allocate window structure and linesizes arrays
! 955: */
! 956: newwin = (WIN *)alloc((unsigned)sizeof(WIN));
! 957: if (newwin)
! 958: {
! 959: /*
! 960: * most stucture members have to be zero
! 961: */
! 962: (void)vim_memset(newwin, 0, sizeof(WIN));
! 963: /*
! 964: * link the window in the window list
! 965: */
! 966: win_append(after, newwin);
! 967:
! 968: win_alloc_lsize(newwin);
! 969:
! 970: /* position the display and the cursor at the top of the file. */
! 971: newwin->w_topline = 1;
! 972: newwin->w_botline = 2;
! 973: newwin->w_cursor.lnum = 1;
! 974:
! 975: #ifdef USE_GUI
! 976: /* Let the GUI know this is a new scrollbar */
! 977: newwin->w_scrollbar.height = 0;
! 978: #endif /* USE_GUI */
! 979: }
! 980: return newwin;
! 981: }
! 982:
! 983: /*
! 984: * remove window 'wp' from the window list and free the structure
! 985: */
! 986: void
! 987: win_free(wp)
! 988: WIN *wp;
! 989: {
! 990: int i;
! 991:
! 992: if (prevwin == wp)
! 993: prevwin = NULL;
! 994: win_free_lsize(wp);
! 995:
! 996: for (i = 0; i < wp->w_tagstacklen; ++i)
! 997: free(wp->w_tagstack[i].tagname);
! 998:
! 999: #ifdef USE_GUI
! 1000: if (gui.in_use)
! 1001: gui_mch_destroy_scrollbar(wp);
! 1002: #endif /* USE_GUI */
! 1003:
! 1004: win_remove(wp);
! 1005: vim_free(wp);
! 1006: }
! 1007:
! 1008: static void
! 1009: win_append(after, wp)
! 1010: WIN *after, *wp;
! 1011: {
! 1012: WIN *before;
! 1013:
! 1014: if (after == NULL) /* after NULL is in front of the first */
! 1015: before = firstwin;
! 1016: else
! 1017: before = after->w_next;
! 1018:
! 1019: wp->w_next = before;
! 1020: wp->w_prev = after;
! 1021: if (after == NULL)
! 1022: firstwin = wp;
! 1023: else
! 1024: after->w_next = wp;
! 1025: if (before == NULL)
! 1026: lastwin = wp;
! 1027: else
! 1028: before->w_prev = wp;
! 1029: }
! 1030:
! 1031: /*
! 1032: * remove window from the window list
! 1033: */
! 1034: static void
! 1035: win_remove(wp)
! 1036: WIN *wp;
! 1037: {
! 1038: if (wp->w_prev)
! 1039: wp->w_prev->w_next = wp->w_next;
! 1040: else
! 1041: firstwin = wp->w_next;
! 1042: if (wp->w_next)
! 1043: wp->w_next->w_prev = wp->w_prev;
! 1044: else
! 1045: lastwin = wp->w_prev;
! 1046: }
! 1047:
! 1048: /*
! 1049: * allocate lsize arrays for a window
! 1050: * return FAIL for failure, OK for success
! 1051: */
! 1052: int
! 1053: win_alloc_lsize(wp)
! 1054: WIN *wp;
! 1055: {
! 1056: wp->w_lsize_valid = 0;
! 1057: wp->w_lsize_lnum = (linenr_t *) malloc((size_t) (Rows * sizeof(linenr_t)));
! 1058: wp->w_lsize = (char_u *)malloc((size_t) Rows);
! 1059: if (wp->w_lsize_lnum == NULL || wp->w_lsize == NULL)
! 1060: {
! 1061: win_free_lsize(wp); /* one of the two may have worked */
! 1062: wp->w_lsize_lnum = NULL;
! 1063: wp->w_lsize = NULL;
! 1064: return FAIL;
! 1065: }
! 1066: return OK;
! 1067: }
! 1068:
! 1069: /*
! 1070: * free lsize arrays for a window
! 1071: */
! 1072: void
! 1073: win_free_lsize(wp)
! 1074: WIN *wp;
! 1075: {
! 1076: vim_free(wp->w_lsize_lnum);
! 1077: vim_free(wp->w_lsize);
! 1078: }
! 1079:
! 1080: /*
! 1081: * call this fuction whenever Rows changes value
! 1082: */
! 1083: void
! 1084: screen_new_rows()
! 1085: {
! 1086: WIN *wp;
! 1087: int extra_lines;
! 1088:
! 1089: if (firstwin == NULL) /* not initialized yet */
! 1090: return;
! 1091: /*
! 1092: * the number of extra lines is the difference between the position where
! 1093: * the command line should be and where it is now
! 1094: */
! 1095: compute_cmdrow();
! 1096: extra_lines = Rows - p_ch - cmdline_row;
! 1097: if (extra_lines < 0) /* reduce windows height */
! 1098: {
! 1099: for (wp = lastwin; wp; wp = wp->w_prev)
! 1100: {
! 1101: if (wp->w_height - MIN_ROWS < -extra_lines)
! 1102: {
! 1103: extra_lines += wp->w_height - MIN_ROWS;
! 1104: win_new_height(wp, MIN_ROWS);
! 1105: }
! 1106: else
! 1107: {
! 1108: win_new_height(wp, wp->w_height + extra_lines);
! 1109: break;
! 1110: }
! 1111: }
! 1112: (void)win_comp_pos(); /* compute w_winpos */
! 1113: }
! 1114: else if (extra_lines > 0) /* increase height of last window */
! 1115: win_new_height(lastwin, lastwin->w_height + extra_lines);
! 1116:
! 1117: compute_cmdrow();
! 1118:
! 1119: if (p_ea)
! 1120: win_equal(curwin, FALSE);
! 1121: }
! 1122:
! 1123: /*
! 1124: * update the w_winpos field for all windows
! 1125: * returns the row just after the last window
! 1126: */
! 1127: static int
! 1128: win_comp_pos()
! 1129: {
! 1130: WIN *wp;
! 1131: int row;
! 1132:
! 1133: row = 0;
! 1134: for (wp = firstwin; wp != NULL; wp = wp->w_next)
! 1135: {
! 1136: if (wp->w_winpos != row) /* if position changes, redraw */
! 1137: {
! 1138: wp->w_winpos = row;
! 1139: wp->w_redr_type = NOT_VALID;
! 1140: wp->w_redr_status = TRUE;
! 1141: }
! 1142: row += wp->w_height + wp->w_status_height;
! 1143: }
! 1144: return row;
! 1145: }
! 1146:
! 1147: /*
! 1148: * set current window height
! 1149: */
! 1150: void
! 1151: win_setheight(height)
! 1152: int height;
! 1153: {
! 1154: WIN *wp;
! 1155: int room; /* total number of lines available */
! 1156: int take; /* number of lines taken from other windows */
! 1157: int room_cmdline; /* lines available from cmdline */
! 1158: int row;
! 1159: int run;
! 1160:
! 1161: if (height < MIN_ROWS) /* need at least some lines */
! 1162: height = MIN_ROWS;
! 1163: /*
! 1164: * compute the room we have from all the windows
! 1165: */
! 1166: room = MIN_ROWS; /* count the MIN_ROWS for the current window */
! 1167: for (wp = firstwin; wp != NULL; wp = wp->w_next)
! 1168: room += wp->w_height - MIN_ROWS;
! 1169: /*
! 1170: * compute the room available from the command line
! 1171: */
! 1172: room_cmdline = Rows - p_ch - cmdline_row;
! 1173: /*
! 1174: * limit new height to the room available
! 1175: */
! 1176: if (height > room + room_cmdline) /* can't make it that large */
! 1177: height = room + room_cmdline; /* use all available room */
! 1178: /*
! 1179: * compute the number of lines we will take from the windows (can be negative)
! 1180: */
! 1181: take = height - curwin->w_height;
! 1182: if (take == 0) /* no change, nothing to do */
! 1183: return;
! 1184:
! 1185: if (take > 0)
! 1186: {
! 1187: take -= room_cmdline; /* use lines from cmdline first */
! 1188: if (take < 0)
! 1189: take = 0;
! 1190: }
! 1191: /*
! 1192: * set the current window to the new height
! 1193: */
! 1194: win_new_height(curwin, height);
! 1195:
! 1196: /*
! 1197: * First take lines from the windows below the current window.
! 1198: * If that is not enough, takes lines from windows above the current window.
! 1199: */
! 1200: for (run = 0; run < 2; ++run)
! 1201: {
! 1202: if (run == 0)
! 1203: wp = curwin->w_next; /* 1st run: start with next window */
! 1204: else
! 1205: wp = curwin->w_prev; /* 2nd run: start with prev window */
! 1206: while (wp != NULL && take != 0)
! 1207: {
! 1208: if (wp->w_height - take < MIN_ROWS)
! 1209: {
! 1210: take -= wp->w_height - MIN_ROWS;
! 1211: win_new_height(wp, MIN_ROWS);
! 1212: }
! 1213: else
! 1214: {
! 1215: win_new_height(wp, wp->w_height - take);
! 1216: take = 0;
! 1217: }
! 1218: if (run == 0)
! 1219: wp = wp->w_next;
! 1220: else
! 1221: wp = wp->w_prev;
! 1222: }
! 1223: }
! 1224:
! 1225: /* recompute the window positions */
! 1226: row = win_comp_pos();
! 1227:
! 1228: /*
! 1229: * If there is extra space created between the last window and the command line,
! 1230: * clear it.
! 1231: */
! 1232: screen_fill(row, cmdline_row, 0, (int)Columns, ' ', ' ');
! 1233: cmdline_row = row;
! 1234:
! 1235: updateScreen(NOT_VALID);
! 1236: }
! 1237:
! 1238: #ifdef USE_MOUSE
! 1239: void
! 1240: win_drag_status_line(offset)
! 1241: int offset;
! 1242: {
! 1243: WIN *wp;
! 1244: int room;
! 1245: int row;
! 1246: int up; /* if TRUE, drag status line up, otherwise down */
! 1247:
! 1248: if (offset < 0)
! 1249: {
! 1250: up = TRUE;
! 1251: offset = -offset;
! 1252: }
! 1253: else
! 1254: up = FALSE;
! 1255:
! 1256: if (up) /* drag up */
! 1257: {
! 1258: room = 0;
! 1259: for (wp = curwin; wp != NULL && room < offset; wp = wp->w_prev)
! 1260: room += wp->w_height - MIN_ROWS;
! 1261: wp = curwin->w_next; /* put wp at window that grows */
! 1262: }
! 1263: else /* drag down */
! 1264: {
! 1265: /*
! 1266: * Only dragging the last status line can reduce p_ch.
! 1267: */
! 1268: room = Rows - cmdline_row;
! 1269: if (curwin->w_next == NULL)
! 1270: room -= 1;
! 1271: else
! 1272: room -= p_ch;
! 1273: for (wp = curwin->w_next; wp != NULL && room < offset; wp = wp->w_next)
! 1274: room += wp->w_height - MIN_ROWS;
! 1275: wp = curwin; /* put wp at window that grows */
! 1276: }
! 1277:
! 1278: if (room < offset) /* Not enough room */
! 1279: offset = room; /* Move as far as we can */
! 1280: if (offset <= 0)
! 1281: return;
! 1282:
! 1283: if (wp != NULL) /* grow window wp by offset lines */
! 1284: win_new_height(wp, wp->w_height + offset);
! 1285:
! 1286: if (up)
! 1287: wp = curwin; /* current window gets smaller */
! 1288: else
! 1289: wp = curwin->w_next; /* next window gets smaller */
! 1290:
! 1291: while (wp != NULL && offset > 0)
! 1292: {
! 1293: if (wp->w_height - offset < MIN_ROWS)
! 1294: {
! 1295: offset -= wp->w_height - MIN_ROWS;
! 1296: win_new_height(wp, MIN_ROWS);
! 1297: }
! 1298: else
! 1299: {
! 1300: win_new_height(wp, wp->w_height - offset);
! 1301: offset = 0;
! 1302: }
! 1303: if (up)
! 1304: wp = wp->w_prev;
! 1305: else
! 1306: wp = wp->w_next;
! 1307: }
! 1308: row = win_comp_pos();
! 1309: screen_fill(row, cmdline_row, 0, (int)Columns, ' ', ' ');
! 1310: cmdline_row = row;
! 1311: p_ch = Rows - cmdline_row;
! 1312: updateScreen(NOT_VALID);
! 1313: showmode();
! 1314: }
! 1315: #endif /* USE_MOUSE */
! 1316:
! 1317: /*
! 1318: * Set new window height.
! 1319: */
! 1320: static void
! 1321: win_new_height(wp, height)
! 1322: WIN *wp;
! 1323: int height;
! 1324: {
! 1325: /* should adjust topline to keep cursor at same relative postition */
! 1326:
! 1327: wp->w_height = height;
! 1328: win_comp_scroll(wp);
! 1329: wp->w_redr_type = NOT_VALID;
! 1330: wp->w_redr_status = TRUE;
! 1331: }
! 1332:
! 1333: void
! 1334: win_comp_scroll(wp)
! 1335: WIN *wp;
! 1336: {
! 1337: wp->w_p_scroll = (wp->w_height >> 1);
! 1338: if (wp->w_p_scroll == 0)
! 1339: wp->w_p_scroll = 1;
! 1340: }
! 1341:
! 1342: /*
! 1343: * command_height: called whenever p_ch has been changed
! 1344: */
! 1345: void
! 1346: command_height()
! 1347: {
! 1348: int current;
! 1349:
! 1350: current = Rows - cmdline_row;
! 1351: if (p_ch > current) /* p_ch got bigger */
! 1352: {
! 1353: if (lastwin->w_height - (p_ch - current) < MIN_ROWS)
! 1354: {
! 1355: emsg(e_noroom);
! 1356: p_ch = lastwin->w_height - MIN_ROWS + current;
! 1357: }
! 1358: /* clear the lines added to cmdline */
! 1359: screen_fill((int)(Rows - p_ch), (int)Rows, 0, (int)Columns, ' ', ' ');
! 1360: }
! 1361: win_new_height(lastwin, lastwin->w_height + current - (int)p_ch);
! 1362: cmdline_row = Rows - p_ch;
! 1363: redraw_cmdline = TRUE;
! 1364: }
! 1365:
! 1366: void
! 1367: last_status()
! 1368: {
! 1369: if (lastwin->w_status_height)
! 1370: {
! 1371: /* remove status line */
! 1372: if (p_ls == 0 || (p_ls == 1 && firstwin == lastwin))
! 1373: {
! 1374: win_new_height(lastwin, lastwin->w_height + 1);
! 1375: lastwin->w_status_height = 0;
! 1376: }
! 1377: }
! 1378: else
! 1379: {
! 1380: /* add status line */
! 1381: if (p_ls == 2 || (p_ls == 1 && firstwin != lastwin))
! 1382: {
! 1383: if (lastwin->w_height <= MIN_ROWS) /* can't do it */
! 1384: emsg(e_noroom);
! 1385: else
! 1386: {
! 1387: win_new_height(lastwin, lastwin->w_height - 1);
! 1388: lastwin->w_status_height = 1;
! 1389: }
! 1390: }
! 1391: }
! 1392: }
! 1393:
! 1394: /*
! 1395: * file_name_at_cursor()
! 1396: *
! 1397: * Return the name of the file under (or to the right of) the cursor. The
! 1398: * p_path variable is searched if the file name does not start with '/'.
! 1399: * The string returned has been alloc'ed and should be freed by the caller.
! 1400: * NULL is returned if the file name or file is not found.
! 1401: */
! 1402: char_u *
! 1403: file_name_at_cursor(options)
! 1404: int options;
! 1405: {
! 1406: return get_file_name_in_path(ml_get_curline(),
! 1407: curwin->w_cursor.col, options);
! 1408: }
! 1409: /* options:
! 1410: * FNAME_MESS give error messages
! 1411: * FNAME_EXP expand to path
! 1412: * FNAME_HYP check for hypertext link
! 1413: */
! 1414: char_u *
! 1415: get_file_name_in_path(ptr, col, options)
! 1416: char_u *ptr;
! 1417: int col;
! 1418: int options;
! 1419: {
! 1420: char_u *dir;
! 1421: char_u *file_name;
! 1422: char_u save_char;
! 1423: char_u *curr_path = NULL;
! 1424: int curr_path_len;
! 1425: int len;
! 1426:
! 1427: /* search forward for what could be the start of a file name */
! 1428: while (ptr[col] != NUL && !isfilechar(ptr[col]))
! 1429: ++col;
! 1430: if (ptr[col] == NUL) /* nothing found */
! 1431: {
! 1432: if (options & FNAME_MESS)
! 1433: EMSG("No file name under cursor");
! 1434: return NULL;
! 1435: }
! 1436:
! 1437: /* search backward for char that cannot be in a file name */
! 1438: while (col >= 0 && isfilechar(ptr[col]))
! 1439: --col;
! 1440: ptr += col + 1;
! 1441: col = 0;
! 1442:
! 1443: /* search forward for a char that cannot be in a file name */
! 1444: while (isfilechar(ptr[col]))
! 1445: ++col;
! 1446:
! 1447: if (options & FNAME_HYP)
! 1448: {
! 1449: /* For hypertext links, ignore the name of the machine.
! 1450: * Such a link looks like "type://machine/path". Only "/path" is used.
! 1451: * First search for the string "://", then for the extra '/'
! 1452: */
! 1453: if ((file_name = vim_strchr(ptr, ':')) != NULL &&
! 1454: STRNCMP(file_name, "://", (size_t)3) == 0 &&
! 1455: (file_name = vim_strchr(file_name + 3, '/')) != NULL &&
! 1456: file_name < ptr + col)
! 1457: {
! 1458: col -= file_name - ptr;
! 1459: ptr = file_name;
! 1460: if (ptr[1] == '~') /* skip '/' for /~user/path */
! 1461: {
! 1462: ++ptr;
! 1463: --col;
! 1464: }
! 1465: }
! 1466: }
! 1467:
! 1468: if (!(options & FNAME_EXP))
! 1469: return strnsave(ptr, col);
! 1470:
! 1471: /* copy file name into NameBuff, expanding environment variables */
! 1472: save_char = ptr[col];
! 1473: ptr[col] = NUL;
! 1474: expand_env(ptr, NameBuff, MAXPATHL);
! 1475: ptr[col] = save_char;
! 1476:
! 1477: if (isFullName(NameBuff)) /* absolute path */
! 1478: {
! 1479: if ((file_name = strsave(NameBuff)) == NULL)
! 1480: return NULL;
! 1481: if (getperm(file_name) >= 0)
! 1482: return file_name;
! 1483: if (options & FNAME_MESS)
! 1484: {
! 1485: sprintf((char *)IObuff, "Can't find file `%s'", NameBuff);
! 1486: emsg(IObuff);
! 1487: }
! 1488: }
! 1489: else /* relative path, use 'path' option */
! 1490: {
! 1491: if (curbuf->b_xfilename != NULL)
! 1492: {
! 1493: curr_path = curbuf->b_xfilename;
! 1494: ptr = gettail(curr_path);
! 1495: curr_path_len = ptr - curr_path;
! 1496: }
! 1497: else
! 1498: curr_path_len = 0;
! 1499: if ((file_name = alloc((int)(curr_path_len + STRLEN(p_path) +
! 1500: STRLEN(NameBuff) + 3))) == NULL)
! 1501: return NULL;
! 1502:
! 1503: for (dir = p_path; *dir;)
! 1504: {
! 1505: len = copy_option_part(&dir, file_name, 31000, " ,");
! 1506: /* len == 0 means: use current directory */
! 1507: if (len != 0)
! 1508: {
! 1509: /* Look for file relative to current file */
! 1510: if (file_name[0] == '.' && curr_path_len > 0)
! 1511: {
! 1512: if (len == 1) /* just a "." */
! 1513: len = 0;
! 1514: else /* "./path": move "path" */
! 1515: {
! 1516: len -= 2;
! 1517: vim_memmove(file_name + curr_path_len, file_name + 2,
! 1518: (size_t)len);
! 1519: }
! 1520: STRNCPY(file_name, curr_path, curr_path_len);
! 1521: len += curr_path_len;
! 1522: }
! 1523: if (!ispathsep(file_name[len - 1]))
! 1524: file_name[len++] = PATHSEP;
! 1525: }
! 1526: STRCPY(file_name + len, NameBuff);
! 1527: if (getperm(file_name) >= 0)
! 1528: return file_name;
! 1529: }
! 1530: if (options & FNAME_MESS)
! 1531: EMSG2("Can't find file \"%s\" in path", NameBuff);
! 1532: }
! 1533: vim_free(file_name); /* file doesn't exist */
! 1534: return NULL;
! 1535: }
! 1536:
! 1537: /*
! 1538: * Return the minimal number of rows that is needed on the screen to display
! 1539: * the current number of windows.
! 1540: */
! 1541: int
! 1542: min_rows()
! 1543: {
! 1544: WIN *wp;
! 1545: int total;
! 1546:
! 1547: if (firstwin == NULL) /* not initialized yet */
! 1548: return MIN_ROWS + 1; /* one window plus command line */
! 1549:
! 1550: total = p_ch; /* count the room for the status line */
! 1551: for (wp = firstwin; wp != NULL; wp = wp->w_next)
! 1552: total += MIN_ROWS + wp->w_status_height;
! 1553: return total;
! 1554: }
! 1555:
! 1556: /*
! 1557: * Return TRUE if there is only one window, not counting a help window, unless
! 1558: * it is the current window.
! 1559: */
! 1560: int
! 1561: only_one_window()
! 1562: {
! 1563: int count = 0;
! 1564: WIN *wp;
! 1565:
! 1566: for (wp = firstwin; wp != NULL; wp = wp->w_next)
! 1567: if (!wp->w_buffer->b_help || wp == curwin)
! 1568: ++count;
! 1569: return (count <= 1);
! 1570: }
![[BACK]](/icons/back.gif){kind=icon}
Return to window.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / vim