> ## 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

> Ajustez les propriétés de l’élément Paragraph dans le langage FlexiLayout : nombre de lignes, espacement entre les lignes, alignement, retraits et contraintes de largeur des lignes.

L’élément **Paragraph** prend en charge les paramètres suivants en langage FlexiLayout.

<div id="paragraph-parameters">
  ## Paramètres de Paragraph
</div>

| Parameter                                     | Description                                                                                                                                                                                                                                                                                                                                                                                         |
| --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Void MaxGapInLine( Distance )`               | Définit la distance maximale entre les caractères adjacents.                                                                                                                                                                                                                                                                                                                                        |
| `Void MaxXOutsidePart( Real )`                | Spécifie la partie du caractère qui peut dépasser horizontalement la zone de recherche. Cette partie du caractère est exprimée par un nombre compris entre `0` et `1`. Les caractères dont la partie située en dehors de la zone de recherche est égale ou inférieure à la valeur spécifiée sont inclus dans l’hypothèse.                                                                           |
| `Void MaxYOutsidePart( Real )`                | Spécifie la partie du caractère qui peut dépasser verticalement de la zone de recherche. Cette partie du caractère est spécifiée par un nombre compris entre `0` et `1`. Les caractères dont la partie située en dehors de la zone de recherche est égale ou inférieure à la valeur spécifiée sont inclus dans l’hypothèse.                                                                         |
| `Void MaxInterlineSpace( Distance )`          | Distance maximale entre les lignes.                                                                                                                                                                                                                                                                                                                                                                 |
| `Void MaxRelativeInterlineSpace( Real )`      | Distance maximale entre deux lignes adjacentes, exprimée en pourcentage de la hauteur de la ligne supérieure.                                                                                                                                                                                                                                                                                       |
| `Void MaxLineHeightSpread( Real )`            | Variation maximale de la hauteur des lignes, calculée comme la différence de hauteur entre la ligne la plus haute et la plus basse, divisée par la hauteur de la ligne la plus haute.                                                                                                                                                                                                               |
| `Void MaxLineLengthSpread( Real )`            | La variation maximale de la longueur des lignes, calculée comme la différence de longueur entre la ligne la plus longue et la ligne la plus courte, divisée par la longueur de la ligne la plus longue.                                                                                                                                                                                             |
| `Void MinHorLineOverlap( Real )`              | Le chevauchement horizontal minimal des lignes voisines, calculé comme la longueur du segment commun des lignes divisée par la longueur de la ligne la plus courte.                                                                                                                                                                                                                                 |
| `Void IgnoreSeparators( Logic )`              | Cet indicateur précise s’il faut ignorer les Separator lors de l’assemblage du paragraphe. Si la valeur est définie sur `true`, les paragraphes qui contiennent des Separator ne sont pas scindés.                                                                                                                                                                                                  |
| `Void MinLineWidth( Distance )`               | La largeur minimale de la ligne. S’applique lors de la concaténation des lignes dans un paragraphe. Les lignes qui ne satisfont pas à cette condition sont exclues.                                                                                                                                                                                                                                 |
| `Void MaxLineWidth( Distance )`               | La largeur maximale de la ligne. S’applique lors de la concaténation des lignes dans un paragraphe. Les lignes qui ne satisfont pas à cette condition sont exclues.                                                                                                                                                                                                                                 |
| `Void MinLinesCount( Int )`                   | Le nombre minimal de lignes dans le paragraphe.                                                                                                                                                                                                                                                                                                                                                     |
| `Void MaxLinesCount( Int )`                   | Le nombre maximal de lignes dans le paragraphe. S’applique lors de l’assemblage du paragraphe. Si le nombre de lignes atteint la valeur spécifiée, aucune ligne supplémentaire n’est ajoutée au paragraphe.                                                                                                                                                                                         |
| `Void Alignment ( TextAlignment )`            | Définit le type d’alignement. S’applique lors de la vérification après l’assemblage des paragraphes. Les paragraphes dont l’alignement est incorrect sont exclus. Valeurs admises : `Alignment_None` (l’alignement n’est pas vérifié), `Alignment_Left` (alignement à gauche), `Alignment_Right` (alignement à droite), `Alignment_Justified` (justifié) et `Alignment_Center` (alignement centré). |
| `Void MaxAlignmentError( Distance )`          | L’erreur d’alignement admissible. Elle est calculée comme la différence entre les coordonnées maximale et minimale du bord de ligne correspondant (le bord est défini par le type d’alignement).                                                                                                                                                                                                    |
| `Void AllowFirstLineIndent( Logic )`          | Indique si le retrait de première ligne est autorisé. Lorsqu’il est défini sur `true`, la première ligne peut être en retrait pour les types d’alignement `Alignment_Left`, `Alignment_Right` et `Alignment_Justified`. Pour les types `Alignment_Left` et `Alignment_Justified`, le retrait à gauche est autorisé. Pour `Alignment_Right`, le retrait à droite est autorisé.                       |
| `Void MaxFirstLineIndent( Distance )`         | Le retrait maximal autorisé de la première ligne. Si une valeur négative est spécifiée, un retrait négatif est autorisé.                                                                                                                                                                                                                                                                            |
| `Void AllowLastHangingLine( Logic )`          | Cet indicateur indique si le paragraphe peut se terminer par une ligne plus courte. Lorsqu’il est défini sur `true`, la longueur minimale de la dernière ligne du paragraphe n’est pas limitée.                                                                                                                                                                                                     |
| `Void LinesCount( IntFuzzyInterval )`         | Le nombre de lignes dans le paragraphe.                                                                                                                                                                                                                                                                                                                                                             |
| `Void FragmentWidth( IntFuzzyInterval )`      | La largeur du paragraphe en caractères.                                                                                                                                                                                                                                                                                                                                                             |
| `Void MaxLineHeight( Distance )`              | La hauteur maximale des caractères (taille de police).                                                                                                                                                                                                                                                                                                                                              |
| `Void MinLineHeight( Distance )`              | La hauteur minimale des caractères (taille de police).                                                                                                                                                                                                                                                                                                                                              |
| `Void MaxRelativeGapInLine( Real )`           | La distance maximale entre les caractères voisins, exprimée en pourcentage de la hauteur de ligne.                                                                                                                                                                                                                                                                                                  |
| `Void AllowChoppedWords( Logic )`             | Cet indicateur indique si les objets texte qui ne s'inscrivent pas entièrement entre les limites gauche et droite doivent être inclus dans l'hypothèse.                                                                                                                                                                                                                                             |
| `Void MinQuality( Real )`                     | Définit la qualité minimale de l'hypothèse.                                                                                                                                                                                                                                                                                                                                                         |
| `Void FilterStamp( Logic )`                   | Pour plus d’informations, voir [Paragraph](/fr/flexi-capture/fls/template/text-chain).                                                                                                                                                                                                                                                                                                              |
| `Void AllowedTextRotations ( TextRotations )` | Spécifie les orientations du texte reconnu pour lesquelles la recherche d'un élément est autorisée.                                                                                                                                                                                                                                                                                                 |

<div id="allowchoppedwords-example">
  ## Exemple pour `AllowChoppedWords`
</div>

Le code suivant indique à FlexiLayout Studio qu’il peut rechercher l’élément parmi les objets texte qui ne se trouvent que partiellement dans la zone de recherche.

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