/* vi:set ts=8 sts=4 sw=4 noet:

*

* VIM - Vi IMproved by Bram Moolenaar

*

* Do ":help uganda" in Vim to read copying and usage conditions.

* Do ":help credits" in Vim to see a list of people who contributed.

* See README.txt for an overview of the Vim source code.

*/

/*

* drawline.c: Functions for drawing window lines on the screen.

* This is the middle level, drawscreen.c is the higher level and screen.c the

* lower level.

*/

#include "vim.h"

/*

* Get the 'listchars' "extends" characters to use for "wp", or NUL if it

* shouldn't be used.

*/

static int

get_lcs_ext(win_T *wp)

{

if (wp->w_p_wrap)

// Line never continues beyond the right of the screen with 'wrap'.

return NUL;

if (wp->w_p_wrap_flags & P_INSECURE)

// If 'nowrap' was set from a modeline, forcibly use '>'.

return '>';

return wp->w_p_list ? wp->w_lcs_chars.ext : NUL;

}

#ifdef FEAT_SYN_HL

/*

* Advance **color_cols and return TRUE when there are columns to draw.

*/

static int

advance_color_col(int vcol, int **color_cols)

{

while (**color_cols >= 0 && vcol > **color_cols)

++*color_cols;

return (**color_cols >= 0);

}

#endif

#ifdef FEAT_SYN_HL

/*

* Used when 'cursorlineopt' contains "screenline": compute the margins between

* which the highlighting is used.

*/

static void

margin_columns_win(win_T *wp, int *left_col, int *right_col)

{

// cache previous calculations depending on w_virtcol

static int saved_w_virtcol;

static win_T *prev_wp;

static int prev_width1;

static int prev_width2;

static int prev_left_col;

static int prev_right_col;

int cur_col_off = win_col_off(wp);

int width1;

int width2;

width1 = wp->w_width - cur_col_off;

width2 = width1 + win_col_off2(wp);

if (saved_w_virtcol == wp->w_virtcol && prev_wp == wp

&& prev_width1 == width1 && prev_width2 == width2)

{

*right_col = prev_right_col;

*left_col = prev_left_col;

return;

}

*left_col = 0;

*right_col = width1;

if (wp->w_virtcol >= (colnr_T)width1 && width2 > 0)

*right_col = width1 + ((wp->w_virtcol - width1) / width2 + 1) * width2;

if (wp->w_virtcol >= (colnr_T)width1 && width2 > 0)

*left_col = (wp->w_virtcol - width1) / width2 * width2 + width1;

// cache values

prev_left_col = *left_col;

prev_right_col = *right_col;

prev_wp = wp;

prev_width1 = width1;

prev_width2 = width2;

saved_w_virtcol = wp->w_virtcol;

}

#endif

#if defined(FEAT_SIGNS) || defined(FEAT_QUICKFIX) \

|| defined(FEAT_SYN_HL) || defined(FEAT_DIFF)

// using an attribute for the whole line

# define LINE_ATTR

#endif

// structure with variables passed between win_line() and other functions

