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, 6 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);