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

# Static Text

> Affinez la recherche de l'élément Static Text en langage FlexiLayout avec des seuils d'erreur, la sensibilité à la casse, des sources du texte de base de données ou de fichier, et des pénalités appliquées aux mots.

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

<div id="static-text-parameters">
  ## Parameters de Static Text
</div>

| Parameter                                                                                           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| --------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Void MinQuality( Real )`                                                                           | Définit la qualité minimale de l’hypothèse.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `Void MaxErrors( Int )`                                                                             | Définit le nombre maximal d’erreurs dans l’hypothèse. Voir [**Static Text**](/fr/flexi-capture/fls/template/static-text), **Max number of errors**.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `Void MaxErrorsPart( Real )`                                                                        | Définit le pourcentage maximal d’erreurs dans l’hypothèse. Voir [**Static Text**](/fr/flexi-capture/fls/template/static-text), **Max error percentage**.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `Void MaxErrors( Int number, Real part )`                                                           | Définit à la fois le nombre maximal d’erreurs (`number`) et le pourcentage maximal d’erreurs (`part`) dans l’hypothèse. **Remarque.** FlexiLayout Studio applique la plus stricte des deux conditions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `Void MaxGapInLine( Distance )`                                                                     | Définit la distance maximale entre des caractères voisins. Lors de la génération d’une hypothèse, FlexiLayout Studio ajoute des caractères à l’hypothèse tant que la distance entre deux caractères voisins ne dépasse pas `MaxGapInLine`. Voir aussi [**Character String**](/fr/flexi-capture/fls/template/character-chain), **Max space length**.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `Void MaxRelativeGapInLine( Real )`                                                                 | Distance maximale entre des caractères voisins, exprimée en pourcentage de la hauteur de ligne.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `Void AllowChoppedWords( Logic )`                                                                   | Cet indicateur précise si les objets texte qui ne s’inscrivent pas entièrement entre les limites gauche et droite doivent être inclus dans l’hypothèse. La valeur par défaut est `true`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `Void MaxXOutsidePart( Real )`                                                                      | Indique la part du caractère qui peut dépasser horizontalement de la zone de recherche. Cette part est exprimée par un nombre compris entre `0` et `1`. Les caractères dont la part située hors de la zone de recherche est inférieure ou égale à la valeur indiquée sont inclus dans l’hypothèse.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `Void MaxYOutsidePart( Real )`                                                                      | Indique la part du caractère qui peut dépasser verticalement de la zone de recherche. Cette part est exprimée par un nombre compris entre `0` et `1`. Les caractères dont la part située hors de la zone de recherche est inférieure ou égale à la valeur indiquée sont inclus dans l’hypothèse.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `Void CaseSensitive( Logic Value=true )`                                                            | Distingue les lettres minuscules des majuscules si la valeur est définie sur `true`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `Void IgnoreAccents( Logic value = true )`                                                          | Indique si les signes diacritiques sont ignorés lors de la recherche de texte. Si la valeur est définie sur `true`, les signes diacritiques seront ignorés (par exemple, les mots "café" et "cafe" seront considérés comme identiques).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `Void SearchTextFromDB( String connectionString, String selectString, Int maxRecordsCount = 1000 )` | Indique l’ensemble de chaînes à rechercher dans une image à l’aide d’une base de données. Pour plus d’informations, voir [Bases de données et fichiers texte dans le langage FlexiLayout](/fr/flexi-capture/fls/language/bd-textfiles). L’argument `connectionString` définit la chaîne de connexion à la base de données. L’argument `selectString` définit une requête SQL commençant par la commande `SELECT`. L’ensemble obtenu par cette requête, qui ne doit contenir qu’un seul champ, représente des variantes de phrases. Dans sa forme la plus simple, une requête récupère le champ requis à partir d’un tableau de base de données spécifié. Si une requête renvoie plusieurs champs, les données du premier champ sont utilisées pour la recherche. Pour accélérer la recherche, seules les `maxRecordsCount` premières variantes sont utilisées (la valeur par défaut est 1000). |
| `Void SearchTextFromFile( String fileName, Int maxRecordsCount = 1000 )`                            | Indique l’ensemble de chaînes à rechercher dans une image à l’aide du fichier texte `fileName`. Pour plus d’informations, voir [Bases de données et fichiers texte dans le langage FlexiLayout](/fr/flexi-capture/fls/language/bd-textfiles). Pour accélérer la recherche, seules les `maxRecordsCount` premières variantes sont utilisées (la valeur par défaut est 1000).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `AllowIntersectPercent( Real )`                                                                     | Indique le pourcentage maximal autorisé de chevauchement vertical entre deux lignes de texte (la valeur par défaut est 15). Ce paramètre peut être utile pour les textes à interligne serré.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |

Exemple pour `MaxErrors( Int number, Real part )` :

Le code suivant indique à FlexiLayout Studio que le nombre absolu d’erreurs ne peut pas dépasser `3` et que le pourcentage d’erreurs ne peut pas dépasser `20%`.

```text theme={null}
MaxErrors (3, 0.2);
```

Exemple pour `MaxGapInLine` :

Le code suivant indique à FlexiLayout Studio que la distance maximale entre deux caractères voisins ne peut pas dépasser 5 mm ; sinon, une hypothèse nulle est générée.

```text theme={null}
MaxGapInLine (5mm);
```

Exemple d’`AllowChoppedWords` :

Le code suivant demande à FlexiLayout Studio de rechercher l’élément uniquement parmi les objets texte qui sont entièrement compris dans la zone de recherche.

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

Exemple de `SearchTextFromDB` :

```text theme={null}
SearchTextFromDB: "Provider=Microsoft.Jet.OLEDB.4.0; Data Source=D:\\FCS\\DBKeywords.mdb", "SELECT Words FROM WordsTable", 500;
```

Exemple de `SearchTextFromFile` :

```text theme={null}
SearchTextFromFile: "Keywords.txt", 500;
```

<div id="single-word-text-methods">
  ## Méthodes de texte à mot unique
</div>

Ces méthodes sont disponibles uniquement si le texte recherché se compose d’un seul mot.

| Parameter                    | Description         |
| ---------------------------- | ------------------- |
| `Void SearchText ( String )` | Texte à rechercher. |

<div id="multi-word-text-methods">
  ## Méthodes pour les textes composés de plusieurs mots
</div>

Ces méthodes sont disponibles si le texte à rechercher se compose de plusieurs mots.

| Parameter                                     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Void NextLinePenalty( Real )`                | Voir [**Static Text**](/fr/flexi-capture/fls/template/static-text), **Pénalité de retour à la ligne**.                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `Void OmissionPenalty( Real )`                | Voir [**Static Text**](/fr/flexi-capture/fls/template/static-text), **Pénalité pour mots omis**.                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `Void WholeWordMode ( Logic )`                | L’indicateur précise si seuls des objets texte entiers doivent être considérés comme des hypothèses valides. Lorsqu’il est défini sur `true`, les hypothèses constituées de fragments de mots sont ignorées. Le paramètre par défaut est `false`. **Remarque.** Cette méthode diffère de `AllowChoppedWords` en ce que `AllowChoppedWords` n’affecte que les hypothèses générées à partir de mots situés à la limite de la zone de recherche, tandis que `WholeWordMode` affecte la génération de toutes les hypothèses. |
| `Void AllowEmbeddedHypotheses( Logic )`       | Indique si les hypothèses imbriquées sont autorisées. Lorsqu’il est défini sur `False`, FlexiLayout Studio génère l’hypothèse la plus longue.                                                                                                                                                                                                                                                                                                                                                                            |
| `Void MaxLineBreakDistance( Distance )`       | Distance entre le mot de la ligne suivante et la ligne précédente.                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `SuggestOnlySimilarChars( Logic value )`      | Lorsqu’elle est définie sur `true`, seuls les caractères (glyphes) au tracé similaire sont autorisés comme caractères de remplacement dans les opérations d’insertion, de suppression et de remplacement de caractères.                                                                                                                                                                                                                                                                                                  |
| `Void AllowedTextRotations ( TextRotations )` | Indique un ensemble d’orientations du texte reconnu dans lesquelles la recherche d’un élément est autorisée.                                                                                                                                                                                                                                                                                                                                                                                                             |

Exemple pour `AllowEmbeddedHypotheses` :

Le code suivant indique à FlexiLayout Studio qu’il doit générer l’hypothèse la plus longue.

```text theme={null}
AllowEmbeddedHypotheses (False);
```