typedef struct {

int draw_state; // what to draw next

linenr_T lnum; // line number to be drawn

int startrow; // first row in the window to be drawn

int row; // row in the window, excl w_winrow

int screen_row; // row on the screen, incl w_winrow

long vcol; // virtual column, before wrapping

int col; // visual column on screen, after wrapping

#ifdef FEAT_CONCEAL

int boguscols; // nonexistent columns added to "col" to force

// wrapping

int vcol_off_co; // offset for concealed characters

#endif

int vcol_off_tp; // offset for virtual text

#ifdef FEAT_SYN_HL

int draw_color_col; // highlight colorcolumn

int *color_cols; // pointer to according columns array

#endif

int eol_hl_off; // 1 if highlighted char after EOL

unsigned off; // offset in ScreenLines/ScreenAttrs

int win_attr; // background for the whole window, except

// margins and "~" lines.

#ifdef FEAT_SYN_HL

int cul_attr; // set when 'cursorline' active

#endif

#ifdef LINE_ATTR

int line_attr; // for the whole line, includes 'cursorline'

#endif

int screen_line_flags; // flags for screen_line()

int fromcol; // start of inverting

int tocol; // end of inverting

#ifdef FEAT_LINEBREAK

long vcol_sbr; // virtual column after showbreak

int need_showbreak; // overlong line, skipping first x chars

int dont_use_showbreak; // do not use 'showbreak'

#endif

#ifdef FEAT_PROP_POPUP

int text_prop_above_count;

#endif

// TRUE when 'cursorlineopt' has "screenline" and cursor is in this line

int cul_screenline;

int char_attr; // attributes for the next character

int n_extra; // number of extra bytes

char_u *p_extra; // string of extra chars, plus NUL, only used

// when c_extra and c_final are NUL

char_u *p_extra_free; // p_extra buffer that needs to be freed

int extra_attr; // attributes for p_extra, should be combined

// with win_attr if needed

int n_attr_skip; // chars to skip before using extra_attr

int c_extra; // extra chars, all the same

int c_final; // final char, mandatory if set

int extra_for_textprop; // n_extra set for textprop

int start_extra_for_textprop; // extra_for_textprop was just set

// saved "extra" items for when draw_state becomes WL_LINE (again)

int saved_n_extra;

char_u *saved_p_extra;

char_u *saved_p_extra_free;

int saved_extra_attr;

int saved_n_attr_skip;

int saved_extra_for_textprop;

int saved_c_extra;

int saved_c_final;

int saved_char_attr;

char_u extra[NUMBUFLEN + MB_MAXBYTES];

// "%ld " and 'fdc' must fit in here, as well

// any text sign

#ifdef FEAT_DIFF

hlf_T diff_hlf; // type of diff highlighting

#endif

int filler_lines; // nr of filler lines to be drawn

int filler_todo; // nr of filler lines still to do + 1

#ifdef FEAT_SIGNS

sign_attrs_T sattr;

#endif

#ifdef FEAT_LINEBREAK

// do consider wrapping in linebreak mode only after encountering

// a non whitespace char

int need_lbr;

#endif

} winlinevars_T;

// draw_state values for items that are drawn in sequence:

#define WL_START 0 // nothing done yet, must be zero

#define WL_CMDLINE (WL_START + 1) // cmdline window column

#ifdef FEAT_FOLDING

# define WL_FOLD (WL_CMDLINE + 1) // 'foldcolumn'

#else

# define WL_FOLD WL_CMDLINE

#endif

#ifdef FEAT_SIGNS

# define WL_SIGN (WL_FOLD + 1) // column for signs

#else

# define WL_SIGN WL_FOLD // column for signs

#endif

#define WL_NR (WL_SIGN + 1) // line number

#ifdef FEAT_LINEBREAK

# define WL_BRI (WL_NR + 1) // 'breakindent'

#else

# define WL_BRI WL_NR

#endif

#if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF)

# define WL_SBR (WL_BRI + 1) // 'showbreak' or 'diff'

#else

# define WL_SBR WL_BRI

#endif

#define WL_LINE (WL_SBR + 1) // text in the line

#if defined(FEAT_SIGNS) || defined(FEAT_FOLDING)

/*

* Return TRUE if CursorLineSign / CursorLineFold highlight is to be used.

* This depends only on 'cursorline', not on 'cursorlineopt'.

*/

static int

use_cursor_line_highlight(win_T *wp, linenr_T lnum)

{

return wp->w_p_cul

&& lnum == wp->w_cursor.lnum;

}

#endif

#ifdef FEAT_FOLDING

/*

* Setup for drawing the 'foldcolumn', if there is one.

*/

static void

handle_foldcolumn(win_T *wp, winlinevars_T *wlv)

{

int fdc = compute_foldcolumn(wp, 0);

if (fdc <= 0)

return;

// Allocate a buffer, "wlv->extra[]" may already be in use.

vim_free(wlv->p_extra_free);

wlv->p_extra_free = alloc(MAX_MCO * fdc + 1);

if (wlv->p_extra_free == NULL)

return;

wlv->n_extra = (int)fill_foldcolumn(wlv->p_extra_free,

wp, FALSE, wlv->lnum);

wlv->p_extra_free[wlv->n_extra] = NUL;

wlv->p_extra = wlv->p_extra_free;

wlv->c_extra = NUL;

wlv->c_final = NUL;

if (use_cursor_line_highlight(wp, wlv->lnum))

wlv->char_attr = hl_combine_attr(get_win_attr(wp), HL_ATTR(HLF_CLF));

else

wlv->char_attr = hl_combine_attr(get_win_attr(wp), HL_ATTR(HLF_FC));

}

