diff options
Diffstat (limited to 'src/nvim/cursor.c')
| -rw-r--r-- | src/nvim/cursor.c | 489 |
1 files changed, 489 insertions, 0 deletions
diff --git a/src/nvim/cursor.c b/src/nvim/cursor.c new file mode 100644 index 0000000000..661516b52d --- /dev/null +++ b/src/nvim/cursor.c @@ -0,0 +1,489 @@ +#include "nvim/cursor.h" +#include "nvim/charset.h" +#include "nvim/fold.h" +#include "nvim/memline.h" +#include "nvim/memory.h" +#include "nvim/misc1.h" +#include "nvim/move.h" +#include "nvim/screen.h" +#include "nvim/vim.h" + +static int coladvance2(pos_T *pos, int addspaces, int finetune, colnr_T wcol); + +/* + * Get the screen position of the cursor. + */ +int getviscol(void) +{ + colnr_T x; + + getvvcol(curwin, &curwin->w_cursor, &x, NULL, NULL); + return (int)x; +} + +/* + * Get the screen position of character col with a coladd in the cursor line. + */ +int getviscol2(colnr_T col, colnr_T coladd) +{ + colnr_T x; + pos_T pos; + + pos.lnum = curwin->w_cursor.lnum; + pos.col = col; + pos.coladd = coladd; + getvvcol(curwin, &pos, &x, NULL, NULL); + return (int)x; +} + +/* + * Go to column "wcol", and add/insert white space as necessary to get the + * cursor in that column. + * The caller must have saved the cursor line for undo! + */ +int coladvance_force(colnr_T wcol) +{ + int rc = coladvance2(&curwin->w_cursor, TRUE, FALSE, wcol); + + if (wcol == MAXCOL) + curwin->w_valid &= ~VALID_VIRTCOL; + else { + /* Virtcol is valid */ + curwin->w_valid |= VALID_VIRTCOL; + curwin->w_virtcol = wcol; + } + return rc; +} + +/* + * Try to advance the Cursor to the specified screen column. + * If virtual editing: fine tune the cursor position. + * Note that all virtual positions off the end of a line should share + * a curwin->w_cursor.col value (n.b. this is equal to STRLEN(line)), + * beginning at coladd 0. + * + * return OK if desired column is reached, FAIL if not + */ +int coladvance(colnr_T wcol) +{ + int rc = getvpos(&curwin->w_cursor, wcol); + + if (wcol == MAXCOL || rc == FAIL) + curwin->w_valid &= ~VALID_VIRTCOL; + else if (*ml_get_cursor() != TAB) { + /* Virtcol is valid when not on a TAB */ + curwin->w_valid |= VALID_VIRTCOL; + curwin->w_virtcol = wcol; + } + return rc; +} + +static int +coladvance2 ( + pos_T *pos, + int addspaces, /* change the text to achieve our goal? */ + int finetune, /* change char offset for the exact column */ + colnr_T wcol /* column to move to */ +) +{ + int idx; + char_u *ptr; + char_u *line; + colnr_T col = 0; + int csize = 0; + int one_more; + int head = 0; + + one_more = (State & INSERT) + || restart_edit != NUL + || (VIsual_active && *p_sel != 'o') + || ((ve_flags & VE_ONEMORE) && wcol < MAXCOL) + ; + line = ml_get_buf(curbuf, pos->lnum, FALSE); + + if (wcol >= MAXCOL) { + idx = (int)STRLEN(line) - 1 + one_more; + col = wcol; + + if ((addspaces || finetune) && !VIsual_active) { + curwin->w_curswant = linetabsize(line) + one_more; + if (curwin->w_curswant > 0) + --curwin->w_curswant; + } + } else { + int width = W_WIDTH(curwin) - win_col_off(curwin); + + if (finetune + && curwin->w_p_wrap + && curwin->w_width != 0 + && wcol >= (colnr_T)width) { + csize = linetabsize(line); + if (csize > 0) + csize--; + + if (wcol / width > (colnr_T)csize / width + && ((State & INSERT) == 0 || (int)wcol > csize + 1)) { + /* In case of line wrapping don't move the cursor beyond the + * right screen edge. In Insert mode allow going just beyond + * the last character (like what happens when typing and + * reaching the right window edge). */ + wcol = (csize / width + 1) * width - 1; + } + } + + ptr = line; + while (col <= wcol && *ptr != NUL) { + /* Count a tab for what it's worth (if list mode not on) */ + csize = win_lbr_chartabsize(curwin, ptr, col, &head); + mb_ptr_adv(ptr); + col += csize; + } + idx = (int)(ptr - line); + /* + * Handle all the special cases. The virtual_active() check + * is needed to ensure that a virtual position off the end of + * a line has the correct indexing. The one_more comparison + * replaces an explicit add of one_more later on. + */ + if (col > wcol || (!virtual_active() && one_more == 0)) { + idx -= 1; + /* Don't count the chars from 'showbreak'. */ + csize -= head; + col -= csize; + } + + if (virtual_active() + && addspaces + && ((col != wcol && col != wcol + 1) || csize > 1)) { + /* 'virtualedit' is set: The difference between wcol and col is + * filled with spaces. */ + + if (line[idx] == NUL) { + /* Append spaces */ + int correct = wcol - col; + char_u *newline = xmalloc(idx + correct + 1); + int t; + + for (t = 0; t < idx; ++t) + newline[t] = line[t]; + + for (t = 0; t < correct; ++t) + newline[t + idx] = ' '; + + newline[idx + correct] = NUL; + + ml_replace(pos->lnum, newline, FALSE); + changed_bytes(pos->lnum, (colnr_T)idx); + idx += correct; + col = wcol; + } else { + /* Break a tab */ + int linelen = (int)STRLEN(line); + int correct = wcol - col - csize + 1; /* negative!! */ + char_u *newline; + int t, s = 0; + int v; + + if (-correct > csize) + return FAIL; + + newline = xmalloc(linelen + csize); + + for (t = 0; t < linelen; t++) { + if (t != idx) + newline[s++] = line[t]; + else + for (v = 0; v < csize; v++) + newline[s++] = ' '; + } + + newline[linelen + csize - 1] = NUL; + + ml_replace(pos->lnum, newline, FALSE); + changed_bytes(pos->lnum, idx); + idx += (csize - 1 + correct); + col += correct; + } + } + } + + if (idx < 0) + pos->col = 0; + else + pos->col = idx; + + pos->coladd = 0; + + if (finetune) { + if (wcol == MAXCOL) { + /* The width of the last character is used to set coladd. */ + if (!one_more) { + colnr_T scol, ecol; + + getvcol(curwin, pos, &scol, NULL, &ecol); + pos->coladd = ecol - scol; + } + } else { + int b = (int)wcol - (int)col; + + /* The difference between wcol and col is used to set coladd. */ + if (b > 0 && b < (MAXCOL - 2 * W_WIDTH(curwin))) + pos->coladd = b; + + col += b; + } + } + + /* prevent from moving onto a trail byte */ + if (has_mbyte) + mb_adjustpos(curbuf, pos); + + if (col < wcol) + return FAIL; + return OK; +} + +/* + * Return in "pos" the position of the cursor advanced to screen column "wcol". + * return OK if desired column is reached, FAIL if not + */ +int getvpos(pos_T *pos, colnr_T wcol) +{ + return coladvance2(pos, FALSE, virtual_active(), wcol); +} + +/* + * Increment the cursor position. See inc() for return values. + */ +int inc_cursor(void) +{ + return inc(&curwin->w_cursor); +} + +/* + * dec(p) + * + * Decrement the line pointer 'p' crossing line boundaries as necessary. + * Return 1 when crossing a line, -1 when at start of file, 0 otherwise. + */ +int dec_cursor(void) +{ + return dec(&curwin->w_cursor); +} + +/* + * Get the line number relative to the current cursor position, i.e. the + * difference between line number and cursor position. Only look for lines that + * can be visible, folded lines don't count. + */ +linenr_T +get_cursor_rel_lnum ( + win_T *wp, + linenr_T lnum /* line number to get the result for */ +) +{ + linenr_T cursor = wp->w_cursor.lnum; + linenr_T retval = 0; + + if (hasAnyFolding(wp)) { + if (lnum > cursor) { + while (lnum > cursor) { + (void)hasFoldingWin(wp, lnum, &lnum, NULL, TRUE, NULL); + /* if lnum and cursor are in the same fold, + * now lnum <= cursor */ + if (lnum > cursor) + retval++; + lnum--; + } + } else if (lnum < cursor) { + while (lnum < cursor) { + (void)hasFoldingWin(wp, lnum, NULL, &lnum, TRUE, NULL); + /* if lnum and cursor are in the same fold, + * now lnum >= cursor */ + if (lnum < cursor) + retval--; + lnum++; + } + } + /* else if (lnum == cursor) + * retval = 0; + */ + } else + retval = lnum - cursor; + + return retval; +} + +/* + * Make sure curwin->w_cursor.lnum is valid. + */ +void check_cursor_lnum(void) +{ + if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count) { + /* If there is a closed fold at the end of the file, put the cursor in + * its first line. Otherwise in the last line. */ + if (!hasFolding(curbuf->b_ml.ml_line_count, + &curwin->w_cursor.lnum, NULL)) + curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; + } + if (curwin->w_cursor.lnum <= 0) + curwin->w_cursor.lnum = 1; +} + +/* + * Make sure curwin->w_cursor.col is valid. + */ +void check_cursor_col(void) +{ + check_cursor_col_win(curwin); +} + +/* + * Make sure win->w_cursor.col is valid. + */ +void check_cursor_col_win(win_T *win) +{ + colnr_T len; + colnr_T oldcol = win->w_cursor.col; + colnr_T oldcoladd = win->w_cursor.col + win->w_cursor.coladd; + + len = (colnr_T)STRLEN(ml_get_buf(win->w_buffer, win->w_cursor.lnum, FALSE)); + if (len == 0) + win->w_cursor.col = 0; + else if (win->w_cursor.col >= len) { + /* Allow cursor past end-of-line when: + * - in Insert mode or restarting Insert mode + * - in Visual mode and 'selection' isn't "old" + * - 'virtualedit' is set */ + if ((State & INSERT) || restart_edit + || (VIsual_active && *p_sel != 'o') + || (ve_flags & VE_ONEMORE) + || virtual_active()) + win->w_cursor.col = len; + else { + win->w_cursor.col = len - 1; + /* Move the cursor to the head byte. */ + if (has_mbyte) + mb_adjustpos(win->w_buffer, &win->w_cursor); + } + } else if (win->w_cursor.col < 0) + win->w_cursor.col = 0; + + /* If virtual editing is on, we can leave the cursor on the old position, + * only we must set it to virtual. But don't do it when at the end of the + * line. */ + if (oldcol == MAXCOL) + win->w_cursor.coladd = 0; + else if (ve_flags == VE_ALL) { + if (oldcoladd > win->w_cursor.col) + win->w_cursor.coladd = oldcoladd - win->w_cursor.col; + else + /* avoid weird number when there is a miscalculation or overflow */ + win->w_cursor.coladd = 0; + } +} + +/* + * make sure curwin->w_cursor in on a valid character + */ +void check_cursor(void) +{ + check_cursor_lnum(); + check_cursor_col(); +} + +/* + * Make sure curwin->w_cursor is not on the NUL at the end of the line. + * Allow it when in Visual mode and 'selection' is not "old". + */ +void adjust_cursor_col(void) +{ + if (curwin->w_cursor.col > 0 + && (!VIsual_active || *p_sel == 'o') + && gchar_cursor() == NUL) + --curwin->w_cursor.col; +} + +/* + * When curwin->w_leftcol has changed, adjust the cursor position. + * Return TRUE if the cursor was moved. + */ +int leftcol_changed(void) +{ + long lastcol; + colnr_T s, e; + int retval = FALSE; + + changed_cline_bef_curs(); + lastcol = curwin->w_leftcol + W_WIDTH(curwin) - curwin_col_off() - 1; + validate_virtcol(); + + /* + * If the cursor is right or left of the screen, move it to last or first + * character. + */ + if (curwin->w_virtcol > (colnr_T)(lastcol - p_siso)) { + retval = TRUE; + coladvance((colnr_T)(lastcol - p_siso)); + } else if (curwin->w_virtcol < curwin->w_leftcol + p_siso) { + retval = TRUE; + (void)coladvance((colnr_T)(curwin->w_leftcol + p_siso)); + } + + /* + * If the start of the character under the cursor is not on the screen, + * advance the cursor one more char. If this fails (last char of the + * line) adjust the scrolling. + */ + getvvcol(curwin, &curwin->w_cursor, &s, NULL, &e); + if (e > (colnr_T)lastcol) { + retval = TRUE; + coladvance(s - 1); + } else if (s < curwin->w_leftcol) { + retval = TRUE; + if (coladvance(e + 1) == FAIL) { /* there isn't another character */ + curwin->w_leftcol = s; /* adjust w_leftcol instead */ + changed_cline_bef_curs(); + } + } + + if (retval) + curwin->w_set_curswant = TRUE; + redraw_later(NOT_VALID); + return retval; +} + +int gchar_cursor(void) +{ + if (has_mbyte) + return (*mb_ptr2char)(ml_get_cursor()); + return (int)*ml_get_cursor(); +} + +/* + * Write a character at the current cursor position. + * It is directly written into the block. + */ +void pchar_cursor(int c) +{ + *(ml_get_buf(curbuf, curwin->w_cursor.lnum, TRUE) + + curwin->w_cursor.col) = c; +} + +/* + * Return pointer to cursor line. + */ +char_u *ml_get_curline(void) +{ + return ml_get_buf(curbuf, curwin->w_cursor.lnum, FALSE); +} + +/* + * Return pointer to cursor position. + */ +char_u *ml_get_cursor(void) +{ + return ml_get_buf(curbuf, curwin->w_cursor.lnum, FALSE) + + curwin->w_cursor.col; +} + |