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

> Passen Sie die Eigenschaften des Paragraph-Elements in der FlexiLayout-Sprache an: Zeilenanzahl, Zeilenabstand, Ausrichtung, Einzüge und Beschränkungen der Zeilenbreite.

Das **Paragraph**-Element unterstützt in der FlexiLayout-Sprache die folgenden Parameter.

<div id="paragraph-parameters">
  ## Parameter des Paragraph-Elements
</div>

| Parameter                                     | Beschreibung                                                                                                                                                                                                                                                                                                                                                                |
| --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Void MaxGapInLine( Distance )`               | Legt den maximalen Abstand zwischen benachbarten Zeichen fest.                                                                                                                                                                                                                                                                                                              |
| `Void MaxXOutsidePart( Real )`                | Gibt den Anteil des Zeichens an, der horizontal über den Suchbereich hinausragen darf. Der Anteil des Zeichens wird durch eine Zahl von `0` bis `1` angegeben. Zeichen, von denen sich der angegebene oder ein kleinerer Anteil außerhalb des Suchbereichs befindet, werden in die Hypothese aufgenommen.                                                                   |
| `Void MaxYOutsidePart( Real )`                | Gibt den Teil des Zeichens an, der den Suchbereich vertikal überschreiten darf. Der Teil des Zeichens wird durch eine Zahl von `0` bis `1` angegeben. Zeichen, bei denen sich der angegebene oder ein kleinerer Teil außerhalb des Suchbereichs befindet, werden in die Hypothese einbezogen.                                                                               |
| `Void MaxInterlineSpace( Distance )`          | Der maximale Abstand zwischen den Zeilen.                                                                                                                                                                                                                                                                                                                                   |
| `Void MaxRelativeInterlineSpace( Real )`      | Der maximale Abstand zwischen benachbarten Zeilen, ausgedrückt als Prozentsatz der Höhe der oberen Zeile.                                                                                                                                                                                                                                                                   |
| `Void MaxLineHeightSpread( Real )`            | Die maximale Abweichung bei der Höhe der Zeilen, berechnet als Differenz zwischen der Höhe der höchsten und der niedrigsten Zeile, geteilt durch die Höhe der höchsten Zeile.                                                                                                                                                                                               |
| `Void MaxLineLengthSpread( Real )`            | Die maximale Abweichung der Zeilenlängen, berechnet als die durch die Länge der längsten Zeile geteilte Differenz zwischen der längsten und der kürzesten Zeile.                                                                                                                                                                                                            |
| `Void MinHorLineOverlap( Real )`              | Die minimale horizontale Überlappung benachbarter Zeilen, berechnet als die durch die Länge der kürzesten Zeile geteilte Länge des gemeinsamen Abschnitts der Zeilen.                                                                                                                                                                                                       |
| `Void IgnoreSeparators( Logic )`              | Mit diesem Flag wird festgelegt, ob Trennzeichen bei der Bildung des Paragraphen ignoriert werden. Wenn der Wert auf `true` gesetzt ist, werden Paragraphen, die Trennzeichen enthalten, nicht aufgeteilt.                                                                                                                                                                  |
| `Void MinLineWidth( Distance )`               | Die minimale Breite der Zeile. Gilt bei der Verkettung von Zeilen in einem Absatz. Zeilen, die diese Bedingung nicht erfüllen, werden ausgeschlossen.                                                                                                                                                                                                                       |
| `Void MaxLineWidth( Distance )`               | Die maximale Breite der Zeile. Gilt bei der Verkettung von Zeilen in einem Absatz. Zeilen, die diese Bedingung nicht erfüllen, werden ausgeschlossen.                                                                                                                                                                                                                       |
| `Void MinLinesCount( Int )`                   | Die Mindestanzahl an Zeilen im Absatz.                                                                                                                                                                                                                                                                                                                                      |
| `Void MaxLinesCount( Int )`                   | Die Höchstanzahl an Zeilen im Absatz. Gilt bei der Absatzbildung. Wenn die Anzahl der Zeilen den angegebenen Wert erreicht, werden dem Absatz keine weiteren Zeilen hinzugefügt.                                                                                                                                                                                            |
| `Void Alignment ( TextAlignment )`            | Legt den Ausrichtungstyp fest. Gilt bei der Überprüfung nach der Absatzbildung. Absätze mit falscher Ausrichtung werden ausgeschlossen. Zulässige Werte: `Alignment_None` (Ausrichtung wird nicht geprüft), `Alignment_Left` (linksbündig), `Alignment_Right` (rechtsbündig), `Alignment_Justified` (Blocksatz) und `Alignment_Center` (zentriert).                         |
| `Void MaxAlignmentError( Distanz )`           | Der zulässige Ausrichtungsfehler. Er wird als Differenz zwischen den maximalen und minimalen Koordinaten der entsprechenden Zeilenkante berechnet (die Kante wird durch den Ausrichtungstyp definiert).                                                                                                                                                                     |
| `Void AllowFirstLineIndent( Logic )`          | Gibt an, ob ein Einzug der ersten Zeile zulässig ist. Wenn der Wert auf `true` gesetzt ist, kann die erste Zeile bei den Ausrichtungstypen `Alignment_Left`, `Alignment_Right` und `Alignment_Justified` eingerückt werden. Für die Typen `Alignment_Left` und `Alignment_Justified` ist ein linker Einzug zulässig. Für `Alignment_Right` ist ein rechter Einzug zulässig. |
| `Void MaxFirstLineIndent( Distanz )`          | Der maximal zulässige Einzug der ersten Zeile. Wenn ein negativer Wert angegeben wird, ist ein hängender Einzug zulässig.                                                                                                                                                                                                                                                   |
| `Void AllowLastHangingLine( Logic )`          | Dieses Flag legt fest, ob der Absatz mit einer kürzeren letzten Zeile enden darf. Wenn es auf `true` gesetzt ist, ist die Mindestlänge der letzten Zeile des Absatzes nicht eingeschränkt.                                                                                                                                                                                  |
| `Void LinesCount( IntFuzzyInterval )`         | Die Anzahl der Zeilen im Absatz.                                                                                                                                                                                                                                                                                                                                            |
| `Void FragmentWidth( IntFuzzyInterval )`      | Die Breite des Absatzes in Zeichen.                                                                                                                                                                                                                                                                                                                                         |
| `Void MaxLineHeight( Distance )`              | Die maximale Höhe der Zeichen (Schriftgröße).                                                                                                                                                                                                                                                                                                                               |
| `Void MinLineHeight( Distance )`              | Die minimale Höhe der Zeichen (Schriftgröße).                                                                                                                                                                                                                                                                                                                               |
| `Void MaxRelativeGapInLine( Real )`           | Der maximale Abstand zwischen benachbarten Zeichen, ausgedrückt als Prozentsatz der Zeilenhöhe.                                                                                                                                                                                                                                                                             |
| `Void AllowChoppedWords( Logic )`             | Dieses Flag gibt an, ob Textobjekte, die nicht vollständig innerhalb der linken und rechten Begrenzungen liegen, in die Hypothese einbezogen werden sollen.                                                                                                                                                                                                                 |
| `Void MinQuality( Real )`                     | Legt die Mindest-Quality der Hypothese fest.                                                                                                                                                                                                                                                                                                                                |
| `Void FilterStamp( Logic )`                   | Weitere Informationen finden Sie unter [Paragraph](/de/flexi-capture/fls/template/text-chain).                                                                                                                                                                                                                                                                              |
| `Void AllowedTextRotations ( TextRotations )` | Gibt eine Menge von Orientierungen des erkannten Textes an, für die eine Elementsuche zulässig ist.                                                                                                                                                                                                                                                                         |

Beispiel für `AllowChoppedWords`:

Der folgende Code teilt dem Programm mit, dass es nach dem Element auch unter den Textobjekten suchen darf, die nur teilweise innerhalb des Suchbereichs liegen.

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