#endif

#ifdef FEAT_SIGNS

/*

* Get information needed to display the sign in line "wlv->lnum" in window

* "wp".

* If "nrcol" is TRUE, the sign is going to be displayed in the number column.

* Otherwise the sign is going to be displayed in the sign column.

*/

static void

get_sign_display_info(

int nrcol,

win_T *wp,

winlinevars_T *wlv)

{

int text_sign;

# ifdef FEAT_SIGN_ICONS

int icon_sign;

# endif

// Draw two cells with the sign value or blank.

wlv->c_extra = ' ';

wlv->c_final = NUL;

if (nrcol)

wlv->n_extra = number_width(wp) + 1;

else

{

if (use_cursor_line_highlight(wp, wlv->lnum))

wlv->char_attr = hl_combine_attr(get_win_attr(wp), HL_ATTR(HLF_CLS));

else

wlv->char_attr = hl_combine_attr(get_win_attr(wp), HL_ATTR(HLF_SC));

wlv->n_extra = 2;

}

if (wlv->row == wlv->startrow

# ifdef FEAT_DIFF

+ wlv->filler_lines && wlv->filler_todo <= 0

# endif

)

{

text_sign = (wlv->sattr.sat_text != NULL) ? wlv->sattr.sat_typenr : 0;

# ifdef FEAT_SIGN_ICONS

icon_sign = (wlv->sattr.sat_icon != NULL) ? wlv->sattr.sat_typenr : 0;

if (gui.in_use && icon_sign != 0)

{

// Use the image in this position.

if (nrcol)

{

wlv->c_extra = NUL;

wlv->n_extra = vim_snprintf((char *)wlv->extra, sizeof(wlv->extra),

"%-*c ", number_width(wp), SIGN_BYTE);

wlv->p_extra = wlv->extra;

}

else

wlv->c_extra = SIGN_BYTE;

# ifdef FEAT_NETBEANS_INTG

if (netbeans_active() && (buf_signcount(wp->w_buffer, wlv->lnum)

> 1))

{

if (nrcol)

{

wlv->c_extra = NUL;

wlv->n_extra = vim_snprintf((char *)wlv->extra, sizeof(wlv->extra),

"%-*c ", number_width(wp), MULTISIGN_BYTE);

wlv->p_extra = wlv->extra;

}

else

wlv->c_extra = MULTISIGN_BYTE;

}

# endif

wlv->c_final = NUL;

wlv->char_attr = icon_sign;

}

else

# endif

if (text_sign != 0)

{

wlv->p_extra = wlv->sattr.sat_text;

if (wlv->p_extra != NULL)

{

if (nrcol)

{

int width = number_width(wp) - 2;

vim_memset(wlv->extra, ' ', width);

wlv->n_extra = width;

wlv->n_extra += vim_snprintf((char *)wlv->extra + width,

sizeof(wlv->extra) - width, "%s ", wlv->p_extra);

wlv->p_extra = wlv->extra;

}

else

wlv->n_extra = (int)STRLEN(wlv->p_extra);

wlv->c_extra = NUL;

wlv->c_final = NUL;

}

if (use_cursor_line_highlight(wp, wlv->lnum)

&& wlv->sattr.sat_culhl > 0)

wlv->char_attr = wlv->sattr.sat_culhl;

else

wlv->char_attr = wlv->sattr.sat_texthl;

}

}

}

#endif

/*

* Display the absolute or relative line number. After the first row fill with

* blanks when the 'n' flag isn't in 'cpo'.

*/

static void

handle_lnum_col(

win_T *wp,

winlinevars_T *wlv,

int sign_present UNUSED,

int num_attr UNUSED)

