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

# Párrafo

> Ajuste de las propiedades del elemento de párrafo en FlexiLayout language: número de líneas, espaciado interlineal, alineación, sangrías y restricciones de ancho de línea.

El elemento **Párrafo** admite los siguientes parámetros en FlexiLayout language."

<div id="paragraph-parameters">
  ## Parámetros de párrafo
</div>

| Parameter                                     | Description                                                                                                                                                                                                                                                                                                                                                                                                     |
| --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Void MaxGapInLine( Distance )`               | Establece la distancia máxima entre caracteres adyacentes.                                                                                                                                                                                                                                                                                                                                                      |
| `Void MaxXOutsidePart( Real )`                | Especifica la parte del carácter que puede sobresalir horizontalmente del área de búsqueda. La parte del carácter se especifica mediante un número de `0` a `1`. Los caracteres cuya parte situada fuera del área de búsqueda sea la especificada o menor se incluyen en la hipótesis.                                                                                                                          |
| `Void MaxYOutsidePart( Real )`                | Especifica qué parte del carácter puede sobresalir verticalmente del área de búsqueda. Esa parte del carácter se expresa mediante un número de `0` a `1`. Los caracteres cuya parte fuera del área de búsqueda sea igual o menor que la especificada se incluyen en la hipótesis.                                                                                                                               |
| `Void MaxInterlineSpace( Distance )`          | La distancia máxima entre las líneas.                                                                                                                                                                                                                                                                                                                                                                           |
| `Void MaxRelativeInterlineSpace( Real )`      | La distancia máxima entre líneas adyacentes, expresada como porcentaje de la altura de la línea superior.                                                                                                                                                                                                                                                                                                       |
| `Void MaxLineHeightSpread( Real )`            | La variación máxima en la altura de las líneas, calculada como la diferencia de altura entre la línea más alta y la más baja, dividida entre la altura de la línea más alta.                                                                                                                                                                                                                                    |
| `Void MaxLineLengthSpread( Real )`            | La variación máxima en la longitud de las líneas, calculada como la diferencia de longitud entre la línea más larga y la más corta, dividida por la longitud de la línea más larga.                                                                                                                                                                                                                             |
| `Void MinHorLineOverlap( Real )`              | La superposición horizontal mínima entre líneas adyacentes, calculada como la longitud del segmento común de las líneas dividida por la longitud de la línea más corta.                                                                                                                                                                                                                                         |
| `Void IgnoreSeparators( Logic )`              | Este indicador especifica si deben ignorarse los separadores durante la formación del párrafo. Si el valor se establece en `true`, los párrafos que contienen separadores no se dividen.                                                                                                                                                                                                                        |
| `Void MinLineWidth( Distance )`               | La anchura mínima de la línea. Se aplica durante la concatenación de líneas en un párrafo. Se excluyen las líneas que no cumplen la condición.                                                                                                                                                                                                                                                                  |
| `Void MaxLineWidth( Distance )`               | La anchura máxima de la línea. Se aplica durante la concatenación de líneas en un párrafo. Se excluyen las líneas que no cumplen la condición.                                                                                                                                                                                                                                                                  |
| `Void MinLinesCount( Int )`                   | El número mínimo de líneas del párrafo.                                                                                                                                                                                                                                                                                                                                                                         |
| `Void MaxLinesCount( Int )`                   | El número máximo de líneas del párrafo. Se aplica durante la agrupación en párrafos. Si el número de líneas alcanza el valor especificado, no se añaden más líneas al párrafo.                                                                                                                                                                                                                                  |
| `Void Alignment ( TextAlignment )`            | Establece el tipo de alineación. Se aplica durante la comprobación posterior al ensamblado del párrafo. Los párrafos con una alineación incorrecta se excluyen. Valores admitidos: `Alignment_None` (no se comprueba la alineación), `Alignment_Left` (alineación a la izquierda), `Alignment_Right` (alineación a la derecha), `Alignment_Justified` (justificada) y `Alignment_Center` (alineación centrada). |
| `Void MaxAlignmentError( Distance )`          | El error de alineación admisible. Se calcula como la diferencia entre las coordenadas máxima y mínima del borde de la línea correspondiente (el borde se define según el tipo de alineación).                                                                                                                                                                                                                   |
| `Void AllowFirstLineIndent( Logic )`          | Especifica si se permite la sangría de la primera línea. Cuando se establece en `true`, la primera línea puede llevar sangría en los tipos de alineación `Alignment_Left`, `Alignment_Right` y `Alignment_Justified`. Para los tipos `Alignment_Left` y `Alignment_Justified`, se permite la sangría izquierda. Para `Alignment_Right`, se permite la sangría derecha.                                          |
| `Void MaxFirstLineIndent( Distance )`         | La sangría máxima permitida de la primera línea. Si se especifica un valor negativo, se permite una sangría francesa.                                                                                                                                                                                                                                                                                           |
| `Void AllowLastHangingLine( Lógica )`         | Este indicador especifica si el párrafo puede terminar con una línea más corta. Cuando se establece en `true`, la longitud mínima de la última línea del párrafo no tiene restricciones.                                                                                                                                                                                                                        |
| `Void LinesCount( IntFuzzyInterval )`         | El número de líneas del párrafo.                                                                                                                                                                                                                                                                                                                                                                                |
| `Void FragmentWidth( IntFuzzyInterval )`      | El ancho del párrafo en caracteres.                                                                                                                                                                                                                                                                                                                                                                             |
| `Void MaxLineHeight( Distance )`              | La altura máxima de los caracteres (tamaño de la fuente).                                                                                                                                                                                                                                                                                                                                                       |
| `Void MinLineHeight( Distance )`              | La altura mínima de los caracteres (tamaño de la fuente).                                                                                                                                                                                                                                                                                                                                                       |
| `Void MaxRelativeGapInLine( Real )`           | La distancia máxima entre caracteres adyacentes, expresada como un porcentaje de la altura de la línea.                                                                                                                                                                                                                                                                                                         |
| `Void AllowChoppedWords( Lógica )`            | Este indicador especifica si deben incluirse en la hipótesis los objetos de texto que no quedan completamente dentro de los límites izquierdo y derecho.                                                                                                                                                                                                                                                        |
| `Void MinQuality( Real )`                     | Establece la calidad mínima de la hipótesis.                                                                                                                                                                                                                                                                                                                                                                    |
| `Void FilterStamp( Lógica )`                  | Para obtener más información, consulte [Párrafo](/es/flexi-capture/fls/template/text-chain).                                                                                                                                                                                                                                                                                                                    |
| `Void AllowedTextRotations ( TextRotations )` | Especifica un conjunto de orientaciones del texto reconocido en las que se permite buscar un elemento.                                                                                                                                                                                                                                                                                                          |

<div id="allowchoppedwords-example">
  ## Ejemplo de `AllowChoppedWords`
</div>

El siguiente código indica a FlexiLayout Studio que puede buscar el elemento entre los objetos de texto que solo quedan parcialmente dentro del área de búsqueda.

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