|
874
|
1 *fold.txt* For Vim version 7.0. Last change: 2006 Mar 29
|
|
7
|
2
|
|
|
3
|
|
|
4 VIM REFERENCE MANUAL by Bram Moolenaar
|
|
|
5
|
|
|
6
|
|
|
7 Folding *Folding* *folding*
|
|
|
8
|
|
|
9 You can find an introduction on folding in chapter 28 of the user manual.
|
|
|
10 |usr_28.txt|
|
|
|
11
|
|
|
12 1. Fold methods |fold-methods|
|
|
|
13 2. Fold commands |fold-commands|
|
|
|
14 3. Fold options |fold-options|
|
|
|
15 4. Behavior of folds |fold-behavior|
|
|
|
16
|
|
|
17 {Vi has no Folding}
|
|
|
18 {not available when compiled without the +folding feature}
|
|
|
19
|
|
|
20 ==============================================================================
|
|
|
21 1. Fold methods *fold-methods*
|
|
|
22
|
|
|
23 The folding method can be set with the 'foldmethod' option.
|
|
|
24
|
|
|
25 When setting 'foldmethod' to a value other than "manual", all folds are
|
|
|
26 deleted and new ones created. Switching to the "manual" method doesn't remove
|
|
|
27 the existing folds. This can be used to first define the folds automatically
|
|
|
28 and then change them manually.
|
|
|
29
|
|
|
30 There are six methods to select folds:
|
|
|
31 manual manually define folds
|
|
|
32 indent more indent means a higher fold level
|
|
|
33 expr specify an expression to define folds
|
|
|
34 syntax folds defined by syntax highlighting
|
|
|
35 diff folds for unchanged text
|
|
|
36 marker folds defined by markers in the text
|
|
|
37
|
|
|
38
|
|
|
39 MANUAL *fold-manual*
|
|
|
40
|
|
|
41 Use commands to manually define the fold regions. This can also be used by a
|
|
|
42 script that parses text to find folds.
|
|
|
43
|
|
|
44 The level of a fold is only defined by its nesting. To increase the fold
|
|
|
45 level of a fold for a range of lines, define a fold inside it that has the
|
|
|
46 same lines.
|
|
|
47
|
|
|
48 The manual folds are lost when you abandon the file. To save the folds use
|
|
|
49 the |:mkview| command. The view can be restored later with |:loadview|.
|
|
|
50
|
|
|
51
|
|
|
52 INDENT *fold-indent*
|
|
|
53
|
|
|
54 The folds are automatically defined by the indent of the lines.
|
|
|
55
|
|
|
56 The foldlevel is computed from the indent of the line, divided by the
|
|
|
57 'shiftwidth' (rounded down). A sequence of lines with the same or higher fold
|
|
|
58 level form a fold, with the lines with a higher level forming a nested fold.
|
|
|
59
|
|
|
60 The nesting of folds is limited with 'foldnestmax'.
|
|
|
61
|
|
|
62 Some lines are ignored and get the fold level of the line above or below it,
|
|
|
63 whatever is the lowest. These are empty or white lines and lines starting
|
|
|
64 with a character in 'foldignore'. White space is skipped before checking for
|
|
|
65 characters in 'foldignore'. For C use "#" to ignore preprocessor lines.
|
|
|
66
|
|
|
67 When you want to ignore lines in another way, use the 'expr' method. The
|
|
|
68 |indent()| function can be used in 'foldexpr' to get the indent of a line.
|
|
|
69
|
|
|
70
|
|
|
71 EXPR *fold-expr*
|
|
|
72
|
|
|
73 The folds are automatically defined by their foldlevel, like with the "indent"
|
|
|
74 method. The value of the 'foldexpr' option is evaluated to get the foldlevel
|
|
|
75 of a line. Examples:
|
|
|
76 This will create a fold for all consecutive lines that start with a Tab: >
|
|
|
77 :set foldexpr=getline(v:lnum)[0]==\"\\t\"
|
|
|
78 This will call a function to compute the fold level: >
|
|
|
79 :set foldexpr=MyFoldLevel(v:lnum)
|
|
|
80 This will make a fold out of paragraphs separated by blank lines: >
|
|
|
81 :set foldexpr=getline(v:lnum)=~'^\\s*$'&&getline(v:lnum+1)=~'\\S'?'<1':1
|
|
|
82 this does the same: >
|
|
|
83 :set foldexpr=getline(v:lnum-1)=~'^\\s*$'&&getline(v:lnum)=~'\\S'?'>1':1
|
|
|
84
|
|
|
85 Note that backslashes must be used to escape characters that ":set" handles
|
|
|
86 differently (space, backslash, double quote, etc., see |option-backslash|).
|
|
|
87
|
|
|
88 These are the conditions with which the expression is evaluated:
|
|
|
89 - The current buffer and window are set for the line.
|
|
|
90 - The variable "v:lnum" is set to the line number.
|
|
|
91 - The result is used for the fold level in this way:
|
|
|
92 value meaning ~
|
|
|
93 0 the line is not in a fold
|
|
|
94 1, 2, .. the line is in a fold with this level
|
|
|
95 -1 the fold level is undefined, use the fold level of a
|
|
|
96 line before or after this line, whichever is the
|
|
|
97 lowest.
|
|
|
98 "=" use fold level from the previous line
|
|
|
99 "a1", "a2", .. add one, two, .. to the fold level of the previous
|
|
|
100 line
|
|
|
101 "s1", "s2", .. subtract one, two, .. from the fold level of the
|
|
|
102 previous line
|
|
|
103 "<1", "<2", .. a fold with this level ends at this line
|
|
|
104 ">1", ">2", .. a fold with this level starts at this line
|
|
|
105
|
|
|
106 It is not required to mark the start (end) of a fold with ">1" ("<1"), a fold
|
|
|
107 will also start (end) when the fold level is higher (lower) than the fold
|
|
|
108 level of the previous line.
|
|
|
109
|
|
|
110 There must be no side effects from the expression. The text in the buffer,
|
|
|
111 cursor position, the search patterns, options etc. must not be changed.
|
|
818
|
112 You can change and restore them if you are careful.
|
|
7
|
113
|
|
|
114 If there is some error in the expression, or the resulting value isn't
|
|
|
115 recognized, there is no error message and the fold level will be zero.
|
|
|
116 For debugging the 'debug' option can be set to "msg", the error messages will
|
|
|
117 be visible then.
|
|
|
118
|
|
|
119 Note: Since the expression has to be evaluated for every line, this fold
|
|
|
120 method can be very slow!
|
|
|
121
|
|
|
122 Try to avoid the "=", "a" and "s" return values, since Vim often has to search
|
|
|
123 backwards for a line for which the fold level is defined. This can be slow.
|
|
|
124
|
|
|
125 |foldlevel()| can be useful to compute a fold level relative to a previous
|
|
|
126 fold level. But note that foldlevel() may return -1 if the level is not known
|
|
|
127 yet. And it returns the level at the start of the line, while a fold might
|
|
|
128 end in that line.
|
|
|
129
|
|
|
130
|
|
|
131 SYNTAX *fold-syntax*
|
|
|
132
|
|
|
133 A fold is defined by syntax items that have the "fold" argument. |:syn-fold|
|
|
|
134
|
|
|
135 The fold level is defined by nesting folds. The nesting of folds is limited
|
|
|
136 with 'foldnestmax'.
|
|
|
137
|
|
|
138 Be careful to specify proper syntax syncing. If this is not done right, folds
|
|
|
139 may differ from the displayed highlighting. This is especially relevant when
|
|
|
140 using patterns that match more than one line. In case of doubt, try using
|
|
|
141 brute-force syncing: >
|
|
|
142 :syn sync fromstart
|
|
|
143
|
|
|
144
|
|
|
145 DIFF *fold-diff*
|
|
|
146
|
|
|
147 The folds are automatically defined for text that is not part of a change or
|
|
|
148 close to a change.
|
|
|
149
|
|
|
150 This method only works properly when the 'diff' option is set for the current
|
|
|
151 window and changes are being displayed. Otherwise the whole buffer will be
|
|
|
152 one big fold.
|
|
|
153
|
|
|
154 The 'diffopt' option can be used to specify the context. That is, the number
|
|
|
155 of lines between the fold and a change that are not included in the fold. For
|
|
|
156 example, to use a context of 8 lines: >
|
|
|
157 :set diffopt=filler,context:8
|
|
|
158 The default context is six lines.
|
|
|
159
|
|
|
160 When 'scrollbind' is also set, Vim will attempt to keep the same folds open in
|
|
|
161 other diff windows, so that the same text is visible.
|
|
|
162
|
|
|
163
|
|
|
164 MARKER *fold-marker*
|
|
|
165
|
|
|
166 Markers in the text tell where folds start and end. This allows you to
|
|
|
167 precisely specify the folds. This will allow deleting and putting a fold,
|
|
|
168 without the risk of including the wrong lines. The 'foldtext' option is
|
|
|
169 normally set such that the text before the marker shows up in the folded line.
|
|
|
170 This makes it possible to give a name to the fold.
|
|
|
171
|
|
|
172 Markers can have a level included, or can use matching pairs. Including a
|
|
|
173 level is easier, you don't have to add end markers and avoid problems with
|
|
|
174 non-matching marker pairs. Example: >
|
|
|
175 /* global variables {{{1 */
|
|
|
176 int varA, varB;
|
|
|
177
|
|
|
178 /* functions {{{1 */
|
|
|
179 /* funcA() {{{2 */
|
|
|
180 void funcA() {}
|
|
|
181
|
|
|
182 /* funcB() {{{2 */
|
|
|
183 void funcB() {}
|
|
|
184
|
|
|
185 A fold starts at a "{{{" marker. The following number specifies the fold
|
|
|
186 level. What happens depends on the difference between the current fold level
|
|
|
187 and the level given by the marker:
|
|
|
188 1. If a marker with the same fold level is encountered, the previous fold
|
|
|
189 ends and another fold with the same level starts.
|
|
|
190 2. If a marker with a higher fold level is found, a nested fold is started.
|
|
|
191 3. if a marker with a lower fold level is found, all folds up to and including
|
|
|
192 this level end and a fold with the specified level starts.
|
|
|
193
|
|
33
|
194 The number indicates the fold level. A zero cannot be used (a marker with
|
|
|
195 level zero is ignored). You can use "}}}" with a digit to indicate the level
|
|
|
196 of the fold that ends. The fold level of the following line will be one less
|
|
|
197 than the indicated level. Note that Vim doesn't look back to the level of the
|
|
|
198 matching marker (that would take too much time). Example: >
|
|
7
|
199
|
|
|
200 {{{1
|
|
|
201 fold level here is 1
|
|
|
202 {{{3
|
|
|
203 fold level here is 3
|
|
|
204 }}}3
|
|
|
205 fold level here is 2
|
|
|
206
|
|
|
207 You can also use matching pairs of "{{{" and "}}}" markers to define folds.
|
|
|
208 Each "{{{" increases the fold level by one, each "}}}" decreases the fold
|
|
|
209 level by one. Be careful to keep the markers matching! Example: >
|
|
|
210
|
|
|
211 {{{
|
|
|
212 fold level here is 1
|
|
|
213 {{{
|
|
|
214 fold level here is 2
|
|
|
215 }}}
|
|
|
216 fold level here is 1
|
|
|
217
|
|
|
218 You can mix using markers with a number and without a number. A useful way of
|
|
|
219 doing this is to use numbered markers for large folds, and unnumbered markers
|
|
|
220 locally in a function. For example use level one folds for the sections of
|
|
|
221 your file like "structure definitions", "local variables" and "functions".
|
|
|
222 Use level 2 markers for each definition and function, Use unnumbered markers
|
|
|
223 inside functions. When you make changes in a function to split up folds, you
|
|
|
224 don't have to renumber the markers.
|
|
|
225
|
|
|
226 The markers can be set with the 'foldmarker' option. It is recommended to
|
|
|
227 keep this at the default value of "{{{,}}}", so that files can be exchanged
|
|
|
228 between Vim users. Only change it when it is required for the file (e.g., it
|
|
|
229 contains markers from another folding editor, or the default markers cause
|
|
|
230 trouble for the language of the file).
|
|
|
231
|
|
|
232 *fold-create-marker*
|
|
|
233 "zf" can be used to create a fold defined by markers. Vim will insert the
|
|
|
234 markers for you. Vim will append the start and end marker, as specified with
|
|
|
235 'foldmarker'. The markers are appended to the end of the line.
|
|
|
236 'commentstring' is used if it isn't empty.
|
|
|
237 This does not work properly when:
|
|
|
238 - The line already contains a marker with a level number. Vim then doesn't
|
|
|
239 know what to do.
|
|
|
240 - Folds nearby use a level number in their marker which gets in the way.
|
|
|
241 - The line is inside a comment, 'commentstring' isn't empty and nested
|
|
|
242 comments don't work. For example with C: adding /* {{{ */ inside a comment
|
|
|
243 will truncate the existing comment. Either put the marker before or after
|
|
|
244 the comment, or add the marker manually.
|
|
|
245 Generally it's not a good idea to let Vim create markers when you already have
|
|
|
246 markers with a level number.
|
|
|
247
|
|
|
248 *fold-delete-marker*
|
|
|
249 "zd" can be used to delete a fold defined by markers. Vim will delete the
|
|
|
250 markers for you. Vim will search for the start and end markers, as specified
|
|
|
251 with 'foldmarker', at the start and end of the fold. When the text around the
|
|
|
252 marker matches with 'commentstring', that text is deleted as well.
|
|
|
253 This does not work properly when:
|
|
|
254 - A line contains more than one marker and one of them specifies a level.
|
|
|
255 Only the first one is removed, without checking if this will have the
|
|
|
256 desired effect of deleting the fold.
|
|
|
257 - The marker contains a level number and is used to start or end several folds
|
|
|
258 at the same time.
|
|
|
259
|
|
|
260 ==============================================================================
|
|
|
261 2. Fold commands *fold-commands* *E490*
|
|
|
262
|
|
|
263 All folding commands start with "z". Hint: the "z" looks like a folded piece
|
|
|
264 of paper, if you look at it from the side.
|
|
|
265
|
|
|
266
|
|
|
267 CREATING AND DELETING FOLDS ~
|
|
|
268 *zf* *E350*
|
|
|
269 zf{motion} or
|
|
|
270 {Visual}zf Operator to create a fold.
|
|
|
271 This only works when 'foldmethod' is "manual" or "marker".
|
|
|
272 The new fold will be closed for the "manual" method.
|
|
|
273 'foldenable' will be set.
|
|
|
274 Also see |fold-create-marker|.
|
|
|
275
|
|
|
276 *zF*
|
|
|
277 zF Create a fold for N lines. Works like "zf".
|
|
|
278
|
|
|
279 :{range}fo[ld] *:fold* *:fo*
|
|
|
280 Create a fold for the lines in {range}. Works like "zf".
|
|
|
281
|
|
|
282 *zd* *E351*
|
|
42
|
283 zd Delete one fold at the cursor. When the cursor is on a folded
|
|
7
|
284 line, that fold is deleted. Nested folds are moved one level
|
|
|
285 up. In Visual mode all folds (partially) in the selected area
|
|
|
286 are deleted. Careful: This easily deletes more folds than you
|
|
|
287 expect and there is no undo.
|
|
|
288 This only works when 'foldmethod' is "manual" or "marker".
|
|
|
289 Also see |fold-delete-marker|.
|
|
|
290
|
|
|
291 *zD*
|
|
|
292 zD Delete folds recursively at the cursor. In Visual mode all
|
|
|
293 folds (partially) in the selected area and all nested folds in
|
|
|
294 them are deleted.
|
|
|
295 This only works when 'foldmethod' is "manual" or "marker".
|
|
|
296 Also see |fold-delete-marker|.
|
|
|
297
|
|
|
298 *zE* *E352*
|
|
|
299 zE Eliminate all folds in the window.
|
|
|
300 This only works when 'foldmethod' is "manual" or "marker".
|
|
|
301 Also see |fold-delete-marker|.
|
|
|
302
|
|
|
303
|
|
|
304 OPENING AND CLOSING FOLDS ~
|
|
|
305
|
|
|
306 A fold smaller than 'foldminlines' will always be displayed like it was open.
|
|
|
307 Therefore the commands below may work differently on small folds.
|
|
|
308
|
|
|
309 *zo*
|
|
|
310 zo Open one fold under the cursor. When a count is given, that
|
|
|
311 many folds deep will be opened. In Visual mode one level of
|
|
|
312 folds is opened for all lines in the selected area.
|
|
|
313
|
|
|
314 *zO*
|
|
|
315 zO Open all folds under the cursor recursively. Folds that don't
|
|
|
316 contain the cursor line are unchanged.
|
|
|
317 In Visual mode it opens all folds that are in the selected
|
|
|
318 area, also those that are only partly selected.
|
|
|
319
|
|
|
320 *zc*
|
|
|
321 zc Close one fold under the cursor. When a count is given, that
|
|
|
322 many folds deep are closed. In Visual mode one level of folds
|
|
|
323 is closed for all lines in the selected area.
|
|
|
324 'foldenable' will be set.
|
|
|
325
|
|
|
326 *zC*
|
|
|
327 zC Close all folds under the cursor recursively. Folds that
|
|
|
328 don't contain the cursor line are unchanged.
|
|
|
329 In Visual mode it closes all folds that are in the selected
|
|
|
330 area, also those that are only partly selected.
|
|
|
331 'foldenable' will be set.
|
|
|
332
|
|
|
333 *za*
|
|
236
|
334 za When on a closed fold: open it. When folds are nested, you
|
|
7
|
335 may have to use "za" several times. When a count is given,
|
|
|
336 that many closed folds are opened.
|
|
|
337 When on an open fold: close it and set 'foldenable'. This
|
|
|
338 will only close one level, since using "za" again will open
|
|
|
339 the fold. When a count is given that many folds will be
|
|
|
340 closed (that's not the same as repeating "za" that many
|
|
|
341 times).
|
|
|
342
|
|
|
343 *zA*
|
|
|
344 zA When on a closed fold: open it recursively.
|
|
|
345 When on an open fold: close it recursively and set
|
|
|
346 'foldenable'.
|
|
|
347
|
|
|
348 *zv*
|
|
|
349 zv View cursor line: Open just enough folds to make the line in
|
|
|
350 which the cursor is located not folded.
|
|
|
351
|
|
|
352 *zx*
|
|
|
353 zx Update folds: Undo manually opened and closed folds: re-apply
|
|
|
354 'foldlevel', then do "zv": View cursor line.
|
|
|
355
|
|
|
356 *zX*
|
|
|
357 zX Undo manually opened and closed folds: re-apply 'foldlevel'.
|
|
|
358
|
|
|
359 *zm*
|
|
|
360 zm Fold more: Subtract one from 'foldlevel'. If 'foldlevel' was
|
|
|
361 already zero nothing happens.
|
|
|
362 'foldenable' will be set.
|
|
|
363
|
|
|
364 *zM*
|
|
|
365 zM Close all folds: set 'foldlevel' to 0.
|
|
|
366 'foldenable' will be set.
|
|
|
367
|
|
|
368 *zr*
|
|
|
369 zr Reduce folding: Add one to 'foldlevel'.
|
|
|
370
|
|
|
371 *zR*
|
|
|
372 zR Open all folds. This sets 'foldlevel' to highest fold level.
|
|
|
373
|
|
|
374 *:foldo* *:foldopen*
|
|
|
375 :{range}foldo[pen][!]
|
|
|
376 Open folds in {range}. When [!] is added all folds are
|
|
|
377 opened. Useful to see all the text in {range}. Without [!]
|
|
|
378 one level of folds is opened.
|
|
|
379
|
|
|
380 *:foldc* *:foldclose*
|
|
|
381 :{range}foldc[lose][!]
|
|
|
382 Close folds in {range}. When [!] is added all folds are
|
|
|
383 closed. Useful to hide all the text in {range}. Without [!]
|
|
|
384 one level of folds is closed.
|
|
|
385
|
|
|
386 *zn*
|
|
|
387 zn Fold none: reset 'foldenable'. All folds will be open.
|
|
|
388
|
|
|
389 *zN*
|
|
|
390 zN Fold normal: set 'foldenable'. All folds will be as they
|
|
|
391 were before.
|
|
|
392
|
|
|
393 *zi*
|
|
|
394 zi Invert 'foldenable'.
|
|
|
395
|
|
|
396
|
|
|
397 MOVING OVER FOLDS ~
|
|
|
398 *[z*
|
|
|
399 [z Move to the start of the current open fold. If already at the
|
|
|
400 start, move to the start of the fold that contains it. If
|
|
|
401 there is no containing fold, the command fails.
|
|
|
402 When a count is used, repeats the command N times.
|
|
|
403
|
|
|
404 *]z*
|
|
|
405 ]z Move to the end of the current open fold. If already at the
|
|
|
406 end, move to the end of the fold that contains it. If there
|
|
|
407 is no containing fold, the command fails.
|
|
|
408 When a count is used, repeats the command N times.
|
|
|
409
|
|
|
410 *zj*
|
|
|
411 zj Move downwards to the start of the next fold. A closed fold
|
|
|
412 is counted as one fold.
|
|
|
413 When a count is used, repeats the command N times.
|
|
|
414 This command can be used after an |operator|.
|
|
|
415
|
|
|
416 *zk*
|
|
|
417 zk Move upwards to the end of the previous fold. A closed fold
|
|
|
418 is counted as one fold.
|
|
|
419 When a count is used, repeats the command N times.
|
|
|
420 This command can be used after an |operator|.
|
|
|
421
|
|
|
422
|
|
|
423 EXECUTING COMMANDS ON FOLDS ~
|
|
|
424
|
|
|
425 :[range]foldd[oopen] {cmd} *:foldd* *:folddoopen*
|
|
|
426 Execute {cmd} on all lines that are not in a closed fold.
|
|
|
427 When [range] is given, only these lines are used.
|
|
|
428 Each time {cmd} is executed the cursor is positioned on the
|
|
|
429 line it is executed for.
|
|
|
430 This works like the ":global" command: First all lines that
|
|
|
431 are not in a closed fold are marked. Then the {cmd} is
|
|
|
432 executed for all marked lines. Thus when {cmd} changes the
|
|
|
433 folds, this has no influence on where it is executed (except
|
|
|
434 when lines are deleted, of course).
|
|
|
435 Example: >
|
|
|
436 :folddoopen s/end/loop_end/ge
|
|
|
437 < Note the use of the "e" flag to avoid getting an error message
|
|
|
438 where "end" doesn't match.
|
|
|
439
|
|
|
440 :[range]folddoc[losed] {cmd} *:folddoc* *:folddoclosed*
|
|
|
441 Execute {cmd} on all lines that are in a closed fold.
|
|
|
442 Otherwise like ":folddoopen".
|
|
|
443
|
|
|
444 ==============================================================================
|
|
|
445 3. Fold options *fold-options*
|
|
|
446
|
|
|
447 COLORS *fold-colors*
|
|
|
448
|
|
|
449 The colors of a closed fold are set with the Folded group |hl-Folded|. The
|
|
|
450 colors of the fold column are set with the FoldColumn group |hl-FoldColumn|.
|
|
|
451 Example to set the colors: >
|
|
|
452
|
|
|
453 :highlight Folded guibg=grey guifg=blue
|
|
|
454 :highlight FoldColumn guibg=darkgrey guifg=white
|
|
|
455
|
|
|
456
|
|
|
457 FOLDLEVEL *fold-foldlevel*
|
|
|
458
|
|
|
459 'foldlevel' is a number option: The higher the more folded regions are open.
|
|
|
460 When 'foldlevel' is 0, all folds are closed.
|
|
42
|
461 When 'foldlevel' is positive, some folds are closed.
|
|
7
|
462 When 'foldlevel' is very high, all folds are open.
|
|
|
463 'foldlevel' is applied when it is changed. After that manually folds can be
|
|
|
464 opened and closed.
|
|
|
465 When increased, folds above the new level are opened. No manually opened
|
|
|
466 folds will be closed.
|
|
|
467 When decreased, folds above the new level are closed. No manually closed
|
|
|
468 folds will be opened.
|
|
|
469
|
|
|
470
|
|
|
471 FOLDTEXT *fold-foldtext*
|
|
|
472
|
|
|
473 'foldtext' is a string option that specifies an expression. This expression
|
|
|
474 is evaluated to obtain the text displayed for a closed fold. Example: >
|
|
|
475
|
|
|
476 :set foldtext=v:folddashes.substitute(getline(v:foldstart),'/\\*\\\|\\*/\\\|{{{\\d\\=','','g')
|
|
|
477
|
|
|
478 This shows the first line of the fold, with "/*", "*/" and "{{{" removed.
|
|
|
479 Note the use of backslashes to avoid some characters to be interpreted by the
|
|
|
480 ":set" command. It's simpler to define a function and call that: >
|
|
|
481
|
|
|
482 :set foldtext=MyFoldText()
|
|
|
483 :function MyFoldText()
|
|
|
484 : let line = getline(v:foldstart)
|
|
|
485 : let sub = substitute(line, '/\*\|\*/\|{{{\d\=', '', 'g')
|
|
|
486 : return v:folddashes . sub
|
|
|
487 :endfunction
|
|
|
488
|
|
|
489 Evaluating 'foldtext' is done in the |sandbox|. The current window is set to
|
|
|
490 the window that displays the line. Errors are ignored.
|
|
|
491
|
|
|
492 The default value is |foldtext()|. This returns a reasonable text for most
|
|
|
493 types of folding. If you don't like it, you can specify your own 'foldtext'
|
|
|
494 expression. It can use these special Vim variables:
|
|
|
495 v:foldstart line number of first line in the fold
|
|
|
496 v:foldend line number of last line in the fold
|
|
|
497 v:folddashes a string that contains dashes to represent the
|
|
|
498 foldlevel.
|
|
|
499 v:foldlevel the foldlevel of the fold
|
|
|
500
|
|
|
501 In the result a TAB is replaced with a space and unprintable characters are
|
|
|
502 made into printable characters.
|
|
|
503
|
|
|
504 The resulting line is truncated to fit in the window, it never wraps.
|
|
|
505 When there is room after the text, it is filled with the character specified
|
|
|
506 by 'fillchars'.
|
|
|
507
|
|
|
508 Note that backslashes need to be used for characters that the ":set" command
|
|
|
509 handles differently: Space, backslash and double-quote. |option-backslash|
|
|
|
510
|
|
|
511
|
|
|
512 FOLDCOLUMN *fold-foldcolumn*
|
|
|
513
|
|
|
514 'foldcolumn' is a number, which sets the width for a column on the side of the
|
|
|
515 window to indicate folds. When it is zero, there is no foldcolumn. A normal
|
|
519
|
516 value is 4 or 5. The minimal useful value is 2, although 1 still provides
|
|
|
517 some information. The maximum is 12.
|
|
7
|
518
|
|
|
519 An open fold is indicated with a column that has a '-' at the top and '|'
|
|
|
520 characters below it. This column stops where the open fold stops. When folds
|
|
|
521 nest, the nested fold is one character right of the fold it's contained in.
|
|
|
522
|
|
|
523 A closed fold is indicated with a '+'.
|
|
|
524
|
|
|
525 Where the fold column is too narrow to display all nested folds, digits are
|
|
|
526 shown to indicate the nesting level.
|
|
|
527
|
|
|
528 The mouse can also be used to open and close folds by clicking in the
|
|
|
529 fold column:
|
|
|
530 - Click on a '+' to open the closed fold at this row.
|
|
|
531 - Click on any other non-blank character to close the open fold at this row.
|
|
|
532
|
|
|
533
|
|
|
534 OTHER OPTIONS
|
|
|
535
|
|
|
536 'foldenable' 'fen': Open all folds while not set.
|
|
|
537 'foldexpr' 'fde': Expression used for "expr" folding.
|
|
|
538 'foldignore' 'fdi': Characters used for "indent" folding.
|
|
|
539 'foldmarker' 'fmr': Defined markers used for "marker" folding.
|
|
|
540 'foldmethod' 'fdm': Name of the current folding method.
|
|
|
541 'foldminlines' 'fml': Minimum number of screen lines for a fold to be
|
|
|
542 displayed closed.
|
|
|
543 'foldnestmax' 'fdn': Maximum nesting for "indent" and "syntax" folding.
|
|
|
544 'foldopen' 'fdo': Which kinds of commands open closed folds.
|
|
|
545 'foldclose' 'fcl': When the folds not under the cursor are closed.
|
|
|
546
|
|
|
547 ==============================================================================
|
|
|
548 4. Behavior of folds *fold-behavior*
|
|
|
549
|
|
|
550 When moving the cursor upwards or downwards and when scrolling, the cursor
|
|
|
551 will move to the first line of a sequence of folded lines. When the cursor is
|
|
|
552 already on a folded line, it moves to the next unfolded line or the next
|
|
|
553 closed fold.
|
|
|
554
|
|
|
555 While the cursor is on folded lines, the cursor is always displayed in the
|
|
|
556 first column. The ruler does show the actual cursor position, but since the
|
|
|
557 line is folded, it cannot be displayed there.
|
|
|
558
|
|
|
559 Many movement commands handle a sequence of folded lines like an empty line.
|
|
|
560 For example, the "w" command stops once in the first column.
|
|
|
561
|
|
|
562 When in Insert mode, the cursor line is never folded. That allows you to see
|
|
|
563 what you type!
|
|
|
564
|
|
|
565 When using an operator, a closed fold is included as a whole. Thus "dl"
|
|
|
566 deletes the whole closed fold under the cursor.
|
|
|
567
|
|
|
568 For Ex commands the range is adjusted to always start at the first line of a
|
|
8
|
569 closed fold and end at the last line of a closed fold. Thus this command: >
|
|
7
|
570 :s/foo/bar/g
|
|
|
571 when used with the cursor on a closed fold, will replace "foo" with "bar" in
|
|
|
572 all lines of the fold.
|
|
|
573 This does not happen for |:folddoopen| and |:folddoclosed|.
|
|
|
574
|
|
|
575 When editing a buffer that has been edited before, the last used folding
|
|
|
576 settings are used again. For manual folding the defined folds are restored.
|
|
|
577 For all folding methods the manually opened and closed folds are restored.
|
|
|
578 If this buffer has been edited in this window, the values from back then are
|
|
|
579 used. Otherwise the values from the window where the buffer was edited last
|
|
|
580 are used.
|
|
|
581
|
|
|
582 ==============================================================================
|
|
|
583 vim:tw=78:ts=8:ft=help:norl:
|