{

int has_cpo_n = vim_strchr(p_cpo, CPO_NUMCOL) != NULL;

int lnum_row = wlv->startrow + wlv->filler_lines

#ifdef FEAT_PROP_POPUP

+ wlv->text_prop_above_count

#endif

;

if ((wp->w_p_nu || wp->w_p_rnu)

&& (wlv->row <= lnum_row || !has_cpo_n)

// there is no line number in a wrapped line when "n" is in

// 'cpoptions', but 'breakindent' assumes it anyway.

&& !((has_cpo_n

#ifdef FEAT_LINEBREAK

&& !wp->w_p_bri

#endif

) && wp->w_skipcol > 0 && wlv->lnum == wp->w_topline))

{

#ifdef FEAT_SIGNS

// If 'signcolumn' is set to 'number' and a sign is present

// in 'lnum', then display the sign instead of the line

// number.

if ((*wp->w_p_scl == 'n' && *(wp->w_p_scl + 1) == 'u') && sign_present

&& wlv->sattr.sat_text != NULL)

get_sign_display_info(TRUE, wp, wlv);

else

#endif

{

// Draw the line number (empty space after wrapping).

// When there are text properties above the line put the line number

// below them.

if (wlv->row == lnum_row

&& (wp->w_skipcol == 0 || wlv->row > 0

|| (wp->w_p_nu && wp->w_p_rnu)))

{

long num;

char *fmt = "%*ld ";

if (wp->w_p_nu && !wp->w_p_rnu)

// 'number' + 'norelativenumber'

num = (long)wlv->lnum;

else

{

// 'relativenumber', don't use negative numbers

num = labs((long)get_cursor_rel_lnum(wp, wlv->lnum));

if (num == 0 && wp->w_p_nu && wp->w_p_rnu)

{

// 'number' + 'relativenumber'

num = wlv->lnum;

fmt = "%-*ld ";

}

}

vim_snprintf((char *)wlv->extra, sizeof(wlv->extra), fmt, number_width(wp), num);

if (wp->w_skipcol > 0 && wlv->startrow == 0)

for (wlv->p_extra = wlv->extra; *wlv->p_extra == ' ';

++wlv->p_extra)

*wlv->p_extra = '-';

#ifdef FEAT_RIGHTLEFT

if (wp->w_p_rl) // reverse line numbers

{

char_u *p1, *p2;

int t;

// like rl_mirror(), but keep the space at the end

p2 = skipwhite(wlv->extra);

p2 = skiptowhite(p2) - 1;

for (p1 = skipwhite(wlv->extra); p1 < p2; ++p1, --p2)

{

t = *p1;

*p1 = *p2;

*p2 = t;

}

}

#endif

wlv->p_extra = wlv->extra;

wlv->c_extra = NUL;

wlv->c_final = NUL;

}

else

{

wlv->c_extra = ' ';

wlv->c_final = NUL;

}

wlv->n_extra = number_width(wp) + 1;

wlv->char_attr = hl_combine_attr(get_win_attr(wp), HL_ATTR(HLF_N));

#ifdef FEAT_SYN_HL

// When 'cursorline' is set highlight the line number of

// the current line differently.

// When 'cursorlineopt' does not have "line" only

// highlight the line number itself.

// TODO: Can we use CursorLine instead of CursorLineNr

// when CursorLineNr isn't set?

if (wp->w_p_cul

&& wlv->lnum == wp->w_cursor.lnum

&& (wp->w_p_culopt_flags & CULOPT_NBR)

&& (wlv->row == lnum_row

|| (wlv->row > lnum_row

&& (wp->w_p_culopt_flags & CULOPT_LINE))))

wlv->char_attr = hl_combine_attr(get_win_attr(wp), HL_ATTR(HLF_CLN));

#endif

if (wp->w_p_rnu && wlv->lnum < wp->w_cursor.lnum

&& HL_ATTR(HLF_LNA) != 0)

// Use LineNrAbove

wlv->char_attr = hl_combine_attr(get_win_attr(wp), HL_ATTR(HLF_LNA));

if (wp->w_p_rnu && wlv->lnum > wp->w_cursor.lnum

&& HL_ATTR(HLF_LNB) != 0)

// Use LineNrBelow

wlv->char_attr = hl_combine_attr(get_win_attr(wp), HL_ATTR(HLF_LNB));

}

#ifdef FEAT_SIGNS

if (num_attr)

wlv->char_attr = num_attr;

#endif

}

}

