> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Paragraph

> Adjust Paragraph element properties in the FlexiLayout language: line counts, interline spacing, alignment, indents, and line width constraints.

The **Paragraph** element supports the following parameters in the FlexiLayout language.

## Paragraph parameters

| Parameter                                     | Description                                                                                                                                                                                                                                                                                                                                             |
| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Void MaxGapInLine( Distance )`               | Sets the maximum distance between neighboring characters.                                                                                                                                                                                                                                                                                               |
| `Void MaxXOutsidePart( Real )`                | Specifies the part of the character that may extend beyond the search area horizontally. The part of the character is specified by a number from `0` to `1`. Characters that have the specified or smaller part outside the search area are included in the hypothesis.                                                                                 |
| `Void MaxYOutsidePart( Real )`                | Specifies the part of the character that may extend beyond the search area vertically. The part of the character is specified by a number from `0` to `1`. Characters that have the specified or smaller part outside the search area are included in the hypothesis.                                                                                   |
| `Void MaxInterlineSpace( Distance )`          | The maximum distance between the lines.                                                                                                                                                                                                                                                                                                                 |
| `Void MaxRelativeInterlineSpace( Real )`      | The maximum distance between the neighboring lines expressed as a percentage of the height of the top line.                                                                                                                                                                                                                                             |
| `Void MaxLineHeightSpread( Real )`            | The maximum variation in the height of the lines, calculated as the difference in height between the tallest line and the smallest line divided by the height of the tallest line.                                                                                                                                                                      |
| `Void MaxLineLengthSpread( Real )`            | The maximum variation in the length of the lines, calculated as the difference in length between the longest line and the shortest line divided by the length of the longest line.                                                                                                                                                                      |
| `Void MinHorLineOverlap( Real )`              | The minimum horizontal overlap of the neighboring lines, calculated as the length of the common segment of the lines divided by the length of the shortest line.                                                                                                                                                                                        |
| `Void IgnoreSeparators( Logic )`              | This flag specifies whether to ignore separators during assembly of the paragraph. If the value is set to `true`, paragraphs that contain separators are not split.                                                                                                                                                                                     |
| `Void MinLineWidth( Distance )`               | The minimum width of the line. Applies during concatenation of lines in a paragraph. Lines that do not satisfy the condition are excluded.                                                                                                                                                                                                              |
| `Void MaxLineWidth( Distance )`               | The maximum width of the line. Applies during concatenation of lines in a paragraph. Lines that do not satisfy the condition are excluded.                                                                                                                                                                                                              |
| `Void MinLinesCount( Int )`                   | The minimum number of lines in the paragraph.                                                                                                                                                                                                                                                                                                           |
| `Void MaxLinesCount( Int )`                   | The maximum number of lines in the paragraph. Applies during paragraph assembly. If the number of lines reaches the specified value, no more lines are added to the paragraph.                                                                                                                                                                          |
| `Void Alignment ( TextAlignment )`            | Sets the alignment type. Applies during the check after the paragraph assembly. Paragraphs with incorrect alignment are excluded. Admissible values: `Alignment_None` (alignment is not checked), `Alignment_Left` (left alignment), `Alignment_Right` (right alignment), `Alignment_Justified` (justified), and `Alignment_Center` (center alignment). |
| `Void MaxAlignmentError( Distance )`          | The admissible error of alignment. It is calculated as the difference between the maximum and minimum coordinates of the corresponding line edge (the edge is defined by the alignment type).                                                                                                                                                           |
| `Void AllowFirstLineIndent( Logic )`          | Specifies whether the first line indent is allowed. When set to `true`, the first line can be indented for the `Alignment_Left`, `Alignment_Right`, and `Alignment_Justified` alignment types. For the `Alignment_Left` and `Alignment_Justified` types, the left indent is allowed. For `Alignment_Right`, the right indent is allowed.                |
| `Void MaxFirstLineIndent( Distance )`         | The maximum allowed indent of the first line. If a negative value is specified, a hanging indent is allowed.                                                                                                                                                                                                                                            |
| `Void AllowLastHangingLine( Logic )`          | This flag specifies whether the paragraph can end with a shorter line. When set to `true`, the minimum length of the last line of the paragraph is not restricted.                                                                                                                                                                                      |
| `Void LinesCount( IntFuzzyInterval )`         | The number of lines in the paragraph.                                                                                                                                                                                                                                                                                                                   |
| `Void FragmentWidth( IntFuzzyInterval )`      | The width of the paragraph in characters.                                                                                                                                                                                                                                                                                                               |
| `Void MaxLineHeight( Distance )`              | The maximum height of the characters (font size).                                                                                                                                                                                                                                                                                                       |
| `Void MinLineHeight( Distance )`              | The minimum height of the characters (font size).                                                                                                                                                                                                                                                                                                       |
| `Void MaxRelativeGapInLine( Real )`           | The maximum distance between neighboring characters expressed as a percentage of the line height.                                                                                                                                                                                                                                                       |
| `Void AllowChoppedWords( Logic )`             | This flag specifies whether text objects which do not fit entirely within the left and right boundaries should be included in the hypothesis.                                                                                                                                                                                                           |
| `Void MinQuality( Real )`                     | Sets the minimum quality of the hypothesis.                                                                                                                                                                                                                                                                                                             |
| `Void FilterStamp( Logic )`                   | For more information, see [Paragraph](/flexi-capture/fls/template/text-chain).                                                                                                                                                                                                                                                                          |
| `Void AllowedTextRotations ( TextRotations )` | Specifies a set of orientations of the recognized text in which an element search is allowed.                                                                                                                                                                                                                                                           |

## AllowChoppedWords example

The following code tells FlexiLayout Studio that it may look for the element among the text objects that only partially fit within the search area.

```text theme={null}
AllowChoppedWords (True);
```
