Blog: Better line wrapping in Vim, 5th iteration: vim-7.3.285-breakindent.patch

File vim-7.3.285-breakindent.patch, 31.0 KB (added by retracile, 13 years ago)

breakindent patch for vim 7.3.285

  • runtime/doc/eval.txt 

    # HG changeset patch
# User Eli Carter <elicarter@retracile.net>
# Date 1314148805 18000
# Node ID fd4d58423e6bc958dde29184da411d8b6bf6facf
# Parent  7b50afd3103733ad0f70acc655cb9295fd67ceaf
breakindent patch updated for 7.3.285 by Taylor Hedberg

diff -r 7b50afd31037 -r fd4d58423e6b runtime/doc/eval.txt
    a b  
    62086208keymap                  Compiled with 'keymap' support.
    62096209langmap                 Compiled with 'langmap' support.
    62106210libcall                 Compiled with |libcall()| support.
    6211 linebreak               Compiled with 'linebreak', 'breakat' and 'showbreak'
    6212                         support.
     6211linebreak               Compiled with 'linebreak', 'breakat', 'showbreak' and
     6212                        'breakindent' support.
    62136213lispindent              Compiled with support for lisp indenting.
    62146214listcmds                Compiled with commands for the buffer list |:files|
    62156215                        and the argument list |arglist|.

  • runtime/doc/options.txt 

    diff -r 7b50afd31037 -r fd4d58423e6b runtime/doc/options.txt
    a b  
    11841184        break if 'linebreak' is on.  Only works for ASCII and also for 8-bit
    11851185        characters when 'encoding' is an 8-bit encoding.
    11861186
     1187       
     1188                                                *'breakindent'* *'bri'*
     1189'breakindent' 'bri'     boolean (default off)
     1190                        local to window
     1191                        {not in Vi}
     1192                        {not available when compiled without the |+linebreak|
     1193                        feature}
     1194        Every wrapped line will continue visually indented (same amount of
     1195        space as the beginning of that line), thus preserving horizontal blocks
     1196        of text.
     1197
     1198                                                *'breakindentmin'* *'brimin'*
     1199'breakindentmin' 'brimin' number (default 20)
     1200                        local to window
     1201                        {not in Vi}
     1202                        {not available when compiled without the |+linebreak|
     1203                        feature}
     1204        Minimum text width that will be kept after applying 'breakindent',
     1205        even if the resulting text should normally be narrower. This prevents
     1206        text indented almost to the right window border oocupying lot of
     1207        vertical space when broken.
     1208
     1209                                                *'breakindentshift'* *'brishift'*
     1210'breakindentshift' 'brishift' number (default 20)
     1211                        local to window
     1212                        {not in Vi}
     1213                        {not available when compiled without the |+linebreak|
     1214                        feature}
     1215        After applying 'breakindent', wrapped line beginning will be shift by
     1216        given number of characters. It permits dynamic French paragraph
     1217        indentation (negative) or emphasizing the line continuation
     1218        (positive).
     1219
    11871220                                                *'browsedir'* *'bsdir'*
    11881221'browsedir' 'bsdir'     string  (default: "last")
    11891222                        global
    … …  
    44834516                        {not in Vi}
    44844517                        {not available when compiled without the |+linebreak|
    44854518                        feature}
    4486         If on Vim will wrap long lines at a character in 'breakat' rather
     4519        If on, Vim will wrap long lines at a character in 'breakat' rather
    44874520        than at the last character that fits on the screen.  Unlike
    44884521        'wrapmargin' and 'textwidth', this does not insert <EOL>s in the file,
    4489         it only affects the way the file is displayed, not its contents.  The
    4490         value of 'showbreak' is used to put in front of wrapped lines.
    4491         This option is not used when the 'wrap' option is off or 'list' is on.
     4522        it only affects the way the file is displayed, not its contents.
     4523        If 'breakindent' is set, line is visually indented. Then, the value
     4524        of 'showbreak' is used to put in front of wrapped lines. This option
     4525        is not used when the 'wrap' option is off or 'list' is on.
    44924526        Note that <Tab> characters after an <EOL> are mostly not displayed
    44934527        with the right amount of white space.
    44944528

  • runtime/doc/tags 

    diff -r 7b50afd31037 -r fd4d58423e6b runtime/doc/tags
    a b  
    9090'bl'    options.txt     /*'bl'*
    9191'bomb'  options.txt     /*'bomb'*
    9292'breakat'       options.txt     /*'breakat'*
     93'breakindent'   options.txt     /*'breakindent'*
     94'breakindentmin'        options.txt     /*'breakindentmin'*
     95'breakindentshift'      options.txt     /*'breakindentshift'*
     96'bri'   options.txt     /*'bri'*
     97'brimin'        options.txt     /*'brimin'*
     98'brishift'      options.txt     /*'brishift'*
    9399'brk'   options.txt     /*'brk'*
    94100'browsedir'     options.txt     /*'browsedir'*
    95101'bs'    options.txt     /*'bs'*

  • runtime/optwin.vim 

    diff -r 7b50afd31037 -r fd4d58423e6b runtime/optwin.vim
    a b  
    322322call append("$", "linebreak\twrap long lines at a character in 'breakat'")
    323323call append("$", "\t(local to window)")
    324324call <SID>BinOptionL("lbr")
     325call append("$", "breakindent\tpreserve indentation in wrapped text")
     326call append("$", "\t(local to window)")
     327call <SID>BinOptionL("bri")
     328call append("$", "breakindentmin\tminimum text width after indent in 'breakindent'")
     329call append("$", "\t(local to window)")
     330call <SID>OptionL("brimin")
     331call append("$", "breakindentshift\tshift beginning of 'breakindent'ed line by this number of characters (negative left)")
     332call append("$", "\t(local to window)")
     333call <SID>OptionL("brishift")
    325334call append("$", "breakat\twhich characters might cause a line break")
    326335call <SID>OptionG("brk", &brk)
    327336call append("$", "showbreak\tstring to put before wrapped screen lines")

  • src/charset.c 

    diff -r 7b50afd31037 -r fd4d58423e6b src/charset.c
    a b  
    846846 * taking into account the size of a tab.
    847847 */
    848848    int
    849 linetabsize(s)
     849linetabsize(s, lnum)
    850850    char_u      *s;
     851    linenr_T    lnum;
    851852{
    852     return linetabsize_col(0, s);
     853    return linetabsize_col(0, s, lnum);
    853854}
    854855
    855856/*
    856857 * Like linetabsize(), but starting at column "startcol".
    857858 */
    858859    int
    859 linetabsize_col(startcol, s)
     860linetabsize_col(startcol, s, lnum)
    860861    int         startcol;
    861862    char_u      *s;
     863    linenr_T    lnum;
    862864{
    863865    colnr_T     col = startcol;
    864866
    865867    while (*s != NUL)
    866         col += lbr_chartabsize_adv(&s, col);
     868        col += lbr_chartabsize_adv(&s, col, lnum);
    867869    return (int)col;
    868870}
    869871
    … …  
    871873 * Like linetabsize(), but for a given window instead of the current one.
    872874 */
    873875    int
    874 win_linetabsize(wp, p, len)
     876win_linetabsize(wp, p, len, lnum)
    875877    win_T       *wp;
    876878    char_u      *p;
    877879    colnr_T     len;
     880    linenr_T    lnum;
    878881{
    879882    colnr_T     col = 0;
    880883    char_u      *s;
    881884
    882885    for (s = p; *s != NUL && (len == MAXCOL || s < p + len); mb_ptr_adv(s))
    883         col += win_lbr_chartabsize(wp, s, col, NULL);
     886        col += win_lbr_chartabsize(wp, s, col, NULL, lnum);
    884887    return (int)col;
    885888}
    886889
    … …  
    10091012 * like chartabsize(), but also check for line breaks on the screen
    10101013 */
    10111014    int
    1012 lbr_chartabsize(s, col)
     1015lbr_chartabsize(s, col, lnum)
    10131016    unsigned char       *s;
    10141017    colnr_T             col;
     1018    linenr_T            lnum;
    10151019{
    10161020#ifdef FEAT_LINEBREAK
    1017     if (!curwin->w_p_lbr && *p_sbr == NUL)
     1021    if (!curwin->w_p_lbr && *p_sbr == NUL && !curwin->w_p_bri)
    10181022    {
    10191023#endif
    10201024#ifdef FEAT_MBYTE
    … …  
    10241028        RET_WIN_BUF_CHARTABSIZE(curwin, curbuf, s, col)
    10251029#ifdef FEAT_LINEBREAK
    10261030    }
    1027     return win_lbr_chartabsize(curwin, s, col, NULL);
     1031    return win_lbr_chartabsize(curwin, s, col, NULL, lnum);
    10281032#endif
    10291033}
    10301034
    … …  
    10321036 * Call lbr_chartabsize() and advance the pointer.
    10331037 */
    10341038    int
    1035 lbr_chartabsize_adv(s, col)
     1039lbr_chartabsize_adv(s, col, lnum)
    10361040    char_u      **s;
    10371041    colnr_T     col;
     1042    linenr_T    lnum;
    10381043{
    10391044    int         retval;
    10401045
    1041     retval = lbr_chartabsize(*s, col);
     1046    retval = lbr_chartabsize(*s, col, lnum);
    10421047    mb_ptr_adv(*s);
    10431048    return retval;
    10441049}
    … …  
    10491054 * If "headp" not NULL, set *headp to the size of what we for 'showbreak'
    10501055 * string at start of line.  Warning: *headp is only set if it's a non-zero
    10511056 * value, init to 0 before calling.
     1057 *
     1058 * linenr argument needed if in visual highlighting and breakindent=on, then
     1059 * the line calculated is not current; if 0, normal functionality is preserved.
    10521060 */
    10531061    int
    1054 win_lbr_chartabsize(wp, s, col, headp)
     1062win_lbr_chartabsize(wp, s, col, headp, lnum)
    10551063    win_T       *wp;
    10561064    char_u      *s;
    10571065    colnr_T     col;
    10581066    int         *headp UNUSED;
     1067    linenr_T    lnum;
    10591068{
    10601069#ifdef FEAT_LINEBREAK
    10611070    int         c;
    … …  
    10741083    int         n;
    10751084
    10761085    /*
    1077      * No 'linebreak' and 'showbreak': return quickly.
     1086     * No 'linebreak' and 'showbreak' and 'breakindent': return quickly.
    10781087     */
    1079     if (!wp->w_p_lbr && *p_sbr == NUL)
     1088    if (!wp->w_p_lbr && !wp->w_p_bri && *p_sbr == NUL)
    10801089#endif
    10811090    {
    10821091#ifdef FEAT_MBYTE
    … …  
    11511160# endif
    11521161
    11531162    /*
    1154      * May have to add something for 'showbreak' string at start of line
     1163     * May have to add something for 'breakindent' and/or 'showbreak'
     1164     * string at start of line.
    11551165     * Set *headp to the size of what we add.
    11561166     */
    11571167    added = 0;
    1158     if (*p_sbr != NUL && wp->w_p_wrap && col != 0)
     1168    if ((*p_sbr != NUL || wp->w_p_bri) && wp->w_p_wrap && col != 0)
    11591169    {
    11601170        numberextra = win_col_off(wp);
    11611171        col += numberextra + mb_added;
    … …  
    11681178        }
    11691179        if (col == 0 || col + size > (colnr_T)W_WIDTH(wp))
    11701180        {
    1171             added = vim_strsize(p_sbr);
     1181            added = 0;
     1182            if (*p_sbr != NUL)
     1183                added += vim_strsize(p_sbr);
     1184            if (wp->w_p_bri)
     1185                added += get_breakindent_win(wp,lnum);
     1186
    11721187            if (tab_corr)
    11731188                size += (added / wp->w_buffer->b_p_ts) * wp->w_buffer->b_p_ts;
    11741189            else
    … …  
    12761291
    12771292    /*
    12781293     * This function is used very often, do some speed optimizations.
    1279      * When 'list', 'linebreak' and 'showbreak' are not set use a simple loop.
     1294     * When 'list', 'linebreak', 'showbreak' and 'breakindent' are not set
     1295     * use a simple loop.
    12801296     * Also use this when 'list' is set but tabs take their normal size.
    12811297     */
    12821298    if ((!wp->w_p_list || lcs_tab1 != NUL)
    12831299#ifdef FEAT_LINEBREAK
    1284             && !wp->w_p_lbr && *p_sbr == NUL
     1300            && !wp->w_p_lbr && *p_sbr == NUL && !wp->w_p_bri
    12851301#endif
    12861302       )
    12871303    {
    … …  
    13431359        {
    13441360            /* A tab gets expanded, depending on the current column */
    13451361            head = 0;
    1346             incr = win_lbr_chartabsize(wp, ptr, vcol, &head);
     1362            incr = win_lbr_chartabsize(wp, ptr, vcol, &head, pos->lnum);
    13471363            /* make sure we don't go past the end of the line */
    13481364            if (*ptr == NUL)
    13491365            {

  • src/edit.c 

    diff -r 7b50afd31037 -r fd4d58423e6b src/edit.c
    a b  
    398398        if (startln)
    399399            Insstart.col = 0;
    400400    }
    401     Insstart_textlen = (colnr_T)linetabsize(ml_get_curline());
     401    Insstart_textlen = (colnr_T)linetabsize(ml_get_curline(), Insstart.lnum);
    402402    Insstart_blank_vcol = MAXCOL;
    403403    if (!did_ai)
    404404        ai_col = 0;
    … …  
    18971897            else
    18981898#endif
    18991899                ++new_cursor_col;
    1900             vcol += lbr_chartabsize(ptr + new_cursor_col, (colnr_T)vcol);
     1900            vcol += lbr_chartabsize(ptr + new_cursor_col, (colnr_T)vcol, curwin->w_cursor.lnum);
    19011901        }
    19021902        vcol = last_vcol;
    19031903
    … …  
    65006500            ins_need_undo = FALSE;
    65016501        }
    65026502        Insstart = curwin->w_cursor;    /* new insertion starts here */
    6503         Insstart_textlen = (colnr_T)linetabsize(ml_get_curline());
     6503        Insstart_textlen = (colnr_T)linetabsize(ml_get_curline(), curwin->w_cursor.lnum);
    65046504        ai_col = 0;
    65056505#ifdef FEAT_VREPLACE
    65066506        if (State & VREPLACE_FLAG)
    … …  
    68596859        for (;;)
    68606860        {
    68616861            coladvance(v - width);
    6862             /* getviscol() is slow, skip it when 'showbreak' is empty and
    6863              * there are no multi-byte characters */
    6864             if ((*p_sbr == NUL
     6862            /* getviscol() is slow, skip it when 'showbreak' is empty,
     6863             * 'breakindent' is not set and there are no multi-byte
     6864             * characters */
     6865            if ((*p_sbr == NUL && !curwin->w_p_bri
    68656866#  ifdef FEAT_MBYTE
    68666867                        && !has_mbyte
    68676868#  endif
    … …  
    94979498        getvcol(curwin, &fpos, &vcol, NULL, NULL);
    94989499        getvcol(curwin, cursor, &want_vcol, NULL, NULL);
    94999500
    9500         /* Use as many TABs as possible.  Beware of 'showbreak' and
     9501        /* Use as many TABs as possible.  Beware of 'breakindent', 'showbreak' and
    95019502         * 'linebreak' adding extra virtual columns. */
    95029503        while (vim_iswhite(*ptr))
    95039504        {
    9504             i = lbr_chartabsize((char_u *)"\t", vcol);
     9505            i = lbr_chartabsize((char_u *)"\t", vcol, cursor->lnum);
    95059506            if (vcol + i > want_vcol)
    95069507                break;
    95079508            if (*ptr != TAB)
    … …  
    95279528            /* Skip over the spaces we need. */
    95289529            while (vcol < want_vcol && *ptr == ' ')
    95299530            {
    9530                 vcol += lbr_chartabsize(ptr, vcol);
     9531                vcol += lbr_chartabsize(ptr, vcol, cursor->lnum);
    95319532                ++ptr;
    95329533                ++repl_off;
    95339534            }
    … …  
    97839784    while ((colnr_T)temp < curwin->w_virtcol && *ptr != NUL)
    97849785    {
    97859786        prev_ptr = ptr;
    9786         temp += lbr_chartabsize_adv(&ptr, (colnr_T)temp);
     9787        temp += lbr_chartabsize_adv(&ptr, (colnr_T)temp, lnum);
    97879788    }
    97889789    if ((colnr_T)temp > curwin->w_virtcol)
    97899790        ptr = prev_ptr;

  • src/eval.c 

    diff -r 7b50afd31037 -r fd4d58423e6b src/eval.c
    a b  
    1699016990
    1699116991    if (argvars[1].v_type != VAR_UNKNOWN)
    1699216992        col = get_tv_number(&argvars[1]);
    16993 
    16994     rettv->vval.v_number = (varnumber_T)(linetabsize_col(col, s) - col);
     16993    /*
     16994     * FIXME: passing 0 as 3rd argument to linetabsize_col, instead of real line number;
     16995     * (can we get it from here somehow?); might give incorrect result with breakindent!
     16996     */
     16997    rettv->vval.v_number = (varnumber_T)(linetabsize_col(col, s, 0) - col);
    1699516998}
    1699616999
    1699717000/*

  • src/ex_cmds.c 

    diff -r 7b50afd31037 -r fd4d58423e6b src/ex_cmds.c
    a b  
    262262        ;
    263263    save = *last;
    264264    *last = NUL;
    265     len = linetabsize(line);            /* get line length */
     265    len = linetabsize(line, curwin->w_cursor.lnum); /* get line length */
    266266    if (has_tab != NULL)                /* check for embedded TAB */
    267267        *has_tab = (vim_strrchr(first, TAB) != NULL);
    268268    *last = save;

  • src/getchar.c 

    diff -r 7b50afd31037 -r fd4d58423e6b src/getchar.c
    a b  
    26092609                                    if (!vim_iswhite(ptr[col]))
    26102610                                        curwin->w_wcol = vcol;
    26112611                                    vcol += lbr_chartabsize(ptr + col,
    2612                                                                (colnr_T)vcol);
     2612                                                               (colnr_T)vcol, curwin->w_cursor.lnum);
    26132613#ifdef FEAT_MBYTE
    26142614                                    if (has_mbyte)
    26152615                                        col += (*mb_ptr2len)(ptr + col);

  • src/gui_beval.c 

    diff -r 7b50afd31037 -r fd4d58423e6b src/gui_beval.c
    a b  
    335335        {
    336336            /* Not past end of the file. */
    337337            lbuf = ml_get_buf(wp->w_buffer, lnum, FALSE);
    338             if (col <= win_linetabsize(wp, lbuf, (colnr_T)MAXCOL))
     338            if (col <= win_linetabsize(wp, lbuf, (colnr_T)MAXCOL, lnum))
    339339            {
    340340                /* Not past end of line. */
    341341                if (getword)

  • src/misc1.c 

    diff -r 7b50afd31037 -r fd4d58423e6b src/misc1.c
    a b  
    451451    return (int)col;
    452452}
    453453
     454#ifdef FEAT_LINEBREAK
     455/*
     456 * Return appropriate space number for breakindent, taking influencing
     457 * parameters into account. Window must be specified, since it is not
     458 * necessarily always the current one. If lnum==0, current line is calculated,
     459 * specified line otherwise.
     460 */
     461   int
     462get_breakindent_win (wp,lnum)
     463    win_T*      wp;
     464    linenr_T    lnum;
     465{
     466    int bri;
     467    /* window width minus barren space, i.e. what rests for text */
     468    const int eff_wwidth = W_WIDTH(wp)
     469        - (wp->w_p_nu && !vim_strchr(p_cpo,CPO_NUMCOL)?number_width(wp):0);
     470        /* - (*p_sbr == NUL ? 0 : vim_strsize(p_sbr)); */
     471
     472    bri = get_indent_buf(wp->w_buffer,lnum?lnum:wp->w_cursor.lnum) + wp->w_p_brishift;
     473
     474    /* if numbering and 'c' in 'cpoptions', cancel it out effectively */
     475    /* (this could be replaced by an equivalent call to win_col_off2()) */
     476    if (curwin->w_p_nu && vim_strchr(p_cpo, CPO_NUMCOL))
     477        bri += number_width(wp);
     478   
     479    /* never indent past left window margin */
     480    if (bri < 0)
     481        bri = 0;
     482    /* always leave at least bri_min characters on the left,
     483     * if text width is sufficient */
     484    else if (bri > eff_wwidth - wp->w_p_brimin)
     485        bri = eff_wwidth - wp->w_p_brimin < 0 ? 0 : eff_wwidth - wp->w_p_brimin;
     486
     487    return bri;
     488}
     489#endif
     490
     491
    454492#if defined(FEAT_CINDENT) || defined(FEAT_SMARTINDENT)
    455493
    456494static int cin_is_cinword __ARGS((char_u *line));
    … …  
    17571795    s = ml_get_buf(wp->w_buffer, lnum, FALSE);
    17581796    if (*s == NUL)              /* empty line */
    17591797        return 1;
    1760     col = win_linetabsize(wp, s, (colnr_T)MAXCOL);
     1798    col = win_linetabsize(wp, s, (colnr_T)MAXCOL, lnum);
    17611799
    17621800    /*
    17631801     * If list mode is on, then the '$' at the end of the line may take up one
    … …  
    18131851    col = 0;
    18141852    while (*s != NUL && --column >= 0)
    18151853    {
    1816         col += win_lbr_chartabsize(wp, s, (colnr_T)col, NULL);
     1854        col += win_lbr_chartabsize(wp, s, (colnr_T)col, NULL, lnum);
    18171855        mb_ptr_adv(s);
    18181856    }
    18191857
    … …  
    18251863     * 'ts') -- webb.
    18261864     */
    18271865    if (*s == TAB && (State & NORMAL) && (!wp->w_p_list || lcs_tab1))
    1828         col += win_lbr_chartabsize(wp, s, (colnr_T)col, NULL) - 1;
     1866        col += win_lbr_chartabsize(wp, s, (colnr_T)col, NULL, lnum) - 1;
    18291867
    18301868    /*
    18311869     * Add column offset for 'number', 'relativenumber', 'foldcolumn', etc.
    … …  
    85038541                amount = 0;
    85048542                while (*that && col)
    85058543                {
    8506                     amount += lbr_chartabsize_adv(&that, (colnr_T)amount);
     8544                    amount += lbr_chartabsize_adv(&that, (colnr_T)amount, pos->lnum);
    85078545                    col--;
    85088546                }
    85098547
    … …  
    85268564
    85278565                    while (vim_iswhite(*that))
    85288566                    {
    8529                         amount += lbr_chartabsize(that, (colnr_T)amount);
     8567                        amount += lbr_chartabsize(that, (colnr_T)amount, pos->lnum);
    85308568                        ++that;
    85318569                    }
    85328570
    … …  
    85658603                                    --parencount;
    85668604                                if (*that == '\\' && *(that+1) != NUL)
    85678605                                    amount += lbr_chartabsize_adv(&that,
    8568                                                              (colnr_T)amount);
     8606                                                             (colnr_T)amount, pos->lnum);
    85698607                                amount += lbr_chartabsize_adv(&that,
    8570                                                              (colnr_T)amount);
     8608                                                             (colnr_T)amount, pos->lnum);
    85718609                            }
    85728610                        }
    85738611                        while (vim_iswhite(*that))
    85748612                        {
    8575                             amount += lbr_chartabsize(that, (colnr_T)amount);
     8613                            amount += lbr_chartabsize(that, (colnr_T)amount, pos->lnum);
    85768614                            that++;
    85778615                        }
    85788616                        if (!*that || *that == ';')

  • src/misc2.c 

    diff -r 7b50afd31037 -r fd4d58423e6b src/misc2.c
    a b  
    166166#ifdef FEAT_VIRTUALEDIT
    167167            if ((addspaces || finetune) && !VIsual_active)
    168168            {
    169                 curwin->w_curswant = linetabsize(line) + one_more;
     169                curwin->w_curswant = linetabsize(line, pos->lnum) + one_more;
    170170                if (curwin->w_curswant > 0)
    171171                    --curwin->w_curswant;
    172172            }
    … …  
    184184# endif
    185185                && wcol >= (colnr_T)width)
    186186        {
    187             csize = linetabsize(line);
     187            csize = linetabsize(line, pos->lnum);
    188188            if (csize > 0)
    189189                csize--;
    190190
    … …  
    205205        {
    206206            /* Count a tab for what it's worth (if list mode not on) */
    207207#ifdef FEAT_LINEBREAK
    208             csize = win_lbr_chartabsize(curwin, ptr, col, &head);
     208            csize = win_lbr_chartabsize(curwin, ptr, col, &head, pos->lnum);
    209209            mb_ptr_adv(ptr);
    210210#else
    211             csize = lbr_chartabsize_adv(&ptr, col);
     211            csize = lbr_chartabsize_adv(&ptr, col, pos->lnum);
    212212#endif
    213213            col += csize;
    214214        }

  • src/normal.c 

    diff -r 7b50afd31037 -r fd4d58423e6b src/normal.c
    a b  
    44384438    int         dir;
    44394439    long        dist;
    44404440{
    4441     int         linelen = linetabsize(ml_get_curline());
     4441    int         linelen = linetabsize(ml_get_curline(), curwin->w_cursor.lnum);
    44424442    int         retval = OK;
    44434443    int         atend = FALSE;
    44444444    int         n;
    … …  
    45114511                    (void)hasFolding(curwin->w_cursor.lnum,
    45124512                                                &curwin->w_cursor.lnum, NULL);
    45134513#endif
    4514                 linelen = linetabsize(ml_get_curline());
     4514                linelen = linetabsize(ml_get_curline(), curwin->w_cursor.lnum);
    45154515                if (linelen > width1)
    45164516                    curwin->w_curswant += (((linelen - width1 - 1) / width2)
    45174517                                                                + 1) * width2;
    … …  
    45414541                }
    45424542                curwin->w_cursor.lnum++;
    45434543                curwin->w_curswant %= width2;
    4544                 linelen = linetabsize(ml_get_curline());
     4544                linelen = linetabsize(ml_get_curline(), curwin->w_cursor.lnum);
    45454545            }
    45464546        }
    45474547      }

  • src/ops.c 

    diff -r 7b50afd31037 -r fd4d58423e6b src/ops.c
    a b  
    428428        }
    429429        for ( ; vim_iswhite(*bd.textstart); )
    430430        {
    431             incr = lbr_chartabsize_adv(&bd.textstart, (colnr_T)(bd.start_vcol));
     431            incr = lbr_chartabsize_adv(&bd.textstart, (colnr_T)(bd.start_vcol), curwin->w_cursor.lnum);
    432432            total += incr;
    433433            bd.start_vcol += incr;
    434434        }
    … …  
    488488
    489489        while (vim_iswhite(*non_white))
    490490        {
    491             incr = lbr_chartabsize_adv(&non_white, non_white_col);
     491            incr = lbr_chartabsize_adv(&non_white, non_white_col, curwin->w_cursor.lnum);
    492492            non_white_col += incr;
    493493        }
    494494
    … …  
    513513            verbatim_copy_width -= bd.start_char_vcols;
    514514        while (verbatim_copy_width < destination_col)
    515515        {
    516             incr = lbr_chartabsize(verbatim_copy_end, verbatim_copy_width);
     516            incr = lbr_chartabsize(verbatim_copy_end, verbatim_copy_width, curwin->w_cursor.lnum);
    517517            if (verbatim_copy_width + incr > destination_col)
    518518                break;
    519519            verbatim_copy_width += incr;
    … …  
    35653565            for (ptr = oldp; vcol < col && *ptr; )
    35663566            {
    35673567                /* Count a tab for what it's worth (if list mode not on) */
    3568                 incr = lbr_chartabsize_adv(&ptr, (colnr_T)vcol);
     3568                incr = lbr_chartabsize_adv(&ptr, (colnr_T)vcol, lnum);
    35693569                vcol += incr;
    35703570            }
    35713571            bd.textcol = (colnr_T)(ptr - oldp);
    … …  
    35993599            /* calculate number of spaces required to fill right side of block*/
    36003600            spaces = y_width + 1;
    36013601            for (j = 0; j < yanklen; j++)
    3602                 spaces -= lbr_chartabsize(&y_array[i][j], 0);
     3602                spaces -= lbr_chartabsize(&y_array[i][j], 0, lnum);
    36033603            if (spaces < 0)
    36043604                spaces = 0;
    36053605
    … …  
    49614961    while (bdp->start_vcol < oap->start_vcol && *pstart)
    49624962    {
    49634963        /* Count a tab for what it's worth (if list mode not on) */
    4964         incr = lbr_chartabsize(pstart, (colnr_T)bdp->start_vcol);
     4964        incr = lbr_chartabsize(pstart, (colnr_T)bdp->start_vcol, lnum);
    49654965        bdp->start_vcol += incr;
    49664966#ifdef FEAT_VISUALEXTRA
    49674967        if (vim_iswhite(*pstart))
    … …  
    50305030            {
    50315031                /* Count a tab for what it's worth (if list mode not on) */
    50325032                prev_pend = pend;
    5033                 incr = lbr_chartabsize_adv(&pend, (colnr_T)bdp->end_vcol);
     5033                incr = lbr_chartabsize_adv(&pend, (colnr_T)bdp->end_vcol, lnum);
    50345034                bdp->end_vcol += incr;
    50355035            }
    50365036            if (bdp->end_vcol <= oap->end_vcol
    … …  
    65266526            validate_virtcol();
    65276527            col_print(buf1, sizeof(buf1), (int)curwin->w_cursor.col + 1,
    65286528                    (int)curwin->w_virtcol + 1);
    6529             col_print(buf2, sizeof(buf2), (int)STRLEN(p), linetabsize(p));
     6529            col_print(buf2, sizeof(buf2), (int)STRLEN(p), linetabsize(p, curwin->w_cursor.lnum));
    65306530
    65316531            if (char_count_cursor == byte_count_cursor
    65326532                    && char_count == byte_count)

  • src/option.c 

    diff -r 7b50afd31037 -r fd4d58423e6b src/option.c
    a b  
    187187#ifdef FEAT_ARABIC
    188188# define PV_ARAB        OPT_WIN(WV_ARAB)
    189189#endif
     190#ifdef FEAT_LINEBREAK
     191# define PV_BRI         OPT_WIN(WV_BRI)
     192# define PV_BRIMIN      OPT_WIN(WV_BRIMIN)
     193# define PV_BRISHIFT    OPT_WIN(WV_BRISHIFT)
     194#endif
    190195#ifdef FEAT_DIFF
    191196# define PV_DIFF        OPT_WIN(WV_DIFF)
    192197#endif
    … …  
    644649                            {(char_u *)0L, (char_u *)0L}
    645650#endif
    646651                            SCRIPTID_INIT},
     652    {"breakindent",   "bri",  P_BOOL|P_VI_DEF|P_VIM|P_RWIN,
     653#ifdef FEAT_LINEBREAK
     654                            (char_u *)VAR_WIN, PV_BRI,
     655                            {(char_u *)FALSE, (char_u *)0L}
     656#else
     657                            (char_u *)NULL, PV_NONE,
     658                            {(char_u *)0L, (char_u *)0L}
     659#endif
     660                            SCRIPTID_INIT},
     661    {"breakindentmin", "brimin", P_NUM|P_VI_DEF|P_VIM|P_RWIN,
     662#ifdef FEAT_LINEBREAK
     663                            (char_u *)VAR_WIN, PV_BRIMIN,
     664                            {(char_u *)20L, (char_u *)20L}
     665#else
     666                            (char_u *)NULL, PV_NONE,
     667                            {(char_u *)0L, (char_u *)0L}
     668#endif
     669                            SCRIPTID_INIT},
     670    {"breakindentshift", "brishift", P_NUM|P_VI_DEF|P_VIM|P_RWIN,
     671#ifdef FEAT_LINEBREAK
     672                            (char_u *)VAR_WIN, PV_BRISHIFT,
     673                            {(char_u *)0L, (char_u *)0L}
     674#else
     675                            (char_u *)NULL, PV_NONE,
     676                            {(char_u *)0L, (char_u *)0L}
     677#endif
     678                            SCRIPTID_INIT},
    647679    {"browsedir",   "bsdir",P_STRING|P_VI_DEF,
    648680#ifdef FEAT_BROWSE
    649681                            (char_u *)&p_bsdir, PV_NONE,
    … …  
    83398371        }
    83408372        curwin->w_nrwidth_line_count = 0;
    83418373    }
     8374
     8375    /* 'breakindentmin' must be positive */
     8376    else if (pp == &curwin->w_p_brimin)
     8377    {
     8378        if (curwin->w_p_brimin < 1)
     8379        {
     8380            errmsg = e_positive;
     8381            curwin->w_p_brimin = 1;
     8382        }
     8383    }
    83428384#endif
    83438385
    83448386    else if (pp == &curbuf->b_p_tw)
    … …  
    95759617        case PV_WRAP:   return (char_u *)&(curwin->w_p_wrap);
    95769618#ifdef FEAT_LINEBREAK
    95779619        case PV_LBR:    return (char_u *)&(curwin->w_p_lbr);
     9620        case PV_BRI:    return (char_u *)&(curwin->w_p_bri);
     9621        case PV_BRIMIN: return (char_u *)&(curwin->w_p_brimin);
     9622        case PV_BRISHIFT: return (char_u *)&(curwin->w_p_brishift);
    95789623#endif
    95799624#ifdef FEAT_SCROLLBIND
    95809625        case PV_SCBIND: return (char_u *)&(curwin->w_p_scb);
    … …  
    97619806    to->wo_wrap = from->wo_wrap;
    97629807#ifdef FEAT_LINEBREAK
    97639808    to->wo_lbr = from->wo_lbr;
     9809    to->wo_bri = from->wo_bri;
     9810    to->wo_brimin = from->wo_brimin;
    97649811#endif
    97659812#ifdef FEAT_SCROLLBIND
    97669813    to->wo_scb = from->wo_scb;

  • src/option.h 

    diff -r 7b50afd31037 -r fd4d58423e6b src/option.h
    a b  
    10441044#ifdef FEAT_CURSORBIND
    10451045    , WV_CRBIND
    10461046#endif
     1047#ifdef FEAT_LINEBREAK
     1048    , WV_BRI
     1049    , WV_BRIMIN
     1050    , WV_BRISHIFT
     1051#endif
    10471052#ifdef FEAT_DIFF
    10481053    , WV_DIFF
    10491054#endif

  • src/proto/charset.pro 

    diff -r 7b50afd31037 -r fd4d58423e6b src/proto/charset.pro
    a b  
    1414int vim_strsize __ARGS((char_u *s));
    1515int vim_strnsize __ARGS((char_u *s, int len));
    1616int chartabsize __ARGS((char_u *p, colnr_T col));
    17 int linetabsize __ARGS((char_u *s));
    18 int linetabsize_col __ARGS((int startcol, char_u *s));
    19 int win_linetabsize __ARGS((win_T *wp, char_u *p, colnr_T len));
     17int linetabsize __ARGS((char_u *s, linenr_T lnum));
     18int linetabsize_col __ARGS((int startcol, char_u *s, linenr_T lnum));
     19int win_linetabsize __ARGS((win_T *wp, char_u *p, colnr_T len, linenr_T lnum));
    2020int vim_isIDc __ARGS((int c));
    2121int vim_iswordc __ARGS((int c));
    2222int vim_iswordp __ARGS((char_u *p));
    … …  
    2525int vim_isfilec_or_wc __ARGS((int c));
    2626int vim_isprintc __ARGS((int c));
    2727int vim_isprintc_strict __ARGS((int c));
    28 int lbr_chartabsize __ARGS((unsigned char *s, colnr_T col));
    29 int lbr_chartabsize_adv __ARGS((char_u **s, colnr_T col));
    30 int win_lbr_chartabsize __ARGS((win_T *wp, char_u *s, colnr_T col, int *headp));
     28int lbr_chartabsize __ARGS((unsigned char *s, colnr_T col, linenr_T lnum));
     29int lbr_chartabsize_adv __ARGS((char_u **s, colnr_T col, linenr_T lnum));
     30int win_lbr_chartabsize __ARGS((win_T *wp, char_u *s, colnr_T col, int *headp, linenr_T lnum));
    3131int in_win_border __ARGS((win_T *wp, colnr_T vcol));
    3232void getvcol __ARGS((win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *end));
    3333colnr_T getvcol_nolist __ARGS((pos_T *posp));

  • src/proto/misc1.pro 

    diff -r 7b50afd31037 -r fd4d58423e6b src/proto/misc1.pro
    a b  
    55int get_indent_str __ARGS((char_u *ptr, int ts));
    66int set_indent __ARGS((int size, int flags));
    77int get_number_indent __ARGS((linenr_T lnum));
     8int get_breakindent_win __ARGS((win_T *wp, linenr_T lnum));
    89int open_line __ARGS((int dir, int flags, int old_indent));
    910int get_leader_len __ARGS((char_u *line, char_u **flags, int backward));
    1011int plines __ARGS((linenr_T lnum));

  • src/regexp.c 

    diff -r 7b50afd31037 -r fd4d58423e6b src/regexp.c
    a b  
    42694269                    if (top.col == MAXCOL || bot.col == MAXCOL)
    42704270                        end = MAXCOL;
    42714271                    cols = win_linetabsize(wp,
    4272                                       regline, (colnr_T)(reginput - regline));
     4272                                      regline, (colnr_T)(reginput - regline), reglnum + reg_firstlnum);
    42734273                    if (cols < start || cols > end - (*p_sel == 'e'))
    42744274                        status = RA_NOMATCH;
    42754275                }
    … …  
    42934293          case RE_VCOL:
    42944294            if (!re_num_cmp((long_u)win_linetabsize(
    42954295                            reg_win == NULL ? curwin : reg_win,
    4296                             regline, (colnr_T)(reginput - regline)) + 1, scan))
     4296                            regline, (colnr_T)(reginput - regline), reglnum + reg_firstlnum ) + 1, scan))
    42974297                status = RA_NOMATCH;
    42984298            break;
    42994299

  • src/screen.c 

    diff -r 7b50afd31037 -r fd4d58423e6b src/screen.c
    a b  
    28022802# define WL_SIGN        WL_FOLD         /* column for signs */
    28032803#endif
    28042804#define WL_NR           WL_SIGN + 1     /* line number */
     2805#ifdef FEAT_LINEBREAK
     2806# define WL_BRI         WL_NR + 1       /* 'breakindent' */
     2807#else
     2808# define WL_BRI         WL_NR
     2809#endif
    28052810#if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF)
    2806 # define WL_SBR         WL_NR + 1       /* 'showbreak' or 'diff' */
     2811# define WL_SBR         WL_BRI + 1      /* 'showbreak' or 'diff' */
    28072812#else
    2808 # define WL_SBR         WL_NR
     2813# define WL_SBR         WL_BRI
    28092814#endif
    28102815#define WL_LINE         WL_SBR + 1      /* text in the line */
    28112816    int         draw_state = WL_START;  /* what to draw next */
    … …  
    31333138#endif
    31343139        while (vcol < v && *ptr != NUL)
    31353140        {
    3136             c = win_lbr_chartabsize(wp, ptr, (colnr_T)vcol, NULL);
     3141            c = win_lbr_chartabsize(wp, ptr, (colnr_T)vcol, NULL, lnum);
    31373142            vcol += c;
    31383143#ifdef FEAT_MBYTE
    31393144            prev_ptr = ptr;
    … …  
    35023507                }
    35033508            }
    35043509
     3510#ifdef FEAT_LINEBREAK
     3511            /* draw 'breakindent': indent wrapped text accordingly */
     3512            if (draw_state == WL_BRI -1 && n_extra == 0){
     3513                draw_state = WL_BRI;
     3514# ifdef FEAT_DIFF
     3515                /* FIXME: handle (filler_todo > 0): or modify showbreak so that ---- lines are shorter by the amount needed? */
     3516# endif
     3517                if (wp->w_p_bri && row != startrow){ /* FIXME: what is startrow? Don't we need it as well?? */
     3518                    p_extra = NUL;
     3519                    c_extra = ' ';
     3520                    n_extra = get_breakindent_win(wp,lnum);
     3521                    char_attr = 0; /* was: hl_attr(HLF_AT); */
     3522                    /* FIXME: why do we need to adjust vcol if showbreak does not?? */
     3523                    // vcol += n_extra;
     3524                    /* FIXME: is this relevant here? copied shamelessly from showbreak */
     3525                    /* Correct end of highlighted area for 'breakindent',
     3526                     * required when 'linebreak' is also set. */
     3527                    if (tocol == vcol)
     3528                        tocol += n_extra;
     3529                }
     3530            }
     3531#endif
     3532           
     3533
    35053534#if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF)
    35063535            if (draw_state == WL_SBR - 1 && n_extra == 0)
    35073536            {
    … …  
    42084237# ifdef FEAT_MBYTE
    42094238                                has_mbyte ? mb_l :
    42104239# endif
    4211                                 1), (colnr_T)vcol, NULL) - 1;
     4240                                1), (colnr_T)vcol, NULL, lnum) - 1;
    42124241                    c_extra = ' ';
    42134242                    if (vim_iswhite(c))
    42144243                        c = ' ';

  • src/structs.h 

    diff -r 7b50afd31037 -r fd4d58423e6b src/structs.h
    a b  
    133133    int         wo_arab;
    134134# define w_p_arab w_onebuf_opt.wo_arab  /* 'arabic' */
    135135#endif
     136#ifdef FEAT_LINEBREAK
     137    int         wo_bri;
     138# define w_p_bri w_onebuf_opt.wo_bri    /* 'breakindent' */
     139    long        wo_brimin;
     140# define w_p_brimin w_onebuf_opt.wo_brimin /* 'breakindentmin' */
     141    long        wo_brishift;
     142# define w_p_brishift w_onebuf_opt.wo_brishift /* 'breakindentshift' */
     143#endif
    136144#ifdef FEAT_DIFF
    137145    int         wo_diff;
    138146# define w_p_diff w_onebuf_opt.wo_diff  /* 'diff' */

  • src/ui.c 

    diff -r 7b50afd31037 -r fd4d58423e6b src/ui.c
    a b  
    30863086    start = ptr = ml_get_buf(wp->w_buffer, lnum, FALSE);
    30873087    while (count <= vcol && *ptr != NUL)
    30883088    {
    3089         count += win_lbr_chartabsize(wp, ptr, count, NULL);
     3089        count += win_lbr_chartabsize(wp, ptr, count, NULL, lnum);
    30903090        mb_ptr_adv(ptr);
    30913091    }
    30923092    return (int)(ptr - start);