#ifdef FEAT_LINEBREAK

static void

handle_breakindent(win_T *wp, winlinevars_T *wlv)

{

if (wp->w_briopt_sbr && wlv->draw_state == WL_BRI - 1

&& *get_showbreak_value(wp) != NUL)

// draw indent after showbreak value

wlv->draw_state = WL_BRI;

else if (wp->w_briopt_sbr && wlv->draw_state == WL_SBR)

// After the showbreak, draw the breakindent

wlv->draw_state = WL_BRI - 1;

// draw 'breakindent': indent wrapped text accordingly

if (wlv->draw_state == WL_BRI - 1)

{

wlv->draw_state = WL_BRI;

// if wlv->need_showbreak is set, breakindent also applies

if (wp->w_p_bri && (wlv->row > wlv->startrow

# ifdef FEAT_DIFF

+ wlv->filler_lines

# endif

|| wlv->need_showbreak)

# ifdef FEAT_PROP_POPUP

&& !wlv->dont_use_showbreak

# endif

)

{

wlv->char_attr = 0;

# ifdef FEAT_DIFF

if (wlv->diff_hlf != (hlf_T)0)

wlv->char_attr = HL_ATTR(wlv->diff_hlf);

# endif

wlv->p_extra = NULL;

wlv->c_extra = ' ';

wlv->c_final = NUL;

wlv->n_extra = get_breakindent_win(wp,

ml_get_buf(wp->w_buffer, wlv->lnum, FALSE));

if (wlv->row == wlv->startrow)

{

wlv->n_extra -= win_col_off2(wp);

if (wlv->n_extra < 0)

wlv->n_extra = 0;

}

// Correct start of highlighted area for 'breakindent',

if (wlv->fromcol >= wlv->vcol

&& wlv->fromcol < wlv->vcol + wlv->n_extra)

wlv->fromcol = wlv->vcol + wlv->n_extra;

// Correct end of highlighted area for 'breakindent',

// required when 'linebreak' is also set.

if (wlv->tocol == wlv->vcol)

wlv->tocol += wlv->n_extra;

}

if (wp->w_skipcol > 0 && wlv->startrow == 0 && wp->w_p_wrap

&& wp->w_briopt_sbr)

wlv->need_showbreak = FALSE;

}

}

#endif

#if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF)

static void

handle_showbreak_and_filler(win_T *wp, winlinevars_T *wlv)

{

# ifdef FEAT_DIFF

if (wlv->filler_todo > 0)

{

// Draw "deleted" diff line(s).

if (char2cells(wp->w_fill_chars.diff) > 1)

{

wlv->c_extra = '-';

wlv->c_final = NUL;

}

else

{

wlv->c_extra = wp->w_fill_chars.diff;

wlv->c_final = NUL;

}

# ifdef FEAT_RIGHTLEFT

if (wp->w_p_rl)

wlv->n_extra = wlv->col + 1;

else

# endif

wlv->n_extra = wp->w_width - wlv->col;

wlv->char_attr = HL_ATTR(HLF_DED);

}

# endif

# ifdef FEAT_LINEBREAK

char_u *sbr = get_showbreak_value(wp);

if (*sbr != NUL && wlv->need_showbreak)

{

// Draw 'showbreak' at the start of each broken line.

wlv->p_extra = sbr;

wlv->c_extra = NUL;

wlv->c_final = NUL;

wlv->n_extra = (int)STRLEN(sbr);

wlv->vcol_sbr = wlv->vcol + MB_CHARLEN(sbr);

// Correct start of highlighted area for 'showbreak'.

if (wlv->fromcol >= wlv->vcol && wlv->fromcol < wlv->vcol_sbr)

wlv->fromcol = wlv->vcol_sbr;

// Correct end of highlighted area for 'showbreak',

// required when 'linebreak' is also set.

if (wlv->tocol == wlv->vcol)

wlv->tocol = wlv->vcol_sbr;

// combine 'showbreak' with HLF_WIN

wlv->char_attr = hl_combine_attr(wlv->win_attr, HL_ATTR(HLF_AT));

# ifdef FEAT_SYN_HL

// combine 'showbreak' with 'cursorline'

if (wlv->cul_attr != 0)

wlv->char_attr = hl_combine_attr(wlv->char_attr, wlv->cul_attr);

# endif

}

if (wp->w_skipcol == 0 || wlv->startrow > 0 || !wp->w_p_wrap

|| !wp->w_briopt_sbr)

wlv->need_showbreak = FALSE;

# endif

}

#endif

#if defined(FEAT_PROP_POPUP)

/*

* Return the cell size of virtual text after truncation.

*/

static int

textprop_size_after_trunc(

win_T *wp,

int flags, // TP_FLAG_ALIGN_*

int added,

int padding,

char_u *text,

int *n_used_ptr)

{

int space = (flags & (TP_FLAG_ALIGN_BELOW | TP_FLAG_ALIGN_ABOVE))

? wp->w_width - win_col_off(wp) : added;

int strsize = 0;

char_u *p;

// if the remaining size is too small and 'wrap' is set we wrap anyway and

// use the next line

if (space < PROP_TEXT_MIN_CELLS && wp->w_p_wrap)

space += wp->w_width;

if (flags & (TP_FLAG_ALIGN_BELOW | TP_FLAG_ALIGN_ABOVE))

space -= padding;

for (p = text; *p != NUL; p += (*mb_ptr2len)(p))

{

int clen = ptr2cells(p);

if (strsize + clen > space)

break;

strsize += clen;

}

*n_used_ptr = (int)(p - text);

return strsize;

}

/*

* Take care of padding, right-align and truncation of virtual text after a

* line.

* if "n_attr" is not NULL then "n_extra" and "p_extra" are adjusted for any

* padding, right-align and truncation. Otherwise only the size is computed.

* When "n_attr" is NULL returns the number of screen cells used.

* Otherwise returns TRUE when drawing continues on the next line.

*/

int

text_prop_position(

win_T *wp,

textprop_T *tp,

int vcol, // current text column

int scr_col, // current screen column

int *n_extra, // nr of bytes for virtual text

char_u **p_extra, // virtual text

int *n_attr, // attribute cells, NULL if not used

int *n_attr_skip, // cells to skip attr, NULL if not used

int do_skip) // skip_cells is not zero

{

int right = (tp->tp_flags & TP_FLAG_ALIGN_RIGHT);

int above = (tp->tp_flags & TP_FLAG_ALIGN_ABOVE);

int below = (tp->tp_flags & TP_FLAG_ALIGN_BELOW);

int wrap = tp->tp_col < MAXCOL || (tp->tp_flags & TP_FLAG_WRAP);

int padding = tp->tp_col == MAXCOL ? tp->tp_padleft : 0;

int col_with_padding = scr_col + (below ? 0 : padding);

int room = wp->w_width - col_with_padding;

int before = room; // spaces before the text

int after = 0; // spaces after the text

int n_used = *n_extra;

char_u *l = NULL;

int strsize = vim_strsize(*p_extra);

int cells = wrap ? strsize : textprop_size_after_trunc(wp,

tp->tp_flags, before, padding, *p_extra, &n_used);

if (wrap || right || above || below || padding > 0 || n_used < *n_extra)

{

int col_off = win_col_off(wp) - win_col_off2(wp);

if (above)

{

before = 0;

after = wp->w_width - cells - win_col_off(wp) - padding;

if (after < 0)

{

// text "above" has too much padding to fit

padding += after;

after = 0;

}

}

else

{

// Right-align: fill with before

if (right)

before -= cells;

// Below-align: empty line add one character

if (below && vcol == 0 && col_with_padding == col_off

&& wp->w_width - col_off == before)

col_with_padding += 1;

if (before < 0

|| !(right || below)

|| (below ? (col_with_padding <= col_off || !wp->w_p_wrap)

: (n_used < *n_extra)))

{

if (right && (wrap

|| (room < PROP_TEXT_MIN_CELLS && wp->w_p_wrap)))

{

// right-align on next line instead of wrapping if possible

before = wp->w_width - col_off - strsize + room;

if (before < 0)

before = 0;

else

n_used = *n_extra;

}

else if (below && before > vcol && do_skip)

before -= vcol;

else

before = 0;

}

}

// With 'nowrap' add one to show the "extends" character if needed (it

// doesn't show if the text just fits).

if (n_used < *n_extra && get_lcs_ext(wp) != NUL)

++n_used;

// add 1 for NUL, 2 for when '…' is used

if (n_attr != NULL)

l = alloc(n_used + before + after + (padding > 0 ? padding : 0) + 3);

if (n_attr == NULL || l != NULL)

{

int off = 0;

if (n_attr != NULL)

{

vim_memset(l, ' ', before);

off += before;

if (padding > 0)

{

vim_memset(l + off, ' ', padding);

off += padding;

}

vim_strncpy(l + off, *p_extra, n_used);

off += n_used;

}

else

{

off = before + after + padding + n_used;

cells += before + after + padding;

}

if (n_attr != NULL)

{

if (n_used < *n_extra && wp->w_p_wrap)

{

char_u *lp = l + off - 1;

if (has_mbyte)

{

char_u buf[MB_MAXBYTES + 1];

char_u *cp = buf;

// change the last character to '…', converted to the

// current 'encoding'

STRCPY(buf, "…");

if (!enc_utf8)

{

vimconv_T vc;

vc.vc_type = CONV_NONE;

convert_setup(&vc, (char_u *)"utf-8", p_enc);

if (vc.vc_type != CONV_NONE)

{

cp = string_convert(&vc, buf, NULL);

if (cp == NULL)

{

// when conversion fails use '>'

cp = buf;

STRCPY(buf, ">");

}

convert_setup(&vc, NULL, NULL);

}

}

lp -= (*mb_ptr2cells)(cp) - 1;

lp -= (*mb_head_off)(l, lp);

STRCPY(lp, cp);

n_used = lp - l + 3 - before - padding;

if (cp != buf)

vim_free(cp);

}

else

// change last character to '>'

*lp = '>';

}

else if (after > 0)

{

vim_memset(l + off, ' ', after);

l[off + after] = NUL;

}

*p_extra = l;

*n_extra = n_used + before + after + padding;

*n_attr = mb_charlen(*p_extra);

// n_attr_skip will not be decremented before draw_state is

// WL_LINE

*n_attr_skip = before + (padding > 0 ? padding : 0);

*n_attr -= *n_attr_skip;

if (above)

*n_attr -= after;

}

}

}

if (n_attr == NULL)

return cells;

return (below && col_with_padding > win_col_off(wp) && !wp->w_p_wrap);

}

# if defined(FEAT_LINEBREAK)

/*

* no 'showbreak' before "below" text property

* or after "above" or "right" text property

*/

int

text_prop_no_showbreak(textprop_T *tp)

{

int right = (tp->tp_flags & TP_FLAG_ALIGN_RIGHT);

int above = (tp->tp_flags & TP_FLAG_ALIGN_ABOVE);

int below = (tp->tp_flags & TP_FLAG_ALIGN_BELOW);

int wrap = tp->tp_col < MAXCOL || (tp->tp_flags & TP_FLAG_WRAP);

return (right || above || below || !wrap);

}

# endif

#endif

/*

* Call screen_line() using values from "wlv".

* Also takes care of putting "<<<" on the first line for 'smoothscroll'

* when 'showbreak' is not set.

* When "clear_end" is TRUE clear until the end of the screen line.

*/

static void

wlv_screen_line(win_T *wp, winlinevars_T *wlv, int clear_end)

{

if (wlv->row == 0 && wp->w_skipcol > 0

#if defined(FEAT_LINEBREAK)

// do not overwrite the 'showbreak' text with "<<<"

&& *get_showbreak_value(wp) == NUL

#endif

// do not overwrite the 'listchars' "precedes" text with "<<<"

&& !(wp->w_p_list && wp->w_lcs_chars.prec != 0))

{

int off = (int)(current_ScreenLine - ScreenLines);

int max_off = off + screen_Columns;

int skip = 0;

if (wp->w_p_nu && wp->w_p_rnu)

// Do not overwrite the line number, change "123 text" to

// "123<<<xt".

while (skip < wp->w_width && VIM_ISDIGIT(ScreenLines[off]))

{

++off;

++skip;

}

for (int i = 0; i < 3 && i + skip < wp->w_width; ++i)

{

if ((*mb_off2cells)(off, max_off) > 1)

// When the first half of a double-width character is

// overwritten, change the second half to a space.

ScreenLines[off + 1] = ' ';

ScreenLines[off] = '<';

if (enc_utf8)

ScreenLinesUC[off] = 0;

ScreenAttrs[off] = HL_ATTR(HLF_AT);

++off;

}

}

screen_line(wp, wlv->screen_row, wp->w_wincol, wlv->col,

clear_end ? wp->w_width : -wp->w_width,

wlv->vcol - 1, wlv->screen_line_flags);

}

/*

* Called when finished with the line: draw the screen line and handle any

* highlighting until the right of the window.

*/

static void

draw_screen_line(win_T *wp, winlinevars_T *wlv)

{

#ifdef FEAT_SYN_HL

long v;

int wcol;

// Highlight 'cursorcolumn' & 'colorcolumn' past end of the line.

if (wp->w_p_wrap)

v = wlv->startrow == 0 ? wp->w_skipcol : 0;

else

v = wp->w_leftcol;

wcol =

# ifdef FEAT_RIGHTLEFT

wp->w_p_rl ? wp->w_width - wlv->col - 1 :

# endif

wlv->col;

// check if line ends before left margin

if (wlv->vcol < v + wcol - win_col_off(wp))

wlv->vcol = v + wcol - win_col_off(wp);

# ifdef FEAT_CONCEAL

// Get rid of the boguscols now, we want to draw until the right

// edge for 'cursorcolumn'.

wlv->col -= wlv->boguscols;

wlv->boguscols = 0;

# define VCOL_HLC (wlv->vcol - wlv->vcol_off_co - wlv->vcol_off_tp)

# else

# define VCOL_HLC (wlv->vcol - wlv->vcol_off_tp)

# endif

if (wlv->draw_color_col)

wlv->draw_color_col = advance_color_col(VCOL_HLC, &wlv->color_cols);

if (((wp->w_p_cuc

&& (int)wp->w_virtcol >= VCOL_HLC - wlv->eol_hl_off

&& (int)wp->w_virtcol <

(long)wp->w_width * (wlv->row - wlv->startrow + 1) + v

&& wlv->lnum != wp->w_cursor.lnum)

|| wlv->draw_color_col

# ifdef LINE_ATTR

|| wlv->line_attr != 0

# endif

|| wlv->win_attr != 0))

{

int rightmost_vcol = 0;

int i;

if (wp->w_p_cuc)

rightmost_vcol = wp->w_virtcol;

if (wlv->draw_color_col)

// determine rightmost colorcolumn to possibly draw

for (i = 0; wlv->color_cols[i] >= 0; ++i)

if (rightmost_vcol < wlv->color_cols[i])

rightmost_vcol = wlv->color_cols[i];

while (

# ifdef FEAT_RIGHTLEFT

wp->w_p_rl ? (wlv->col >= 0) :

# endif

(wlv->col < wp->w_width))

{

ScreenLines[wlv->off] = ' ';

if (enc_utf8)

ScreenLinesUC[wlv->off] = 0;

if (wlv->draw_color_col)

wlv->draw_color_col = advance_color_col(

VCOL_HLC, &wlv->color_cols);

int attr = wlv->win_attr;

# ifdef LINE_ATTR

if (wlv->line_attr != 0)

attr = hl_combine_attr(attr, wlv->line_attr);

# endif

if (wp->w_p_cuc && VCOL_HLC == (long)wp->w_virtcol

&& wlv->lnum != wp->w_cursor.lnum)

attr = hl_combine_attr(attr, HL_ATTR(HLF_CUC));

else if (wlv->draw_color_col && VCOL_HLC == *wlv->color_cols)

attr = hl_combine_attr(attr, HL_ATTR(HLF_MC));

ScreenAttrs[wlv->off] = attr;

ScreenCols[wlv->off] = wlv->vcol;

# ifdef FEAT_RIGHTLEFT

if (wp->w_p_rl)

{

--wlv->off;