<?xml version="1.0" encoding="UTF-8"?>
<article id="Filters">
  <title>Utilisation des filtres<indexterm>
      <primary>filtres</primary>

      <seealso>filtres de fichiers</seealso>

      <seealso>masques de fichiers</seealso>

      <seealso>filtres de lignes</seealso>

      <seealso>filtres de substitution</seealso>
    </indexterm></title>

  <para>Lorsque vous comparez des fichiers ou des dossiers, vous pouvez utiliser des
filtres pour restreindre la portée de la comparaison. Cela peut être utile
lorsque vous souhaitez simplifier le résultat de la comparaison en éliminant
les différences qui ne vous intéressent pas. Les filtres sont des règles
basées sur des expressions régulières. WinMerge utilise le moteur
d'expressions régulières populaire PCRE (Perl Compatible Regular
Expressions).<indexterm>
      <primary>expressions régulières</primary>

      <secondary>moteur pris en charge</secondary>
    </indexterm><indexterm>
      <primary>moteur d'expressions régulières PCRE</primary>
    </indexterm><indexterm>
      <primary>regexp</primary>

      <see>expressions régulières</see>
    </indexterm></para>

  <para>Le fonctionnement de base du filtrage est simple : chaque élément qui serait
normalement comparé (dossier, fichier ou ligne d'un fichier) est évalué, et
si l'expression du filtre correspond à l'élément cible, le filtre est
appliqué. Selon le type de filtre, l'élément est soit inclus, soit exclu de
la comparaison.</para>

  <para>Il existe différents filtres WinMerge pour les opérations de comparaison de
dossiers et de fichiers :</para>

  <variablelist>
    <varlistentry>
      <term>Comparaison de dossiers : masques de fichiers et filtres de
fichiers<indexterm>
          <primary>comparaison de dossiers</primary>

          <secondary>filtrage</secondary>
        </indexterm></term>

      <listitem>
        <para>Vous pouvez spécifier les fichiers à inclure dans une comparaison de
dossiers en utilisant des masques de fichiers simples ou, pour un filtrage
plus complexe, en appliquant plusieurs règles spécifiées dans un filtre de
fichier.</para>

        <para>Les fichiers et dossiers filtrés sont masqués par défaut dans le résultat,
ce qui est généralement l'effet recherché. Vous pouvez cliquer sur
<menuchoice> <guimenu>Affichage</guimenu> <guimenuitem>Afficher les éléments
ignorés</guimenuitem> </menuchoice> pour les faire réapparaître, mais la
fenêtre de comparaison n'affiche que des informations minimales à leur
sujet. Par exemple, vous ne pouvez pas savoir si un fichier ignoré est un
fichier texte ou un fichier binaire.</para>

        <para>Le filtre d'affichage des fichiers/dossiers est également disponible pour
les opérations de comparaison de dossiers. Contrairement aux filtres de
fichiers, il n'affecte pas le résultat de la comparaison; il contrôle
uniquement les éléments visibles dans la fenêtre de comparaison de
dossiers. Voir <xref linkend="Filters_DisplayFileFolderFilter"/>.</para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term>Comparaisons de fichiers : filtres de lignes et filtres de
substitution<indexterm>
          <primary>comparaison de fichiers</primary>

          <secondary>filtrage</secondary>
        </indexterm></term>

      <listitem>
        <para>Les filtres de lignes s'appliquent uniquement aux opérations de comparaison
de fichiers. Ils vous permettent d'ignorer les différences portant sur une
seule ligne.</para>
        <para>Les filtres de substitution s'appliquent uniquement aux opérations de
comparaison de fichiers. Ils remplacent les chaînes de caractères dans le
bloc de diff par des chaînes spécifiées, les comparent, et ignorent le bloc
de diff si les résultats du remplacement correspondent. Ils sont utiles pour
ignorer un grand nombre de changements sans intérêt.</para>
        <para>Le filtre d'affichage des lignes s'applique uniquement aux opérations de
comparaison de fichiers. Contrairement aux filtres de lignes, il n'affecte
pas le résultat de la comparaison; il contrôle uniquement les lignes
visibles dans la fenêtre de comparaison de fichiers. Voir <xref
linkend="Filters_DisplayLineFilter"/>.</para>
      </listitem>
    </varlistentry>
  </variablelist>

  <section id="Filters_Mask">
    <title>Utilisation des masques de fichiers<indexterm>
        <primary>masques de fichiers</primary>
      </indexterm><indexterm>
        <primary>filtres</primary>

        <secondary>masques de fichiers</secondary>
      </indexterm><indexterm>
        <primary>filtres</primary>

        <secondary>dans les comparaisons de dossiers</secondary>
      </indexterm></title>

    <para>Vous pouvez utiliser un ou plusieurs <glossterm>masques de
fichiers</glossterm> spécifiant les extensions de fichiers à inclure dans
une comparaison de dossiers. Tous les autres fichiers seront omis de votre
sélection.</para>

    <section id="Filters_MaskApply">
      <title>Définition et application des masques de fichiers<indexterm>
          <primary>ligne de commande</primary>

          <secondary>application des masques de fichiers</secondary>
        </indexterm></title>

      <para>Définissez et appliquez un masque de fichier au moment où vous lancez votre
opération de comparaison de dossiers :</para>

      <itemizedlist>
        <listitem>
          <para>Si vous utilisez la boîte de dialogue « Sélectionner des fichiers ou des
dossiers », après avoir choisi les dossiers <guilabel>1er</guilabel> et
<guilabel>2e</guilabel>, saisissez un ou plusieurs masques de fichiers dans
le champ <guilabel>Filtre</guilabel>. Les masques sont appliqués lorsque
vous démarrez l'opération de comparaison.</para>
        </listitem>

        <listitem>
          <para>Si vous utilisez la ligne de commande WinMerge, utilisez le commutateur
<option>-f</option> pour spécifier les masques de fichiers (voir l'exemple
dans la section suivante).</para>
        </listitem>
      </itemizedlist>
    </section>

    <section id="Filters_MaskSyntax">
      <title>Syntaxe et exemple de masques de fichiers<indexterm>
          <primary>règles</primary>

          <secondary>masques de fichiers</secondary>
        </indexterm><indexterm>
          <primary>filtres</primary>

          <secondary>masques de fichiers</secondary>
        </indexterm><indexterm>
          <primary>expressions régulières</primary>

          <secondary>dans les masques de fichiers</secondary>
        </indexterm></title>

      <para>Vous pouvez spécifier des masques de fichiers et des filtres étendus en
utilisant ce format :</para>

      <synopsis>
        <replaceable>Filtre1 du Groupe1</replaceable>;<replaceable>Filtre2</replaceable> ...|<replaceable>Filtre1 du Groupe2</replaceable>;<replaceable>Filtre2</replaceable> ...|...
      </synopsis>

      <itemizedlist>
        <listitem><para>Le caractère <filename>|</filename> sépare les groupes de filtres et agit
comme un ET logique.</para></listitem>
        <listitem><para>Les filtres au sein d'un même groupe sont séparés par <filename>;</filename>
et sont interprétés avec un OU logique.</para></listitem>
        <listitem><para>Un fichier est inclus uniquement s'il correspond à au moins un filtre dans
chaque groupe.</para></listitem>
        <listitem>
          <para>Pour inclure un caractère <filename>|</filename> (barre verticale) littéral
dans une expression régulière qui n'est pas entourée de guillemets doubles
(comme dans les filtres <filename>f:</filename> ou
<filename>f!:</filename>), utilisez <filename>||</filename> à la place.</para>
          <para>Exemple : <userinput>f:(abc||def)\.txt$</userinput></para>
        </listitem>
        <listitem>
          <para>Chaque filtre (par ex., Filtre1, Filtre2) peut être de l'un des types
suivants :</para>
          <variablelist>
            <varlistentry><term><replaceable>*.ext</replaceable></term><listitem><para>Masque de fichier par extension (ex: *.txt)</para></listitem></varlistentry>
            <varlistentry><term><replaceable>*.</replaceable></term><listitem><para>Fichiers sans extension (ex: README)</para></listitem></varlistentry>
            <varlistentry><term>!<replaceable>*.ext</replaceable></term><listitem><para>Exclure les fichiers correspondant à l'extension (disponible depuis 2.16.19)</para></listitem></varlistentry>
            <varlistentry><term><replaceable>dossier</replaceable>\</term><listitem><para>Dossiers cibles (doit se terminer par \) (disponible depuis 2.16.19)</para></listitem></varlistentry>
            <varlistentry><term>!<replaceable>dossier</replaceable>\</term><listitem><para>Exclure les dossiers correspondants (disponible depuis 2.16.19)</para></listitem></varlistentry>
            <varlistentry><term>f: <replaceable>regexp</replaceable></term><listitem><para>Fait correspondre les noms de fichiers par expressions régulières
(disponible depuis 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>f!: <replaceable>regexp</replaceable></term><listitem><para>Exclure les fichiers correspondant à la regex (disponible depuis 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>d: <replaceable>regexp</replaceable></term><listitem><para>Fait correspondre les noms de dossiers par regex (disponible depuis 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>d!: <replaceable>regexp</replaceable></term><listitem><para>Exclure les dossiers correspondant à la regex (disponible depuis 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>fe: <replaceable>expr</replaceable></term><listitem><para>Expression de filtre pour les fichiers (ex: fe:Size &lt; 1KB) (disponible
depuis 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>fe!: <replaceable>expr</replaceable></term><listitem><para>Expression de filtre pour exclure des fichiers (disponible depuis 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>de: <replaceable>expr</replaceable></term><listitem><para>Expression de filtre pour les dossiers (disponible depuis 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>de!: <replaceable>expr</replaceable></term><listitem><para>Expression de filtre pour exclure des dossiers (disponible depuis 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>pf: <replaceable>nom du filtre de fichier</replaceable></term><listitem><para>Appliquer un filtre de fichier par son nom (disponible depuis 2.16.49)</para></listitem></varlistentry>
          </variablelist>
        </listitem>
      </itemizedlist>

      <example>
        <title>Masque de fichier</title>

        <para>Dans cet exemple en ligne de commande, l'opération de comparaison de
dossiers inclut uniquement les fichiers avec les extensions
<filename>xml</filename> ou <filename>txt</filename>. Tous les autres
fichiers sont omis :</para>

        <para><userinput>WinMergeU c:\project\docs c:\temp /f *.xml;*.txt</userinput></para>
      </example>

      <example>
        <title>Exclure des dossiers (depuis la version 2.16.19)</title>

        <para>Dans cet exemple en ligne de commande, l'opération de comparaison de
dossiers exclut les dossiers <filename>.git</filename> et
<filename>.vs</filename> :</para>

        <para><userinput>WinMergeU c:\project\docs c:\temp /f !.git\;!.vs\</userinput></para>
      </example>

      <example>
        <title>Expression de filtre (depuis la version 2.16.49)</title>

        <para>Dans cet exemple en ligne de commande, l'opération de comparaison de
dossiers inclut uniquement les fichiers ayant les extensions
<filename>cpp</filename> ou <filename>h</filename> et dont la taille est
inférieure à 1 Ko :</para>

        <para><userinput>WinMergeU c:\project\docs c:\temp /f "*.cpp;*.h|fe:Size &lt;
1KB"</userinput></para>
      </example>
    </section>

    <section id="FilterExpression_Syntax">
      <title>Syntaxe des expressions de filtre</title>

      <para>
WinMerge permet un filtrage puissant à l'aide d'expressions opérant sur les
métadonnées des fichiers, leur contenu et le contexte de comparaison. Cette
section décrit les attributs, opérateurs, fonctions, types de données et
règles d'évaluation pris en charge.</para>

      <section id="FilterExpression_Literals">
        <title>Littéraux et types</title>

        <para>Les types de littéraux pris en charge incluent :</para>
        <itemizedlist>
          <listitem><para><emphasis>Booléen</emphasis> : <literal>true</literal>,
<literal>false</literal></para></listitem>
          <listitem><para><emphasis>Nul</emphasis> : <literal>none</literal> (représente une valeur
nulle ou manquante)</para></listitem>
          <listitem><para><emphasis>Entier</emphasis> : entiers signés 64 bits (ex :
<literal>1024</literal>, ou avec des unités comme <literal>100KB</literal>,
<literal>7days</literal>)</para></listitem>
          <listitem><para><emphasis>Réel (Double)</emphasis> : nombres à virgule flottante avec
décimale ou exposant facultatifs (ex : <literal>3.14</literal>,
<literal>.5</literal>, <literal>1e6</literal>)</para></listitem>
          <listitem><para><emphasis>Chaîne de caractères</emphasis> : entourée de guillemets doubles
(p. ex. <literal>"exemple"</literal>)</para></listitem>
          <listitem><para><emphasis>Date/Heure</emphasis> : Préfixée par <literal>d</literal> et
entourée de guillemets doubles (p. ex. <literal>d"2026-05-21
07:16:33"</literal>, <literal>d"2026-05-21"</literal>)</para></listitem>
        </itemizedlist>

        <para>
En interne, les valeurs peuvent être des types suivants : Booléen, Entier,
Réel, Horodatage, Chaîne de caractères, Contenu de fichier, Tableau ou
<literal>Aucun</literal>.</para>
      </section>

      <section id="FilterExpression_Directives">
        <title>Directives</title>

        <para>
Les expressions de filtre prennent en charge des directives qui contrôlent
la manière dont l'expression est évaluée. Les directives sont spécifiées au
début de l'expression, préfixées par <literal>@</literal>, et séparées de
l'expression par un espace.</para>

        <section id="FilterExpression_CaseSensitivity">
          <title>Directives de sensibilité à la casse</title>

          <para>
Par défaut, tous les opérateurs de comparaison de chaînes
(<literal>=</literal>, <literal>!=</literal>, <literal>&lt;</literal>,
<literal>&lt;=</literal>, <literal>&gt;</literal>, <literal>&gt;=</literal>,
<literal>contains</literal>, <literal>recontains</literal>,
<literal>like</literal>, <literal>matches</literal>) sont insensibles à la
casse. Vous pouvez contrôler ce comportement en utilisant les directives
suivantes :</para>

          <variablelist>
            <varlistentry>
              <term><literal>@cs</literal>, <literal>@casesensitive</literal></term>
              <listitem>
                <para>
Active la comparaison sensible à la casse. Avec ces directives,
<literal>"ABC"</literal> et <literal>"abc"</literal> sont considérés comme
différents.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><literal>@ci</literal>, <literal>@caseinsensitive</literal></term>
              <listitem>
                <para>
Active la comparaison insensible à la casse (comportement par défaut). Avec
ces directives, <literal>"ABC"</literal> et <literal>"abc"</literal> sont
considérés comme identiques.</para>
              </listitem>
            </varlistentry>
          </variablelist>

          <example>
            <title>Exemples de sensibilité à la casse</title>
<programlisting>@cs Name = "README.txt"           ## Sensible à la casse : correspond uniquement à "README.txt"
@ci Name = "readme.txt"           ## Insensible à la casse : correspond à "README.txt", "readme.txt", "ReadMe.TXT", etc.
@casesensitive Extension = "TXT"  ## Sensible à la casse : correspond uniquement aux fichiers avec l'extension ".TXT"
@caseinsensitive Content contains "error"  ## Insensible à la casse : correspond à "Error", "ERROR", "error", etc.</programlisting></example>
        </section>

        <section id="FilterExpression_Optimize">
          <title>Directives d'optimisation</title>

          <para>
Par défaut, les expressions de filtre sont optimisées pour améliorer les
performances. Vous pouvez contrôler ce comportement en utilisant les
directives suivantes :</para>

          <variablelist>
            <varlistentry>
              <term><literal>@optimize</literal>, <literal>@opt</literal></term>
              <listitem>
                <para>
Active l'optimisation des expressions de filtre (comportement par
défaut). Cela peut améliorer les performances pour les expressions
complexes.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><literal>@nooptimize</literal>, <literal>@noopt</literal></term>
              <listitem>
                <para>
Désactive l'optimisation des expressions de filtre. C'est utile pour le
débogage ou lorsque l'optimisation provoque des résultats inattendus.</para>
              </listitem>
            </varlistentry>
          </variablelist>

          <example>
            <title>Exemples d'optimisation</title>
<programlisting>@optimize Size &gt; 10MB and Extension = "log"     ## Active l'optimisation (par défaut)
@noopt Name matches "complex[0-9]+pattern"    ## Désactive l'optimisation pour le débogage
@nooptimize Content contains "special-case"   ## Désactive l'optimisation</programlisting></example>
        </section>

        <section id="FilterExpression_Name">
          <title>Directive Name</title>

          <para>
La directive <literal>@name</literal> vous permet d'attribuer un nom
descriptif à une expression de filtre. Ce nom est destiné à être utilisé
dans les messages d'erreur et les journaux pour aider à identifier
l'expression de filtre qui a causé un problème.</para>

          <variablelist>
            <varlistentry>
              <term><literal>@name="Filter Name"</literal>, <literal>@name=FilterName</literal></term>
              <listitem>
                <para>
Attribue un nom à l'expression de filtre. Si le nom contient des espaces ou
des caractères spéciaux, il doit être entouré de guillemets doubles. Les
noms sans espaces peuvent être spécifiés sans guillemets.</para>
                <para>
Le nom spécifié sera utilisé dans les messages d'erreur et les sorties de
diagnostic pour identifier le filtre. C'est particulièrement utile lors de
l'utilisation de multiples expressions de filtre complexes.</para>
              </listitem>
            </varlistentry>
          </variablelist>

          <example>
            <title>Exemples de la directive Name</title>
<programlisting>@name="Gros fichiers images" Size &gt; 10MB and Extension = "png"
@name=PetitsFichiersTexte Size &lt; 1KB and Extension = "txt"
@name="Modifié aujourd'hui" Date &gt;= today()
@name="Filtre de test" @cs Name like "test_*.cpp"</programlisting></example>

          <note>
            <para>
La directive <literal>@name</literal> peut être combinée avec d'autres
directives. Lorsque plusieurs directives sont utilisées, elles doivent
toutes apparaître au début de l'expression, séparées par un espace.</para>
          </note>
        </section>
      </section>

      <section id="FilterExpression_Attributes">
        <title>Attributs</title>

        <para>
Les expressions de filtre prennent en charge divers attributs se rapportant
aux métadonnées et au contenu des fichiers. Les noms d'attributs sont
insensibles à la casse. Vous pouvez éventuellement spécifier à quel côté de
la comparaison (gauche, droite ou milieu) un attribut s'applique en
utilisant un préfixe.</para>

        <section>
          <title>Attributs principaux</title>
          <variablelist>
            <varlistentry>
              <term><varname>Exists</varname></term>
              <listitem><para>Retourne <literal>true</literal> si le fichier existe,
<literal>false</literal> sinon</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Name</varname></term>
              <listitem><para>Nom du fichier</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>BaseName</varname></term>
              <listitem><para>Retourne le nom du fichier sans l'extension. Par exemple, « document.txt »
retourne « document ».</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Extension</varname></term>
              <listitem><para>Extension du fichier</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>IsFolder</varname></term>
              <listitem><para>Retourne true si l'élément est un dossier/répertoire, false si c'est un
fichier.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Folder</varname></term>
              <listitem><para>Retourne le chemin relatif en excluant le nom de fichier et le dossier de
base</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>RelPath</varname></term>
              <listitem><para>Renvoie le chemin relatif à partir du répertoire racine de comparaison,
incluant le chemin du dossier et le nom du fichier. Par exemple, si la
comparaison porte sur « C:\Project » et que le fichier se trouve dans «
C:\Project\src\main.cpp », RelPath renvoie « src\main.cpp ».</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>FullPath</varname></term>
              <listitem><para>Retourne le chemin complet du fichier</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Size</varname></term>
              <listitem><para>Taille du fichier</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Date</varname></term>
              <listitem><para>Horodatage de dernière modification</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>DateStr</varname></term>
              <listitem><para>Chaîne de date de dernière modification au format
<literal>yyyy-MM-dd</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>CreationTime</varname></term>
              <listitem><para>Horodatage de la date de création</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Attributes</varname></term>
              <listitem><para>Retourne les attributs de fichier sous forme d'entier</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>AttrStr</varname></term>
              <listitem>
                <para>Retourne la chaîne des attributs de fichier. Exemples :
<literal>"R"</literal> pour Lecture seule, <literal>"H"</literal> pour
Caché, <literal>"A"</literal> pour Archive, <literal>"S"</literal> pour
fichier Système.</para>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section>
          <title>Attributs spécifiques aux fichiers</title>
          <para>
Les attributs suivants sont disponibles uniquement pour les éléments de
comparaison de fichiers. Lorsqu'ils sont utilisés avec des dossiers, le
comportement est indéfini.</para>

          <variablelist>
            <varlistentry>
              <term><varname>Content</varname></term>
              <listitem><para>Contenu du fichier. Retourne une valeur de type FileContent. Seuls
<literal>contains</literal> et <literal>recontains</literal> peuvent être
utilisés avec ce type.</para></listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section>
          <title>Attributs spécifiques aux dossiers</title>
          <para>
Les attributs suivants sont disponibles uniquement pour les éléments de
comparaison de dossiers. Lorsqu'ils sont utilisés avec des fichiers, le
comportement est indéfini.</para>

          <variablelist>
            <varlistentry>
              <term><varname>Files</varname></term>
              <listitem><para>Nombre de fichiers directement contenus dans le dossier.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>RecursiveFiles</varname></term>
              <listitem><para>Nombre de fichiers contenus dans le dossier, incluant tous les
sous-dossiers.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Items</varname></term>
              <listitem><para>Nombre d'éléments (fichiers et sous-dossiers) directement contenus dans le
dossier.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>RecursiveItems</varname></term>
              <listitem><para>Nombre d'éléments (fichiers et sous-dossiers) contenus dans le dossier,
incluant tous les sous-dossiers.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>TotalSize</varname></term>
              <listitem><para>Taille totale de tous les fichiers directement contenus dans le dossier, en
octets.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>RecursiveTotalSize</varname></term>
              <listitem><para>Taille totale de tous les fichiers contenus dans le dossier, incluant tous
les sous-dossiers, en octets.</para></listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section>
          <title>Préfixes spécifiques au côté</title>
          <para>
Des préfixes peuvent être ajoutés pour spécifier le côté de la comparaison :</para>
          <itemizedlist>
            <listitem><para><emphasis>Left</emphasis> : S'applique au fichier du côté gauche (par ex.,
<literal>LeftSize</literal>)</para></listitem>
            <listitem><para><emphasis>Right</emphasis> : S'applique au fichier du côté droit (par ex.,
<literal>RightDate</literal>)</para></listitem>
            <listitem><para><emphasis>Middle</emphasis> : S'applique au fichier du milieu dans une
comparaison à 3 voies (par ex., <literal>MiddleName</literal>)</para></listitem>
          </itemizedlist>

          <para>
Les attributs sans préfixe (par ex. <literal>Size</literal>) renvoient un
tableau de valeurs de tous les côtés disponibles (Gauche, Milieu, Droite).</para>
        </section>

        <section>
          <title>Attributs de propriétés Windows</title>
          <para>
Ces attributs permettent d'accéder aux valeurs du système de propriétés
Windows, telles que les métadonnées définies par le schéma du système de
propriétés Windows (par ex. <literal>System.Title</literal>,
<literal>System.FileOwner</literal>,
<literal>System.Image.HorizontalResolution</literal>).</para>

          <variablelist>
            <varlistentry>
              <term><varname>Prop</varname></term>
              <listitem>
                <para>
Renvoie un tableau de valeurs de propriété (Gauche, Milieu, Droite) pour le
nom de propriété canonique spécifié. Exemple :
<literal>prop("System.Title")</literal></para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>LeftProp</varname></term>
              <listitem>
                <para>
Valeur de propriété du fichier du côté gauche. Exemple :
<literal>leftprop("System.FileOwner")</literal></para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>MiddleProp</varname></term>
              <listitem>
                <para>Valeur de propriété du fichier du milieu (dans une comparaison à 3 voies).</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>RightProp</varname></term>
              <listitem>
                <para>Valeur de propriété du fichier du côté droit.</para>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section>
          <title>Attributs pour les filtres d'affichage uniquement</title>
          <para>
Les attributs suivants sont conçus pour être utilisés dans les <emphasis
role="bold">filtres d'affichage uniquement</emphasis> (spécifiés via les
préfixes <guilabel>e:</guilabel>, <guilabel>e!:</guilabel>,
<guilabel>fe:</guilabel>, <guilabel>fe!:</guilabel>,
<guilabel>de:</guilabel>, ou <guilabel>de!:</guilabel> dans le champ
Filtre). Ils ne doivent pas être utilisés dans les règles
d'inclusion/exclusion des filtres de fichiers (<filename>.flt</filename>),
car ils nécessitent que la comparaison soit d'abord terminée et peuvent
conduire à un comportement inattendu.</para>

          <variablelist>
            <varlistentry>
              <term><varname>Identical</varname></term>
              <listitem>
                <para>
Renvoie <literal>true</literal> si le résultat de la comparaison indique que
les éléments sont identiques, <literal>false</literal> sinon. Il s'agit d'un
attribut global (ne prend pas en charge les préfixes de côté). Exemple :
<literal>Identical</literal> pour n'afficher que les fichiers identiques.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Different</varname></term>
              <listitem>
                <para>
Renvoie <literal>true</literal> si le résultat de la comparaison indique que
les éléments sont différents, <literal>false</literal> sinon. Il s'agit d'un
attribut global (ne prend pas en charge les préfixes de côté). Exemple :
<literal>Different</literal> pour n'afficher que les fichiers différents.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Skipped</varname></term>
              <listitem>
                <para>
Renvoie <literal>true</literal> si la comparaison a été ignorée en raison
d'une erreur ou d'une règle de filtrage, <literal>false</literal> sinon. Il
s'agit d'un attribut global (ne prend pas en charge les préfixes de
côté). Exemple : <literal>Skipped</literal> pour n'afficher que les éléments
ignorés.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Binary</varname></term>
              <listitem>
                <para>
Renvoie <literal>true</literal> si le fichier est détecté comme binaire,
<literal>false</literal> s'il s'agit d'un fichier texte, ou
<literal>none</literal> si le fichier n'existe pas. Cet attribut prend en
charge les préfixes spécifiques au type de codage
(p. ex. <literal>LeftBinary</literal>,
<literal>RightBinary</literal>). Exemple : <literal>allof(Binary)</literal>
pour afficher les fichiers binaires des deux côtés.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>DifferentLeftMiddle</varname></term>
              <listitem>
                <para>
Renvoie <literal>true</literal> si les fichiers de gauche et du milieu
diffèrent lors d'une comparaison à trois voies, <literal>false</literal>
sinon. Renvoie <literal>none</literal> lors d'une comparaison à deux
voies. Il s'agit d'un attribut global (ne prend pas en charge les préfixes
spécifiques à un côté). Exemple : <literal>DifferentLeftMiddle and not
DifferentMiddleRight</literal> pour trouver les fichiers où seul le fichier
de gauche diffère de celui du milieu.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>DifferentMiddleRight</varname></term>
              <listitem>
                <para>
Renvoie <literal>true</literal> si les fichiers du milieu et de droite
diffèrent lors d'une comparaison à trois voies, <literal>false</literal>
sinon. Renvoie <literal>none</literal> lors d'une comparaison à deux
voies. Il s'agit d'un attribut global (ne prend pas en charge les préfixes
spécifiques à un côté). Exemple : <literal>DifferentMiddleRight</literal>
pour afficher les fichiers où les fichiers du milieu et de droite diffèrent.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>DifferentLeftRight</varname></term>
              <listitem>
                <para>
Dans les comparaisons à 3 voies, renvoie <literal>true</literal> si les
fichiers de gauche et de droite sont différents, <literal>false</literal>
sinon. Dans les comparaisons à 2 voies, renvoie <literal>true</literal> si
les deux fichiers existent et sont différents. Il s'agit d'un attribut
global. Exemple : <literal>DifferentLeftRight</literal> pour afficher les
fichiers où la gauche et la droite diffèrent.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Differences</varname></term>
              <listitem>
                <para>
Renvoie le nombre de différences de texte dans la comparaison de
fichiers. Cet attribut n'est significatif que pour les fichiers texte qui
ont été comparés. Il s'agit d'un attribut global. Exemple :
<literal>Differences &gt; 0</literal> pour afficher les fichiers présentant
des différences, ou <literal>Differences &gt; 10</literal> pour les fichiers
avec plus de 10 différences.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>IgnoredDiffs</varname></term>
              <listitem>
                <para>
Renvoie le nombre de différences ignorées lors de la comparaison de fichiers
(différences filtrées par les filtres de ligne ou les paramètres
d'espaces). Cet attribut n'est significatif que pour les fichiers texte qui
ont été comparés. Il s'agit d'un attribut global (ne prend pas en charge les
préfixes de côté). Exemple : <literal>IgnoredDiffs &gt; 0</literal> pour
afficher les fichiers avec des différences ignorées, ou <literal>Differences
= 0 and IgnoredDiffs &gt; 0</literal> pour afficher les fichiers identiques
à l'exception des différences ignorées.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Unpacker</varname></term>
              <listitem>
                <para>
Renvoie le nom du plug-in de décompression utilisé pour la comparaison de
fichiers, ou une chaîne vide si aucun n'a été utilisé. Il s'agit d'un
attribut global. Exemple : <literal>Unpacker =
"CompareMSExcelFiles"</literal> pour afficher les fichiers comparés via le
décompresseur Excel, ou <literal>Unpacker != ""</literal> pour afficher tous
les fichiers où un décompresseur a été utilisé.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Prediffer</varname></term>
              <listitem>
                <para>
Renvoie le nom du plug-in prediffer utilisé pour la comparaison de fichiers,
ou une chaîne vide si aucun n'a été utilisé. Il s'agit d'un attribut
global. Exemple : <literal>Prediffer = "IgnoreColumns"</literal> pour
afficher les fichiers comparés avec le prediffer IgnoreColumns, ou
<literal>Prediffer != ""</literal> pour afficher tous les fichiers où un
prediffer a été utilisé.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>EOL</varname></term>
              <listitem>
                <para>Renvoie le style de fin de ligne (EOL) sous forme d'entier. Pour les
fichiers, renvoie le style EOL prédominant ; pour les lignes, renvoie le
style EOL de la ligne concernée.</para>
                <para>Valeurs : 0 = Aucun, 1 = LF (Unix), 2 = CR (Mac), 3 = CRLF (Windows), 4 =
Mixte (plusieurs styles de fin de ligne dans le fichier)</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>EOLStr</varname></term>
              <listitem>
                <para>Renvoie le style de fin de ligne (EOL) sous forme de chaîne de
caractères. Pour les fichiers, renvoie le style EOL prédominant; pour les
lignes, renvoie le style EOL de la ligne concernée.</para>
                <para>Valeurs : « Aucun », « LF », « CR », « CRLF », « Mixte »</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Codepage</varname></term>
              <listitem>
                <para>
Renvoie la page de code du fichier (encodage des caractères) sous forme
d'entier. Cet attribut prend en charge les préfixes spécifiques au côté
(ex. <literal>LeftCodepage</literal>,
<literal>RightCodepage</literal>). Exemple : <literal>Codepage =
65001</literal> pour afficher les fichiers UTF-8, ou <literal>allof(Codepage
= 65001)</literal> pour afficher les fichiers qui sont en UTF-8 de tous les
côtés.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>HasBOM</varname></term>
              <listitem>
                <para>
Renvoie <literal>true</literal> si le fichier possède une marque d'ordre des
octets (BOM), <literal>false</literal> sinon. Cet attribut prend en charge
les préfixes spécifiques au côté. Exemple : <literal>HasBOM</literal> pour
afficher les fichiers avec BOM, ou <literal>not HasBOM</literal> pour
afficher les fichiers sans BOM.</para>
              </listitem>
            </varlistentry>

          </variablelist>
        </section>

        <section id="FilterExpression_ArrayEvaluation">
          <title>Évaluation de tableau</title>

          <para>
Les attributs sans préfixe de côté (par ex. <literal>Size</literal>)
renvoient un tableau de valeurs de tous les côtés disponibles (Gauche,
Milieu, Droite). Lors de l'application d'un opérateur à de tels tableaux, le
comportement diffère selon que la comparaison se fait avec un scalaire ou un
autre tableau.</para>

          <section id="FilterExpression_ArrayVsScalar">
            <title>Tableau vs Scalaire</title>
            <para>
Lors de la comparaison d'un tableau à un scalaire, l'opération est appliquée
à chaque élément du tableau individuellement. Cela donne un tableau de
booléens. Si un élément de ce tableau est <literal>true</literal>,
l'expression globale est évaluée à <literal>true</literal>. Sinon, elle est
évaluée à <literal>false</literal>.</para>
            <example>
              <title>Exemple</title>
<programlisting>[3, 5, 8] &gt; 6 -> [false, false, true] -> true</programlisting></example>
          </section>

          <section id="FilterExpression_ArrayVsArray">
            <title>Tableau vs Tableau</title>
            <para>
Lors de la comparaison de deux tableaux, le comportement dépend de
l'opérateur :</para>
            <itemizedlist>
              <listitem>
                <para>
Pour <literal>=</literal> et <literal>!=</literal> : Les tableaux doivent
avoir la même longueur. Le résultat est une valeur booléenne unique, pas un
tableau. <literal>=</literal> renvoie <literal>true</literal> uniquement si
tous les éléments sont égaux. <literal>!=</literal> renvoie
<literal>true</literal> si au moins un élément diffère.</para>
              </listitem>
              <listitem>
                <para>
Pour tous les autres opérateurs (par ex. <literal>&gt;</literal>,
<literal>&lt;</literal>) : l'opération est appliquée élément par élément,
produisant un tableau de booléens. Le résultat final de l'expression est
<literal>true</literal> si n'importe quel élément du tableau booléen est
<literal>true</literal>, et <literal>false</literal> si tous les éléments
sont <literal>false</literal>.</para>
              </listitem>
            </itemizedlist>

            <example>
              <title>Exemples</title>
<programlisting>[2, 4] = [2, 4] -> true</programlisting> <programlisting>[2, 4] != [2, 5] -> true (car 4 != 5)</programlisting> <programlisting>[3, 5, 8] &gt; [6, 4, 2]
 -> [false, true, true]
 -> true (car au moins une comparaison est vraie)
              </programlisting></example>
          </section>

          <section id="FilterExpression_ArraySummary">
            <title>Résumé</title>
            <itemizedlist>
              <listitem>
                <para>
Les comparaisons Tableau vs Scalaire produisent un tableau de booléens. Le
résultat global de l'expression est <literal>true</literal> si au moins un
élément est <literal>true</literal>.</para>
              </listitem>
              <listitem>
                <para>
La comparaison Tableau vs Tableau avec <literal>=</literal> ou
<literal>!=</literal> renvoie une valeur booléenne unique.</para>
              </listitem>
              <listitem>
                <para>
La comparaison Tableau vs Tableau avec d'autres opérateurs produit un
tableau de booléens. Le résultat final est <literal>true</literal> si
n'importe quel élément est <literal>true</literal>.</para>
              </listitem>
            </itemizedlist>
          </section>
        </section>
      </section>

      <section id="FilterExpression_Operators">
        <title>Opérateurs</title>

        <para>
Par défaut, tous les opérateurs de comparaison de chaînes (tels que
<literal>=</literal>, <literal>!=</literal>, <literal>&lt;</literal>,
<literal>&lt;=</literal>, <literal>&gt;</literal>, <literal>&gt;=</literal>,
<literal>like</literal>, <literal>matches</literal>,
<literal>contains</literal> et <literal>recontains</literal>) sont
insensibles à la casse. Vous pouvez contrôler ce comportement à l'aide de
directives (voir <xref linkend="FilterExpression_CaseSensitivity" />).</para>

        <variablelist>
          <varlistentry>
            <term><literal>&lt;</literal>, <literal>&lt;=</literal>, <literal>&gt;</literal>,
<literal>&gt;=</literal></term>
            <listitem><para>Comparaison numérique, d'horodatage ou de chaîne</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>=</literal></term>
            <listitem><para>Comparaison d'égalité</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>!=</literal></term>
            <listitem><para>Comparaison d'inégalité</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>+</literal>, <literal>-</literal>, <literal>*</literal>,
<literal>/</literal>, <literal>%</literal></term>
            <listitem>
              <para>
Opérateurs arithmétiques. <literal>+</literal> et <literal>-</literal>
effectuent l'addition et la soustraction. <literal>*</literal> et
<literal>/</literal> effectuent la multiplication et la
division. <literal>%</literal> est l'opérateur modulo (reste).</para>
            </listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>and</literal>, <literal>or</literal>, <literal>not</literal></term>
            <listitem><para>Opérateurs logiques</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>like</literal></term>
            <listitem>
              <para>Correspondance de chaîne avec caractères génériques</para>
              <para>Vous pouvez également utiliser <literal>not like</literal> pour effectuer la
correspondance inverse.</para>
            </listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>matches</literal></term>
            <listitem>
              <para>Correspondance par expressions régulières</para>
              <para>Vous pouvez également utiliser <literal>not matches</literal> pour effectuer
la correspondance inverse.</para>
            </listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>contains</literal></term>
            <listitem>
              <para>Vérifie si une chaîne contient une sous-chaîne</para>
              <para>Vous pouvez également utiliser <literal>not contains</literal> pour vérifier
l'absence de la sous-chaîne.</para>
            </listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>recontains</literal></term>
            <listitem>
              <para>Vérifie si une sous-chaîne correspond à une expression régulière</para>
              <para>Vous pouvez également utiliser <literal>not recontains</literal> pour
garantir qu'aucune correspondance n'existe.</para>
            </listitem>
          </varlistentry>
        </variablelist>
      </section>

      <section id="FilterExpression_Functions">
        <title>Fonctions</title>

        <para>
Les expressions de filtrage prennent en charge diverses fonctions de
manipulation et d'analyse des données. Ces fonctions sont organisées par
catégorie pour faciliter leur consultation.</para>

        <section id="FilterExpression_StringFunctions">
          <title>Fonctions de chaînes de caractères</title>
          <variablelist>
            <varlistentry>
              <term><function>strlen</function>(<replaceable>source</replaceable>)</term>
              <listitem><para>Renvoie la longueur de la chaîne sous forme d'un
<literal>Integer</literal>. Si <replaceable>source</replaceable> est un
tableau de chaînes, le résultat est un tableau d'entiers. Exemple :
<literal>strlen(Name)</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>strCount</function>(<replaceable>str</replaceable>,
<replaceable>substr</replaceable>)</term>
              <listitem>
                <para>
Compte le nombre d'occurrences de la sous-chaîne
<replaceable>substr</replaceable> dans <replaceable>str</replaceable>. La
recherche est insensible à la casse par défaut (respecte les directives
<literal>@cs</literal> et <literal>@ci</literal>). Si
<replaceable>str</replaceable> est un tableau, le résultat est un tableau
d'entiers contenant le nombre d'occurrences de chaque élément. Les
correspondances qui se chevauchent sont comptées séparément
(p. ex. <literal>strCount("aaaa", "aa")</literal> renvoie 2).</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>strCount("hello hello world", "hello")</literal> renvoie 2</para></listitem>
                  <listitem><para><literal>strCount("Test TEST test", "test")</literal> renvoie 3 (sans tenir
compte de la casse)</para></listitem>
                  <listitem><para><literal>@cs strCount("Test TEST test", "test")</literal> renvoie 1
(sensible à la casse)</para></listitem>
                  <listitem><para><literal>le:strCount(Line, "ERROR") > 2</literal> affiche les lignes
contenant « ERROR » plus de deux fois</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>regexCount</function>(<replaceable>str</replaceable>,
<replaceable>pattern</replaceable>)</term>
              <listitem>
                <para>
Compte le nombre de fois où l'expression régulière
<replaceable>pattern</replaceable> est trouvée dans
<replaceable>str</replaceable>. La recherche est insensible à la casse par
défaut (respecte les directives <literal>@cs</literal> et
<literal>@ci</literal>). Si <replaceable>str</replaceable> est un tableau,
le résultat est un tableau d'entiers contenant le nombre d'occurrences de
chaque élément. Les correspondances vides sont gérées de manière élégante
afin d'éviter les boucles infinies.</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>regexCount("test123abc456", "\d+")</literal> renvoie 2</para></listitem>
                  <listitem><para><literal>regexCount("AAA BBB CCC", "[A-Z]+")</literal> renvoie 3</para></listitem>
                  <listitem><para><literal>@cs regexCount("Test TEST", "TEST")</literal> renvoie 1</para></listitem>
                  <listitem><para><literal>le:regexCount(Line, "\b(error|warning)\b") > 0</literal> affiche
les lignes contenant les mots-clés d'erreur ou d'avertissement</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>strFind</function>(<replaceable>str</replaceable>,
<replaceable>substr</replaceable>[, <replaceable>occurrence</replaceable>])</term>
              <listitem>
                <para>
Trouve la position (à partir de 0) de la Nième occurrence de la sous-chaîne
<replaceable>substr</replaceable> dans <replaceable>str</replaceable>. Le
paramètre optionnel <replaceable>occurrence</replaceable> spécifie
l'occurrence à rechercher (à partir de 0, par défaut 0 pour la première
occurrence). La recherche est insensible à la casse par défaut (respecte les
directives `@cs` et `@ci`). Renvoie `none` si la sous-chaîne est introuvable
ou si l'indice d'occurrence est hors limites. Si
<replaceable>str</replaceable> est un tableau, le résultat est un tableau de
positions (ou la valeur `none`).</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>strFind("hello world", "o")</literal> renvoie 4 (premier 'o')</para></listitem>
                  <listitem><para><literal>strFind("hello world", "o", 1)</literal> renvoie 7 (deuxième 'o')</para></listitem>
                  <listitem><para><literal>@cs strFind("Test TEST test", "test")</literal> renvoie 10
(sensible à la casse)</para></listitem>
                  <listitem><para><literal>strFind(array("abc", "def"), "b")</literal> renvoie
<literal>array(1, none)</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>regexFind</function>(<replaceable>str</replaceable>,
<replaceable>pattern</replaceable>[, <replaceable>group</replaceable>[,
<replaceable>occurrence</replaceable>]])</term>
              <listitem>
                <para>
Trouve la position (à partir de 0) de la Nième occurrence d'une
correspondance d'expression régulière dans
<replaceable>str</replaceable>. Le paramètre optionnel
<replaceable>group</replaceable> spécifie le groupe de capture à rechercher
(indexé à partir de 0, par défaut 0 pour la correspondance entière). Le
paramètre optionnel <replaceable>occurrence</replaceable> spécifie
l'occurrence du motif à rechercher (indexé à partir de 0, par défaut 0 pour
la première occurrence). La recherche est insensible à la casse par défaut
(respecte les directives <literal>@cs</literal> et
<literal>@ci</literal>). Renvoie <literal>none</literal> si le motif ne
correspond pas, si l'index du groupe ou l'index de l'occurrence est hors
limites. Si <replaceable>str</replaceable> est un tableau, le résultat est
un tableau de positions (ou la valeur « none »).</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>regexFind("test123abc456", "\d+")</literal> renvoie 4 (position de
« 123 »)</para></listitem>
                  <listitem><para><literal>regexFind("test123abc456", "\d+", 0, 1)</literal> renvoie 10
(position de « 456 », deuxième correspondance)</para></listitem>
                  <listitem><para><literal>regexFind("abc-def-ghi", "([a-z]+)-([a-z]+)", 1)</literal> renvoie
0 (position du premier groupe de capture « abc »)</para></listitem>
                  <listitem><para><literal>regexFind("v1.0 and v2.5", "v(\d+)\.(\d+)", 1, 1)</literal> renvoie
10 (version majeure « 2 » dans la deuxième occurrence)</para></listitem>
                  <listitem><para><literal>regexFind(array("test123", "abc"), "\d+")</literal> renvoie
<literal>array(4, none)</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>substr</function>(<replaceable>source</replaceable>,
<replaceable>start</replaceable>, <replaceable>count</replaceable>)</term>
              <listitem><para>Renvoie une plage de texte spécifique de la <emphasis>chaîne ou du tableau
de chaînes</emphasis> sous forme d'une <literal>String</literal>. Si
<replaceable>source</replaceable> est un tableau de chaînes, le résultat est
un tableau de chaînes. Exemple : <literal>substr(Name, 0, 3)</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>replace</function>(str, from, to)</term>
              <listitem>
                <para>
Remplace toutes les occurrences de la chaîne <replaceable>from</replaceable>
par <replaceable>to</replaceable>. Si <replaceable>str</replaceable> est un
tableau, le résultat est un tableau de chaînes avec les remplacements
appliqués. Exemple : <literal>replace(name, ".bak", ".txt")</literal></para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>regexReplace</function>(str, pattern, replacement)</term>
              <listitem>
                <para>
Remplace toutes les correspondances du motif d'expression régulière par la
chaîne de remplacement. Prend en charge les références arrière ($1, $2,
etc.) dans la chaîne de remplacement. Si <replaceable>str</replaceable> est
un tableau, le résultat est un tableau de chaînes avec les remplacements
appliqués. Exemple : <literal>regexReplace(name, "^(\w+)_(\w+)$",
"$2_$1")</literal> permute des mots séparés par un souligné.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>replaceWithList</function>(str, filepath)</term>
              <listitem>
                <para>
Remplace plusieurs chaînes de caractères dans <replaceable>str</replaceable>
en utilisant des règles de remplacement chargées depuis un fichier séparé
par des tabulations. Le format du fichier est le suivant : une règle de
remplacement par ligne :
<literal>search_string&lt;TAB&gt;replacement_string</literal>. Les lignes
commençant par <literal>#</literal> sont considérées comme des commentaires
et ignorées. Les lignes vides sont également ignorées. Si
<replaceable>str</replaceable> est un tableau, le résultat est un tableau de
chaînes avec les remplacements appliqués.</para>
                <para>Exemple de format de fichier :</para>
                <screen># Ligne de commentaire
pomme	orange
chat	chien
ancien	nouveau</screen>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>replaceWithList(Name, "C:\Filters\replacements.txt")</literal> -
applique les remplacements du fichier au nom du fichier</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>regexReplaceWithList</function>(str, filepath)</term>
              <listitem>
                <para>
Remplace les chaînes de caractères dans <replaceable>str</replaceable> à
l'aide d'expressions régulières chargées depuis un fichier séparé par des
tabulations. Le format du fichier est le suivant : une expression régulière
par ligne :
<literal>regex_pattern&lt;TAB&gt;replacement_string</literal>. La chaîne de
remplacement peut inclure des références arrière ($1, $2, etc.) vers des
groupes capturés. Les lignes commençant par <literal>#</literal> sont
considérées comme des commentaires et ignorées. Les lignes vides sont
également ignorées. Si <replaceable>str</replaceable> est un tableau, le
résultat est un tableau de chaînes avec les remplacements appliqués.</para>
                <para>Exemple de format de fichier :</para>
                <screen># Ligne de commentaire
\d+	NOMBRE
(\d{4})-(\d{2})-(\d{2})	$1_$2_$3</screen>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>regexReplaceWithList(Name,
"C:\Filters\regex_replacements.txt")</literal> - applique des remplacements
d'expressions régulières au nom du fichier</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>regexExtract</function>(<replaceable>str</replaceable>,
<replaceable>pattern</replaceable>[, <replaceable>group</replaceable>[,
<replaceable>offset</replaceable>]])</term>
              <listitem>
                <para>
Capture le texte correspondant à un motif d'expression régulière dans la
chaîne. Le paramètre optionnel <replaceable>group</replaceable> spécifie le
groupe de capture à extraire (indexé à partir de 0). Le groupe 0 (par
défaut) renvoie la correspondance complète ; les groupes 1, 2,
etc. renvoient les groupes de capture correspondants définis entre
parenthèses dans le motif. Le paramètre optionnel
<replaceable>offset</replaceable> spécifie l'occurrence du motif à capturer
(indexé à partir de 0). L'offset 0 (par défaut) renvoie la première
occurrence ; l'offset 1 renvoie la deuxième, etc. Ceci est utile pour
capturer la Nième occurrence dans une ligne, comme le deuxième chiffre d'une
chaîne. Renvoie <literal>none</literal> si le motif ne correspond à aucune
occurrence, si l'index du groupe est hors limites ou si l'offset dépasse le
nombre d'occurrences. Si <replaceable>str</replaceable> est un tableau, le
résultat est un tableau contenant les captures pour chaque élément. La
recherche est insensible à la casse par défaut (respecte les directives
<literal>@cs</literal>/<literal>@ci</literal>).</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>regexExtract("abc123", "[a-z]+\d+")</literal> renvoie
<literal>"abc123"</literal> (correspondance complète)</para></listitem>
                  <listitem><para><literal>regexExtract("abc123", "([a-z]+)(\d+)", 1)</literal> renvoie
<literal>"abc"</literal> (premier groupe de capture)</para></listitem>
                  <listitem><para><literal>regexExtract("abc123", "([a-z]+)(\d+)", 2)</literal> renvoie
<literal>"123"</literal> (deuxième groupe de capture)</para></listitem>
                  <listitem><para><literal>regexExtract("2025-05-16", "(\d{4})-(\d{2})-(\d{2})", 1)</literal>
renvoie <literal>"2025"</literal></para></listitem>
                  <listitem><para><literal>regexExtract("user@example.com", "([^@]+)@([^@]+)", 1)</literal>
renvoie <literal>"user"</literal></para></listitem>
                  <listitem><para><literal>regexExtract("user@example.com", "([^@]+)@([^@]+)", 2)</literal>
renvoie <literal>"example.com"</literal></para></listitem>
                  <listitem><para><literal>regexExtract("value 123 and value 456", "(\d+)", 0, 0)</literal>
renvoie <literal>"123"</literal> (premier nombre)</para></listitem>
                  <listitem><para><literal>regexExtract("value 123 and value 456", "(\d+)", 0, 1)</literal>
renvoie <literal>"456"</literal> (deuxième nombre)</para></listitem>
                  <listitem><para><literal>regexExtract("v1.0.0 et v2.0.0", "v(\d+)\.(\d+)\.(\d+)", 1,
1)</literal> renvoie <literal>"2"</literal> (version majeure de la deuxième
occurrence)</para></listitem>
                  <listitem><para><literal>regexExtract("test", "\d+")</literal> renvoie
<literal>none</literal> (aucune correspondance)</para></listitem>
                  <listitem><para><literal>regexExtract("abc", "([a-z])", 5)</literal> renvoie
<literal>aucun</literal> (groupe hors limites)</para></listitem>
                  <listitem><para><literal>regexExtract(array("abc123", "def456"), "([a-z]+)(\d+)",
1)</literal> renvoie <literal>array("abc", "def")</literal></para></listitem>
                  <listitem><para>L'expression régulière `@cs regexExtract("ABC123", "([a-z]+)", 1)` renvoie
`none` (sensible à la casse, aucune correspondance).</para></listitem>
                  <listitem><para><literal>le:regexExtract(Line, "error:\s+(\w+)", 1)</literal> extrait le
type d'erreur des lignes de journal</para></listitem>
                  <listitem><para><literal>fe:regexExtract(Name, "v(\d+)\.(\d+)\.(\d+)", 1) = "2"</literal>
filtre les fichiers dont la version majeure est 2</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>normalizeUnicode</function>(str[, form])</term>
              <listitem>
                <para>
Normalise la chaîne Unicode. Le paramètre optionnel 'form' spécifie la forme
de normalisation : "NFC" ou "C" (par défaut), "NFD" ou "D", "NFKC" ou "KC",
"NFKD" ou "KD". On peut aussi utiliser les formes numériques : 1=NFC, 2=NFD,
5=NFKC, 6=NFKD. Si <replaceable>str</replaceable> est un tableau, le
résultat est un tableau de chaînes normalisées. Exemple :
<literal>normalizeUnicode(name, "NFC")</literal></para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toLower</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Convertit tous les caractères de la chaîne en minuscules. Si
<replaceable>str</replaceable> est un tableau, le résultat est un tableau de
chaînes en minuscules. Exemple : <literal>toLower("Hello World")</literal>
renvoie <literal>"hello world"</literal></para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toUpper</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Convertit tous les caractères de la chaîne en majuscules. Si
<replaceable>str</replaceable> est un tableau, le résultat est un tableau de
chaînes en majuscules. Exemple : <literal>toUpper("Hello World")</literal>
renvoie <literal>"HELLO WORLD"</literal></para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toHalfWidth</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Convertit les caractères de pleine chasse (full-width) en caractères de
demi-chasse (half-width). Principalement utilisé pour convertir les
caractères alphanumériques et katakana de pleine chasse en demi-chasse. Si
<replaceable>str</replaceable> est un tableau, le résultat est un tableau de
chaînes converties.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toFullWidth</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Convertit les caractères de demi-chasse en caractères de pleine
chasse. Principalement utilisé pour convertir les caractères alphanumériques
et katakana de demi-chasse en pleine chasse. Si
<replaceable>str</replaceable> est un tableau, le résultat est un tableau de
chaînes converties.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toKatakana</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Convertit les caractères hiragana en katakana. Les caractères non-hiragana
restent inchangés. Si <replaceable>str</replaceable> est un tableau, le
résultat est un tableau de chaînes converties.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toHiragana</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Convertit les caractères katakana en hiragana. Les caractères non-katakana
restent inchangés. Si <replaceable>str</replaceable> est un tableau, le
résultat est un tableau de chaînes converties.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toSimplifiedChinese</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Convertit les caractères chinois traditionnels en caractères chinois
simplifiés. Les caractères qui n'ont pas de forme simplifiée restent
inchangés. Si <replaceable>str</replaceable> est un tableau, le résultat est
un tableau de chaînes converties.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toTraditionalChinese</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Convertit les caractères chinois simplifiés en caractères chinois
traditionnels. Les caractères qui n'ont pas de forme traditionnelle restent
inchangés. Si <replaceable>str</replaceable> est un tableau, le résultat est
un tableau de chaînes converties.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>trim</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Supprime les espaces en début et en fin de chaîne (espace, tabulation, saut
de ligne, retour chariot). Si <replaceable>str</replaceable> est un tableau,
le résultat est un tableau de chaînes tronquées.</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>trim("hello ")</literal> renvoie <literal>"hello"</literal></para></listitem>
                  <listitem><para><literal>trim(array(" test ", " data "))</literal> renvoie
<literal>array("test", "data")</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>trimLeft</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Supprime les espaces de début (espace, tabulation, saut de ligne, retour
chariot) de la chaîne. Les espaces de fin sont conservés. Si
<replaceable>str</replaceable> est un tableau, le résultat est un tableau de
chaînes tronquées à gauche.</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>trimLeft(" bonjour ")</literal> renvoie <literal>"bonjour
"</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>trimRight</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Supprime les espaces de fin de chaîne (espace, tabulation, saut de ligne,
retour chariot). Les espaces de début sont conservés. Si
<replaceable>str</replaceable> est un tableau, le résultat est un tableau de
chaînes tronquées à droite.</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>trimRight(" hello ")</literal> renvoie <literal>" hello"</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_FileContentFunctions">
          <title>Fonctions de contenu de fichier</title>
          <variablelist>
            <varlistentry>
              <term><function>lineCount</function>(<replaceable>content</replaceable>)</term>
              <listitem><para>Renvoie le nombre de lignes dans le contenu du fichier ou le tableau de
contenu de fichier sous forme d'un <literal>Integer</literal>. Si
<replaceable>content</replaceable> est un tableau, le résultat est un
tableau d'entiers. Exemple : <literal>lineCount(Content)</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>sublines</function>(<replaceable>content</replaceable>,
<replaceable>start</replaceable>, <replaceable>count</replaceable>)</term>
              <listitem>
                <para>
Extrait le nombre spécifié de lignes en commençant par l'index de ligne
donné dans le contenu du fichier ou le tableau de contenu de fichier, et les
renvoie sous la forme d'une seule chaîne concaténée. Si
<replaceable>content</replaceable> est un tableau, le résultat est un
tableau de chaînes.</para>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_TypeConversionFunctions">
          <title>Fonctions de conversion de type</title>
          <variablelist>
            <varlistentry>
              <term><function>toNumber</function>(<replaceable>str</replaceable>),
<function>toInt</function>(<replaceable>str</replaceable>),
<function>toDouble</function>(<replaceable>str</replaceable>)</term>
              <listitem><para>Convertit une chaîne de caractères en nombre. La fonction
<function>toNumber</function> renvoie un entier ou un nombre à virgule
flottante selon le format d'entrée; la fonction <function>toInt</function>
renvoie uniquement des entiers; la fonction <function>toDouble</function>
renvoie uniquement des nombres à virgule flottante. Les virgules dans
l'entrée sont ignorées. En cas d'échec de l'analyse syntaxique, la fonction
renvoie <literal>none</literal>. Exemple :
<literal>le:toInt(Column("Count")) &gt; 100</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>toDateTime</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Convertit une chaîne de caractères en une valeur d'horodatage. Prend en
charge plusieurs formats de date et d'heure. Renvoie <literal>none</literal>
si la chaîne ne peut pas être analysée. Exemple :
<literal>toDateTime("2025-01-15") &gt; today()</literal></para>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_DateTimeFunctions">
          <title>Fonctions de date/heure</title>
          <variablelist>
            <varlistentry>
              <term><function>now</function>()</term>
              <listitem><para>Renvoie la date et l'heure actuelles sous forme d'une valeur
<literal>Timestamp</literal>.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>today</function>()</term>
              <listitem><para>Renvoie la date du jour sous forme d'une valeur <literal>Timestamp</literal>
représentant <literal>00:00:00.000</literal> au début de la journée.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>startOfWeek</function>(<replaceable>timestamp</replaceable>)</term>
              <listitem><para>Renvoie le premier jour de la semaine, qui est toujours le dimanche quel que
soit le paramètre régional.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>startOfMonth</function>(<replaceable>timestamp</replaceable>)</term>
              <listitem><para>Renvoie le premier jour du mois.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>startOfYear</function>(<replaceable>timestamp</replaceable>)</term>
              <listitem><para>Renvoie le premier jour de l'année.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>toDateStr</function>(<replaceable>timestamp</replaceable>)</term>
              <listitem><para>Convertit l'horodatage donné en une chaîne de date au format
<literal>yyyy-MM-dd</literal>. Si <replaceable>timestamp</replaceable> est
un tableau d'horodatages, le résultat est un tableau de chaînes.</para></listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_MathFunctions">
          <title>Fonctions mathématiques et de comparaison</title>
          <variablelist>
            <varlistentry>
              <term><function>abs</function>(<replaceable>value</replaceable>)</term>
              <listitem><para>Renvoie la valeur absolue de l'entier ou du tableau d'entiers. Si
<replaceable>value</replaceable> est un tableau d'entiers, le résultat est
un tableau d'entiers.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>isWithin</function>(<replaceable>value</replaceable>,
<replaceable>min</replaceable>, <replaceable>max</replaceable>)</term>
              <listitem>
                <para>
Renvoie <literal>true</literal> si <replaceable>value</replaceable> se situe
dans la plage <literal>[min, max]</literal> (inclusif aux deux
extrémités). Prend en charge les entiers, les nombres à virgule flottante,
les horodatages et les chaînes (comparaison insensible à la casse). Si
<replaceable>value</replaceable> est un tableau, le résultat est un tableau
de booléens où chaque élément est vérifié individuellement.</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>isWithin(5, 1, 10)</literal> renvoie <literal>true</literal></para></listitem>
                  <listitem><para><literal>isWithin(Size, 1KB, 10MB)</literal> vérifie si la taille de l'un
des fichiers est comprise entre 1 Ko et 10 Mo</para></listitem>
                  <listitem><para><literal>isWithin(Date, today() - 7days, today())</literal> vérifie si le
fichier a été modifié au cours de la dernière semaine</para></listitem>
                  <listitem><para><literal>allof(isWithin(Size, 1KB, 10MB))</literal> vérifie si toutes les
tailles de fichiers sont comprises entre 1 Ko et 10 Mo</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>inRange</function>(<replaceable>value</replaceable>,
<replaceable>min</replaceable>, <replaceable>max</replaceable>)</term>
              <listitem>
                <para>
Renvoie <literal>true</literal> si <replaceable>value</replaceable> se situe
dans la plage <literal>[min, max)</literal> (borne inférieure incluse, borne
supérieure exclue). Prend en charge les entiers, les nombres à virgule
flottante, les horodatages et les chaînes (comparaison insensible à la
casse). Si <replaceable>value</replaceable> est un tableau, le résultat est
un tableau de booléens où chaque élément est vérifié individuellement.</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>inRange(5, 1, 10)</literal> renvoie <literal>true</literal></para></listitem>
                  <listitem><para><literal>inRange(10, 1, 10)</literal> renvoie <literal>false</literal></para></listitem>
                  <listitem><para><literal>inRange(Size, 0, 1MB)</literal> vérifie si la taille de l'un des
fichiers est inférieure à 1 Mo</para></listitem>
                  <listitem><para><literal>anyof(inRange(Date, startOfMonth(today()), today()))</literal>
vérifie si un fichier a été modifié ce mois-ci (aujourd'hui exclu)</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_ArrayFunctions">
          <title>Fonctions de chaînes de caractères</title>
          <variablelist>
            <varlistentry>
              <term><function>array</function>(<replaceable>value1</replaceable>,
<replaceable>value2</replaceable>, ...)</term>
              <listitem><para>Crée un tableau à partir des valeurs données. Exemple : <literal>array(1, 2,
3)</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>at</function>(<replaceable>array</replaceable>,
<replaceable>index</replaceable>)</term>
              <listitem><para>Renvoie l'élément à l'index spécifié (à partir de 0). Les indices négatifs
sont numérotés à partir de la fin. Exemple : <literal>at(array(1, 2, 3),
-1)</literal> renvoie 3</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>anyof</function>(<replaceable>booleans</replaceable>)</term>
              <listitem><para>Renvoie <literal>true</literal> si un élément quelconque du
<emphasis>tableau booléen</emphasis> satisfait la condition.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>allof</function>(<replaceable>booleans</replaceable>)</term>
              <listitem><para>Renvoie <literal>true</literal> si tous les éléments du tableau de booléens
satisfont à la condition.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>allequal</function>(<replaceable>array</replaceable>)</term>
              <listitem><para>Renvoie <literal>true</literal> si toutes les valeurs du tableau sont
égales.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>len</function>(<replaceable>value</replaceable>)</term>
              <listitem>
                <para>Renvoie la longueur de la valeur sous forme d'un <literal>Integer</literal>.</para>
                <para>Comportement :</para>
                <itemizedlist>
                  <listitem><para><emphasis>Tableau</emphasis> : Renvoie le nombre d'éléments du tableau</para></listitem>
                  <listitem><para><emphasis>Chaîne de caractères</emphasis> : Renvoie le nombre de caractères
UTF-8</para></listitem>
                  <listitem><para><emphasis>Aucun (monostate)</emphasis> : Renvoie 0</para></listitem>
                  <listitem><para><emphasis>Autres valeurs scalaires</emphasis> (Entier, Réel, Booléen,
Horodatage, etc.) : Renvoie 1</para></listitem>
                </itemizedlist>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>len(array(1, 2, 3))</literal> - renvoie 3</para></listitem>
                  <listitem><para><literal>len("hello")</literal> - renvoie 5</para></listitem>
                  <listitem><para><literal>len(123)</literal> - renvoie 1</para></listitem>
                  <listitem><para><literal>len(Size)</literal> - renvoie le nombre de côtés (2 ou 3) dans une
comparaison de dossiers</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_ConditionalFunctions">
          <title>Fonctions conditionnelles</title>
          <variablelist>
            <varlistentry>
              <term><function>if</function>(<replaceable>condition</replaceable>,
<replaceable>trueValue</replaceable>, <replaceable>falseValue</replaceable>)</term>
              <listitem>
                <para>
Renvoie <replaceable>trueValue</replaceable> si la
<replaceable>condition</replaceable> est évaluée à vrai, sinon renvoie
<replaceable>falseValue</replaceable>. Cette fonction effectue une
évaluation en court-circuit (elle n'évalue que la branche qui sera
renvoyée).</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>if(Size > 1MB, "large", "small")</literal> - renvoie "large" ou
"small" selon la taille du fichier</para></listitem>
                  <listitem><para><literal>if(Extension = "txt", "text file", "other file")</literal> -
classifie les fichiers par extension</para></listitem>
                  <listitem><para><literal>if(Exists, Size, 0)</literal> - renvoie la taille du fichier ou 0
si le fichier n'existe pas</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>ifEach</function>(<replaceable>conditionArray</replaceable>,
<replaceable>trueValue</replaceable>, <replaceable>falseValue</replaceable>)</term>
              <listitem>
                <para>
Sélection conditionnelle par élément. Pour chaque élément de
<replaceable>conditionArray</replaceable>, renvoie l'élément correspondant
de <replaceable>trueValue</replaceable> si la condition est vraie, sinon
renvoie l'élément correspondant de <replaceable>falseValue</replaceable>. Si
<replaceable>trueValue</replaceable> ou
<replaceable>falseValue</replaceable> est un scalaire, il est diffusé à tous
les éléments.</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>ifEach(Size &gt; 1MB, "large", "small")</literal> - renvoie un
tableau d'étiquettes "large"/"small" pour chaque fichier</para></listitem>
                  <listitem><para><literal>ifEach(array(true, false, true), array("a", "b", "c"), array("x",
"y", "z"))</literal> - renvoie <literal>array("a", "y", "c")</literal></para></listitem>
                  <listitem><para><literal>anyof(ifEach(Size &gt; 100KB, Size &lt; 10MB, false))</literal> -
vérifie si l'un des fichiers est compris entre 100 Ko et 10 Mo</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>choose</function>(<replaceable>index</replaceable>,
<replaceable>value0</replaceable>, <replaceable>value1</replaceable>, ...)</term>
              <listitem>
                <para>
Sélectionne une valeur parmi les arguments en fonction de l'index. Si
l'index est 0, renvoie <replaceable>value0</replaceable> ; s'il est 1,
renvoie <replaceable>value1</replaceable>, etc. Les indices négatifs sont
ramenés à 0. Les indices au-delà de la dernière valeur renvoient la dernière
valeur.</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>choose(0, "first", "second", "third")</literal> - renvoie "first"</para></listitem>
                  <listitem><para><literal>choose(DiffCode % 3, "equal", "different", "unique")</literal> -
associe des codes de diff à des étiquettes</para></listitem>
                  <listitem><para><literal>choose(5, "a", "b", "c")</literal> - renvoie "c" (hors limites,
renvoie la dernière valeur)</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>chooseEach</function>(<replaceable>indexArray</replaceable>,
<replaceable>value0</replaceable>, <replaceable>value1</replaceable>, ...)</term>
              <listitem>
                <para>
Sélection de valeurs par élément. Pour chaque index de
<replaceable>indexArray</replaceable>, sélectionne la valeur correspondante
dans les arguments restants. Si <replaceable>indexArray</replaceable> est un
scalaire, se comporte comme <literal>choose</literal>.</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>chooseEach(array(0, 1, 2), "a", "b", "c")</literal> - renvoie
<literal>array("a", "b", "c")</literal></para></listitem>
                  <listitem><para><literal>chooseEach(array(0, 0, 1), "x", "y")</literal> - renvoie
<literal>array("x", "x", "y")</literal></para></listitem>
                  <listitem><para><literal>chooseEach(array(2, 0, 1), "first", "second", "third")</literal> -
renvoie <literal>array("third", "first", "second")</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_LogicalFunctions">
          <title>Fonctions logiques élément par élément</title>
          <variablelist>
            <varlistentry>
              <term><function>andEach</function>(<replaceable>value1</replaceable>,
<replaceable>value2</replaceable>),
<function>orEach</function>(<replaceable>value1</replaceable>,
<replaceable>value2</replaceable>),
<function>notEach</function>(<replaceable>value</replaceable>)</term>
              <listitem>
                <para>
Opérations logiques par élément. Ces fonctions opèrent sur des booléens, des
tableaux de booléens ou une combinaison des deux :</para>
                <itemizedlist>
                  <listitem><para><literal>andEach</literal> - Opération ET logique</para></listitem>
                  <listitem><para><literal>orEach</literal> - Opération OU logique</para></listitem>
                  <listitem><para><literal>notEach</literal> - Opération NON logique (argument unique)</para></listitem>
                </itemizedlist>
                <para>
Lorsque les arguments sont des scalaires, renvoie un résultat booléen
scalaire. Lorsqu'un argument est un tableau et l'autre un scalaire, le
scalaire est diffusé à tous les éléments. Lorsque les deux arguments sont
des tableaux, effectue l'opération élément par élément.</para>
                <para>Exemples :</para>
                <itemizedlist>
                  <listitem><para><literal>andEach(Size &gt; 1KB, Size &lt; 1MB)</literal> - fichiers entre 1
Ko et 1 Mo</para></listitem>
                  <listitem><para><literal>orEach(Extension = "txt", Extension = "log")</literal> - fichiers
txt ou log</para></listitem>
                  <listitem><para><literal>notEach(Exists)</literal> - fichiers qui n'existent pas</para></listitem>
                  <listitem><para><literal>allof(andEach(Exists, Size &gt; 0))</literal> - tous les fichiers
existent avec une taille non nulle</para></listitem>
                  <listitem><para><literal>anyof(notEach(Size &gt; 1MB))</literal> - n'importe quel fichier de
1 Mo ou moins</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_DiagnosticFunctions">
          <title>Fonctions de diagnostic et d'enregistrement</title>
          <variablelist>
            <varlistentry>
              <term><function>logError</function>(<replaceable>value1</replaceable>,
<replaceable>value2</replaceable>, ...),
<function>logWarn</function>(<replaceable>value1</replaceable>,
<replaceable>value2</replaceable>, ...),
<function>logInfo</function>(<replaceable>value1</replaceable>,
<replaceable>value2</replaceable>, ...)</term>
              <listitem>
                <para>
Envoie la représentation sous forme de chaîne concaténée de tous les
arguments dans le journal (respectivement au niveau erreur, avertissement ou
information), séparés par des espaces, et renvoie la valeur du dernier
argument. Ces fonctions sont utiles pour déboguer les expressions de filtre.</para>
                <para>Exemples (utilisant la valeur de retour) :</para>
                <itemizedlist>
                  <listitem><para><literal>logInfo("File size:", Size) > 1MB</literal> - consigne la/les
taille(s) de fichier et vérifie si elle est supérieure à 1 Mo</para></listitem>
                  <listitem><para><literal>logWarn("Processing:", Name) like "*.tmp"</literal> - consigne
le/les nom(s) de fichier et vérifie s'il s'agit d'un fichier temporaire</para></listitem>
                  <listitem><para><literal>Size > 1KB and logInfo("Large file:", Name) contains
"test"</literal> - ne consigne que si la condition de taille est vraie, puis
vérifie le nom</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>
      </section>

      <section id="FilterExpression_Units">
        <title>Unités</title>
        <para>Les tailles de fichiers prennent en charge ces suffixes :</para>
        <simplelist type="inline">
          <member>Ko</member>
          <member>Mo</member>
          <member>Go</member>
          <member>To</member>
        </simplelist>
        <para>Les durées prennent en charge ces suffixes :</para>
        <simplelist type="inline">
          <member>semaines</member><member>semaine</member><member>s</member>
          <member>jours</member><member>jour</member><member>j</member>
          <member>heures</member><member>heure</member><member>hr</member><member>h</member>
          <member>minutes</member><member>minute</member><member>min</member><member>m</member>
          <member>secondes</member><member>seconde</member><member>sec</member><member>s</member>
          <member>millisecondes</member><member>milliseconde</member><member>msec</member><member>ms</member>
        </simplelist>
      </section>

      <section id="FilterExpression_Examples">
        <title>Exemples</title>
        <itemizedlist>
          <listitem><para><literal>Size &lt; 10KB</literal> - La taille de n'importe quel côté est
inférieure à 10 Ko</para></listitem>
          <listitem><para><literal>LeftSize &gt;= 10MB</literal> - Le fichier du côté gauche fait au
moins 10 Mo</para></listitem>
          <listitem><para><literal>allof(Size &lt; 1MB)</literal> - Tous les côtés font moins de 1 Mo</para></listitem>
          <listitem><para><literal>abs(LeftSize - RightSize) &lt; 1KB</literal> - La différence de
taille est faible</para></listitem>
          <listitem><para><literal>DateStr = "2025-07-20"</literal> - Le fichier a été modifié pour la
dernière fois à cette date</para></listitem>
          <listitem><para><literal>Date &gt;= today()</literal> - Modifié aujourd'hui ou plus tard</para></listitem>
          <listitem><para><literal>Date &gt; d"2026-05-21 07:16:33"</literal> - Modifié après une date
et une heure spécifiques</para></listitem>
          <listitem><para><literal>isWithin(Date, d"2026-01-01", d"2026-12-31 23:59:59")</literal> -
Modifié au cours de l'année 2026</para></listitem>
          <listitem><para><literal>isWithin(Date, today() - 7days, today())</literal> - Fichier
modifié au cours de la dernière semaine</para></listitem>
          <listitem><para><literal>inRange(Size, 1KB, 10MB)</literal> - La taille du fichier est
comprise entre 1 Ko (inclus) et 10 Mo (exclu)</para></listitem>
          <listitem><para><literal>allof(isWithin(Size, 100KB, 1MB))</literal> - Toutes les tailles de
fichiers sont comprises entre 100 Ko et 1 Mo</para></listitem>
          <listitem><para><literal>AttrStr contains "R"</literal> - Le fichier est en lecture seule</para></listitem>
          <listitem><para><literal>Name matches "file[0-9]\.txt"</literal> - Regex sur le nom du
fichier</para></listitem>
          <listitem><para><literal>Content contains "Test"</literal> - Le contenu du fichier contient
le mot-clé</para></listitem>
          <listitem><para><literal>sublines(Content, 0, 1) contains "XML"</literal> - La première
ligne contient "XML"</para></listitem>
          <listitem><para><literal>strCount(Content, "TODO") > 5</literal> - Le fichier contient plus
de 5 commentaires TODO</para></listitem>
          <listitem><para><literal>regexCount(Content, "\bFIXME\b") > 0</literal> - Le fichier
contient au moins un marqueur FIXME</para></listitem>
          <listitem><para><literal>strFind(Name, "_test") != none</literal> - Fichiers contenant
"_test" dans leur nom</para></listitem>
          <listitem><para><literal>strFind(Name, ".", 1) > 0</literal> - Fichiers dont le nom contient
plusieurs points (le deuxième point existe)</para></listitem>
          <listitem><para><literal>regexFind(Name, "\d{4}") &lt; 5</literal> - Fichiers où un nombre à
4 chiffres apparaît parmi les 5 premiers caractères</para></listitem>
          <listitem><para><literal>regexExtract(Name, "v(\d+)\.(\d+)\.(\d+)", 1) = "2"</literal> -
Fichiers avec version majeure 2 (par exemple, "v2.16.48")</para></listitem>
          <listitem><para><literal>regexExtract(Name, "([^_]+)_([^_]+)\.txt", 2) like
"test*"</literal> - Fichiers dont la deuxième partie du nom commence par
"test"</para></listitem>
          <listitem><para><literal>le:regexExtract(Line, "(\d+)", 0, 1)</literal> - Extrait le
deuxième nombre de chaque ligne (décalage=1)</para></listitem>
          <listitem><para><literal>(Extension = "log" and Size > 10MB) or (Date &lt; today() -
7days)</literal> - Gros fichiers journaux ou fichiers de plus d'une semaine</para></listitem>
          <listitem><para><literal>AttrStr not contains "H" and Name like "*.tmp"</literal> - Fichiers
temporaires non cachés</para></listitem>
          <listitem><para><literal>isWithin(Extension, "a", "m") and inRange(Size, 0, 1MB)</literal> -
Fichiers avec extensions de 'a' à 'm' et taille inférieure à 1 Mo</para></listitem>
          <listitem><para><literal>toLower(Name) = "readme.txt"</literal> - Correspondance de nom de
fichier insensible à la casse</para></listitem>
          <listitem><para><literal>toHalfWidth(Name) like "*.txt"</literal> - Correspondance après
conversion pleine chasse en demi-chasse</para></listitem>
          <listitem><para><literal>trim(Name) = "readme.txt"</literal> - Correspond au nom de fichier
après suppression des espaces en début et en fin de fichier</para></listitem>
          <listitem><para><literal>trimLeft(Column("Value")) = "123"</literal> - Correspond à la
valeur de la colonne après suppression des espaces en début de colonne (mode
tableau)</para></listitem>
          <listitem><para><literal>trimRight(Line) contient "end"</literal> - Vérifie si la ligne
(sans espace final) contient "end"</para></listitem>
          <listitem><para><literal>EOL = 3</literal> - Fichiers avec des fins de ligne CRLF (Windows)</para></listitem>
          <listitem><para><literal>EOLStr = "LF"</literal> - Fichiers avec des fins de ligne LF (Unix)</para></listitem>
          <listitem><para><literal>allof(EOL = 1)</literal> - Vérifie si tous les fichiers comparés
utilisent des fins de ligne LF</para></listitem>
          <listitem><para><literal>leftprop("System.Title") != none</literal> - Le fichier de gauche
possède une propriété title définie</para></listitem>
          <listitem><para><literal>prop("System.Author") = none</literal> - Aucune propriété d'auteur
n'est définie</para></listitem>
          <listitem><para><literal>if(LeftExists, LeftSize, 0) == 0</literal> - Vérifie si le fichier
de gauche est manquant ou vide</para></listitem>
          <listitem><para><literal>Different</literal> - Afficher uniquement les fichiers/dossiers qui
sont différents (filtre d'affichage uniquement)</para></listitem>
          <listitem><para><literal>Identical</literal> - Afficher uniquement les fichiers/dossiers qui
sont identiques (filtre d'affichage uniquement)</para></listitem>
          <listitem><para><literal>allof(Binary)</literal> - Afficher uniquement les fichiers qui sont
binaires de tous les côtés (filtre d'affichage uniquement)</para></listitem>
          <listitem><para><literal>DifferentLeftMiddle and not DifferentMiddleRight</literal> - Dans
une comparaison à 3 voies, afficher les fichiers où seule la paire
gauche-milieu diffère (filtre d'affichage uniquement)</para></listitem>
        </itemizedlist>
      </section>
    </section>
  </section>

  <section id="Filters_FileFilter">
    <title>Utilisation des filtres de fichiers<indexterm>
        <primary>filtres</primary>

        <secondary>filtres de fichiers</secondary>
      </indexterm><indexterm>
        <primary>filtres</primary>

        <secondary>dans les comparaisons de dossiers</secondary>
      </indexterm></title>

    <para>Les <glossterm>filtres de fichiers</glossterm> sont des fichiers texte
portant l'extension <filename>flt</filename>. Ils vous permettent
d'appliquer plusieurs règles de filtrage à une comparaison de
dossiers. Contrairement aux masques de fichiers, les filtres de fichiers
peuvent inclure ou exclure des correspondances.</para>

    <para><indexterm>
        <primary>filtres de fichiers</primary>

        <secondary>modèle</secondary>
      </indexterm>WinMerge installe un certain nombre de
filtres de fichiers prédéfinis. Si ces filtres ne fournissent pas le
filtrage dont vous avez besoin, vous pouvez créer les vôtres. Pour faciliter
cette tâche, WinMerge fournit également un fichier modèle nommé
<filename>FileFilter.tmpl</filename>. Cette section décrit comment appliquer
des filtres de fichiers aux comparaisons et documente la syntaxe des filtres
de fichiers. <xref linkend="Filters_dlg" /> décrit comment ajouter, modifier
et gérer les filtres.</para>

    <section id="Filters_FileFilterLoc">
      <title>Emplacements des filtres de fichiers<indexterm>
          <primary>Dossiers de filtres</primary>

          <secondary>emplacements</secondary>
        </indexterm><indexterm>
          <primary>filtres de fichiers</primary>

          <secondary>emplacements</secondary>
        </indexterm></title>

      <para>WinMerge détecte automatiquement les filtres de fichiers dans ces
emplacements :</para>

      <variablelist>
        <varlistentry>
          <term>Sous-dossier Filters dans le dossier d'installation de WinMerge</term>

          <listitem>
            <para>C'est ici que sont installés les filtres de fichiers prédéfinis. Par
exemple, <filename>C:\Program Files\WinMerge\Filters</filename>. Vous pouvez
créer ou copier des fichiers de filtres à cet endroit pour les mettre à la
disposition de tous les utilisateurs de votre système.</para>

            <para>Avant de créer un nouveau filtre de fichiers, vérifiez si les filtres
prédéfinis ne contiennent pas déjà ce dont vous avez besoin. Sinon, vous
pourriez trouver des exemples de règles utiles dans les fichiers existants.</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term>Dossier de filtres privé par défaut</term>

          <listitem>
            <para>L'emplacement de ce dossier est défini dans la page Système des options de
WinMerge. Par défaut, il est spécifié comme un sous-dossier dans votre
dossier de profil utilisateur (par exemple, <filename>Documents</filename>
sous Windows 10). Les filtres créés ou copiés ici ne sont normalement
visibles que par vous. Si vous créez de nouveaux filtres de fichiers, vous
pouvez les copier ici pour les garder privés.</para>
          </listitem>
        </varlistentry>
      </variablelist>

      <para>Avant de pouvoir appliquer des filtres de fichiers existant dans un autre
dossier, vous devez d'abord les installer.</para>
    </section>

    <section id="Filters_FileFilterApply">
      <title>Appliquer des filtres de fichiers<indexterm>
          <primary>filtres de fichiers</primary>

          <secondary>application</secondary>
        </indexterm></title>

      <para>Vous pouvez appliquer un filtre de fichier en utilisant l'une de ces
méthodes :</para>

      <itemizedlist>
        <listitem>
          <para>Lorsque vous lancez une comparaison de dossiers à partir de la boîte de
dialogue Sélectionner des fichiers ou des dossiers :</para>

          <orderedlist>
            <listitem>
              <para>Après avoir choisi les dossiers <guilabel>1er</guilabel> et
<guilabel>2e</guilabel>, cliquez sur <guibutton>Sélectionner</guibutton> à
côté du champ <guilabel>Filtre</guilabel>.</para>
            </listitem>

            <listitem>
              <para>Dans la boîte de dialogue Filtres, utilisez l'onglet Filtres de fichiers
pour choisir un filtre et le charger dans le champ
<guilabel>Filtre</guilabel>.</para>

              <note>
                <para>Si un filtre de fichier est actuellement activé, le filtre sélectionné est
déjà chargé dans le champ <guilabel>Filtre</guilabel>.</para>
              </note>
              <para></para>
            </listitem>

            <listitem>
              <para>Procédez à l'opération de comparaison. Le filtre présent dans le champ
<guilabel>Filtre</guilabel> est appliqué au démarrage de l'opération.</para>
            </listitem>
          </orderedlist>
        </listitem>

        <listitem>
          <para>Pour modifier le filtrage des fichiers après avoir déjà lancé une opération
de comparaison de dossiers (par exemple, pour appliquer un filtre différent
ou désactiver le filtrage) :</para>

          <orderedlist>
            <listitem>
              <para>Cliquez sur <menuchoice> <guimenu>Outils</guimenu>
<guimenuitem>Filtres</guimenuitem> </menuchoice>.</para>
            </listitem>

            <listitem>
              <para>Dans la boîte de dialogue Filtres, configurez votre nouveau réglage de
filtre de fichier, puis cliquez sur <guibutton>OK</guibutton>.</para>
            </listitem>

            <listitem>
              <para>Le nouveau filtrage n'est pas appliqué automatiquement à la fermeture de la
boîte de dialogue Filtres : appuyez sur <keycap>F5</keycap> pour voir les
nouveaux résultats dans la fenêtre de comparaison de dossiers.</para>
            </listitem>
          </orderedlist>
        </listitem>

        <listitem>
          <para><indexterm>
              <primary>ligne de commande</primary>

              <secondary>application des filtres de fichiers</secondary>
            </indexterm>Lorsque vous lancez une comparaison de
dossiers depuis la ligne de commande WinMerge, utilisez le drapeau
<option>-f</option> pour spécifier un filtre de fichier.</para>
        </listitem>
      </itemizedlist>
    </section>

    <section id="Filters_FileFilterSyntax">
      <title>Syntaxe des filtres de fichiers<indexterm>
          <primary>règles</primary>

          <secondary>filtre de fichier</secondary>
        </indexterm><indexterm>
          <primary>filtres de fichiers</primary>

          <secondary>syntaxe</secondary>
        </indexterm></title>

      <para>Cette section décrit la syntaxe des filtres de fichiers de WinMerge et
fournit des directives pour les rédiger.</para>

      <para>Le délimiteur de commentaire est <code>##</code>. Après un délimiteur de
commentaire, tous les caractères d'une ligne sont ignorés. WinMerge ignore
la plupart des caractères d'espacement dans les règles. Cependant, un
commentaire doit toujours être précédé d'un ou plusieurs caractères
d'espacement (espace ou tabulation). Pour utiliser <code>##</code> comme
caractères dans une règle, omettez le préfixe d'espace.</para>

      <para>Les deux premières lignes requises d'un filtre de fichier sont :</para>

      <variablelist>
        <varlistentry>
          <term>name</term>

          <listitem>
            <para>Le nom du filtre tel qu'il apparaît dans la boîte de dialogue Fichiers</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term>def</term>

          <listitem>
            <para>Le type de filtrage à appliquer. Spécifiez l'une de ces valeurs :</para>

            <variablelist>
              <varlistentry>
                <term>include</term>

                <listitem>
                  <para>Inclut tout, sauf les éléments correspondant à la règle spécifiée.</para>
                </listitem>
              </varlistentry>

              <varlistentry>
                <term>exclude</term>

                <listitem>
                  <para>Exclut tout, sauf les éléments correspondant à la règle spécifiée.</para>

                  <para>Lorsque vous choisissez la méthode d'exclusion (exclude), vous devez
également ajouter une règle <guilabel>d</guilabel> (répertoire) qui spécifie
les sous-dossiers. C'est généralement une bonne idée de spécifier tous les
sous-dossiers, comme ceci :</para>

                  <screen>d: \\*$ ## Sous-dossiers</screen>
                </listitem>
              </varlistentry>
            </variablelist>

            <tip>
              <para>Ne confondez pas ces termes. Rappelez-vous que, dans les filtres de
fichiers, une règle <guilabel>include</guilabel> ne spécifie pas ce qu'il
faut inclure, elle spécifie ce qu'il ne faut <emphasis>pas</emphasis>
inclure. De même, <guilabel>exclude</guilabel> ne spécifie pas ce qu'il faut
exclure, elle spécifie ce qu'il ne faut pas exclure.</para>
            </tip>
          </listitem>
        </varlistentry>
      </variablelist>

      <para>Ensuite, votre fichier doit contenir une ou plusieurs règles de
filtrage. Vous pouvez ajouter autant de règles que vous le souhaitez. Il
doit y avoir une règle par ligne, et chaque règle doit tenir sur une seule
ligne (aucun saut de ligne n'est autorisé dans une règle). Une règle
commence par un indicateur de type, suivi soit d'une expression régulière,
soit d'une expression de filtre. Les indicateurs de type pris en charge sont
:</para>

      <variablelist>
        <varlistentry><term>f: <replaceable>regexp</replaceable></term><listitem><para>Faire correspondre les noms de fichiers à l'aide d'expressions régulières</para></listitem></varlistentry>
        <varlistentry><term>f!: <replaceable>regexp</replaceable></term><listitem><para>Exclure les fichiers correspondant à la regex (Disponible depuis la 2.16.19)</para></listitem></varlistentry>
        <varlistentry><term>d: <replaceable>regexp</replaceable></term><listitem><para>Faire correspondre les noms de dossiers à l'aide d'une regex</para></listitem></varlistentry>
        <varlistentry><term>d!: <replaceable>regexp</replaceable></term><listitem><para>Exclure les dossiers correspondant à la regex (Disponible depuis la 2.16.19)</para></listitem></varlistentry>
        <varlistentry><term>fe: <replaceable>expr</replaceable></term><listitem><para>Expression de filtre pour les fichiers (ex: fe:Size &lt; 1KB) (disponible
depuis 2.16.49)</para></listitem></varlistentry>
        <varlistentry><term>fe!: <replaceable>expr</replaceable></term><listitem><para>Expression de filtre pour exclure des fichiers (disponible depuis 2.16.49)</para></listitem></varlistentry>
        <varlistentry><term>de: <replaceable>expr</replaceable></term><listitem><para>Expression de filtre pour les dossiers (disponible depuis 2.16.49)</para></listitem></varlistentry>
        <varlistentry><term>de!: <replaceable>expr</replaceable></term><listitem><para>Expression de filtre pour exclure des dossiers (disponible depuis 2.16.49)</para></listitem></varlistentry>
        <varlistentry><term>e: <replaceable>expr</replaceable></term><listitem><para>Expression de filtre appliquée aux fichiers et aux dossiers (par exemple :
e:Name like "Common*.*") (Disponible depuis la version 2.16.56)</para></listitem></varlistentry>
        <varlistentry><term>e!: <replaceable>expr</replaceable></term><listitem><para>Expression de filtre permettant d'exclure à la fois les fichiers et les
dossiers (Disponible depuis la version 2.16.56)</para></listitem></varlistentry>
      </variablelist>

      <para>Parmi les nombreux caractères spéciaux de regex, les suivants sont
particulièrement importants dans les règles de filtrage de fichiers
:<indexterm>
          <primary>expressions régulières</primary>

          <secondary>caractères spéciaux dans les filtres</secondary>
        </indexterm><indexterm>
          <primary>expressions régulières</primary>

          <secondary>dans les filtres de fichiers</secondary>
        </indexterm></para>

      <variablelist>
        <varlistentry>
          <term>^ (début de ligne)</term>

          <listitem>
            <para>Fréquemment requis pour que les règles fonctionnent correctement.</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term>$ (fin de ligne)</term>

          <listitem>
            <para>Fréquemment requis pour que les règles fonctionnent correctement. Par
exemple :</para>

            <screen>\.c$ ## ne correspond qu'aux noms de fichiers ayant l'extension <filename>c</filename>.
\.c  ## correspond à toute extension commençant par <filename>c</filename>, comme <filename>cpp</filename> et <filename>com</filename>.</screen>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term>\ (échappement)</term>

          <listitem>
            <para>Force les caractères spéciaux à correspondre à des caractères normaux. Par
exemple, pour faire correspondre un nom de dossier, faites précéder le
délimiteur barre oblique inversée du dossier d'une barre oblique inversée
(<code>\\</code>). Pour faire correspondre le point dans un nom de fichier,
spécifiez une barre oblique inversée suivie d'un point (<code>\.</code>).</para>
          </listitem>
        </varlistentry>
      </variablelist>

      <para>Aucun caractère spécial ni caractère générique n'est utilisé pour faire
correspondre les noms de fichiers. Pour faire correspondre tous les noms de
fichiers d'un certain type, omettez simplement le nom du fichier.</para>

      <para>Les règles sont insensibles à la casse. Par exemple, <code>f: \.bat$</code>
correspond à <filename>winmerge.bat</filename> et à
<filename>compare.BAT</filename>.</para>

      <example>
        <title>Exemples de règles de filtrage de fichiers</title>

        <para>Quelques règles de filtrage de fichiers simples :</para>

<screen>f: \.cpp$ ## Correspond aux fichiers <filename>*.cpp</filename>
f: \.h$ ## Correspond aux fichiers <filename>*.h</filename>
f: ^My ## Correspond aux fichiers <filename>My*.*</filename>
f: Dlg\. ## Correspond aux fichiers <filename>*Dlg.*</filename>
d: \\test$ ## Correspond aux dossiers <filename>test</filename>
d: ^\\Build$ ## Correspond aux dossiers <filename>Build</filename>
d: Temp$ ## Correspond aux dossiers <filename>*Temp</filename> (par exemple, <filename>FirstTemp</filename>)
d: Src ## Correspond aux dossiers <filename>*Src*</filename></screen><para>Quelques règles avec des expressions régulières plus complexes :</para>

<screen format="linespecific">f: ^\.#.*$ ## fichiers <filename>.#nom_fichier.version</filename>
f: Dlg\.c(pp)?$ ## fichiers <filename>*Dlg.c</filename> et <filename>*Dlg.cpp</filename>
f: ^I.*\.h$ ## fichiers <filename>I*.h</filename>
f: Srv[1-9]\.def$ ## fichiers <filename>*Srv1.def</filename> à <filename>*Srv9.def</filename>
f: ^[h,k,m] ## fichiers <filename>h*.*</filename>, <filename>k*.*</filename>, et <filename>m*.*</filename></screen></example>
    </section>
  </section>

  <section id="Filters_LineFilter">
    <title>Utilisation des filtres de lignes<indexterm>
        <primary>filtres</primary>

        <secondary>ligne</secondary>
      </indexterm><indexterm>
        <primary>filtres</primary>

        <secondary>dans les comparaisons de fichiers</secondary>
      </indexterm></title>

    <para>Dans une comparaison de fichiers, vous pouvez utiliser des filtres de lignes
pour ignorer des lignes individuelles. Par exemple, vous pourriez utiliser
des filtres de lignes pour ignorer les commentaires ou certains types de
code généré, comme les horodatages des systèmes de contrôle de
version. Chaque filtre de ligne est une règle, et vous pouvez appliquer
n'importe quel nombre de filtres de lignes à une comparaison de fichiers.</para>

    <para>Pour apprendre à ajouter, modifier et gérer les filtres, voir <xref
linkend="Filters_dlg" />.</para>

    <section id="Filters_LineFilterApply">
      <title>Application des filtres de lignes</title>

      <para>Vous pouvez appliquer des filtres de lignes en utilisant l'une de ces
méthodes :</para>

      <itemizedlist>
        <listitem>
          <para>Lorsque vous lancez une comparaison de fichiers à partir de la boîte de
dialogue Sélectionner des fichiers ou des dossiers</para>

          <orderedlist>
            <listitem>
              <para>Après avoir choisi le <guilabel>1er</guilabel> et le <guilabel>2e</guilabel>
fichiers, cliquez sur <guibutton>Sélectionner</guibutton> à côté du champ
<guilabel>Filtre</guilabel>.</para>
            </listitem>

            <listitem>
              <para>Dans la boîte de dialogue Filtres, utilisez l'onglet Filtres de lignes pour
activer les filtres que vous souhaitez utiliser (le cas échéant), ou pour
voir quels filtres sont actuellement activés.</para>

              <note>
                <para>Le champ <guilabel>Filtre</guilabel> n'indique pas quels filtres de lignes
sont activés.</para>
              </note>
              <para></para>
            </listitem>

            <listitem>
              <para>Poursuivez l'opération de comparaison de fichiers. Les filtres de lignes
activés sont appliqués au démarrage de l'opération.</para>
            </listitem>
          </orderedlist>
        </listitem>

        <listitem>
          <para>Après avoir déjà lancé une opération de comparaison de fichiers (par
exemple, pour appliquer des filtres différents ou désactiver le filtrage) :</para>

          <orderedlist>
            <listitem>
              <para>Cliquez sur <menuchoice> <guimenu>Outils</guimenu>
<guimenuitem>Filtres</guimenuitem> </menuchoice>.</para>
            </listitem>

            <listitem>
              <para>Ouvrez l'onglet Filtres de fichiers.</para>
            </listitem>

            <listitem>
              <para>Cochez les filtres de lignes individuels que vous souhaitez appliquer, et
décochez ceux que vous ne souhaitez pas appliquer.</para>

              <para>Vous pouvez également ajouter, modifier et supprimer des filtres de la liste
en utilisant les boutons <guibutton>Nouveau</guibutton>,
<guibutton>Modifier</guibutton> et <guibutton>Supprimer</guibutton>.</para>
            </listitem>

            <listitem>
              <para>Pour activer le filtrage de lignes, cochez <guilabel>Activer les filtres de
lignes</guilabel>. Pour le désactiver, décochez l'option.</para>
            </listitem>

            <listitem>
              <para>Cliquez sur <guibutton>OK</guibutton> pour fermer la boîte de dialogue
Filtres de fichiers.</para>
            </listitem>

            <listitem>
              <para>Appuyez sur <keycap>F5</keycap> pour appliquer vos modifications et
actualiser la fenêtre de comparaison de fichiers.</para>
            </listitem>
          </orderedlist>
        </listitem>
      </itemizedlist>
    </section>

    <section id="Filters_LineFilterSyntax">
      <title>Syntaxe des filtres de lignes<indexterm>
          <primary>règles</primary>

          <secondary>filtre de ligne</secondary>
        </indexterm><indexterm>
          <primary>filtres</primary>

          <secondary>ligne</secondary>
        </indexterm><indexterm>
          <primary>expressions régulières</primary>

          <secondary>dans les filtres de lignes</secondary>
        </indexterm></title>

      <para>Un filtre de ligne est une règle qui est évaluée par rapport à chaque
différence sur une seule ligne dans vos fichiers comparés, si les règles de
filtrage de lignes sont activées. Lorsqu'une règle correspond à une
différence sur une seule ligne, la différence est ignorée.</para>

      <para>Les différences ignorées sont marquées dans la fenêtre de comparaison de
fichiers avec la couleur <guilabel>Différence ignorée</guilabel> (telle que
définie dans la page Couleurs des options de WinMerge). Cela vous permet de
distinguer les différences ignorées des autres types. Cependant, vous ne
pouvez pas sélectionner ni fusionner une différence ignorée.</para>

      <para>La correspondance des filtres de lignes peut être décrite en deux points :</para>

      <itemizedlist>
        <listitem>
          <para>Lorsqu'une règle correspond à n'importe quelle partie de la ligne, la
différence entière est ignorée. Par conséquent, vous ne pouvez pas filtrer
uniquement une partie d'une ligne. Par exemple, supposons que deux fichiers
présentent la différence suivante sur une seule ligne :</para>

          <formalpara>
            <title>Fichier1 :</title>

            <para><screen># Jean Sibelius</screen></para>
          </formalpara>

          <formalpara>
            <title>Fichier2 :</title>

            <para><screen># Janne Sibelius</screen></para>
          </formalpara>

          <para>Sans filtrage, la ligne est détectée comme une différence. Mais si nous
appliquons une règle de filtrage de ligne avec l'expression <code>^#</code>,
les lignes sont signalées comme identiques, car l'expression ne spécifie que
le premier caractère, qui correspond dans les deux fichiers.</para>
        </listitem>

        <listitem>
          <para>Une règle ne s'applique à une différence de plusieurs lignes que si toutes
les lignes correspondent. Par exemple, considérons cette différence de deux
lignes :</para>

          <formalpara>
            <title>Fichier1 :</title>

            <para><screen># Jean Sibelius
# Pekka Himanen</screen></para>
          </formalpara>

          <formalpara>
            <title>Fichier2 :</title>

            <para><screen># Janne Sibelius
Pekka Himanen</screen></para>
          </formalpara>

          <para>La même règle <code>^#</code> correspond à la première ligne, mais pas à la
seconde. Par conséquent, la différence n'est pas ignorée.</para>
        </listitem>
      </itemizedlist>

      <tip>
        <para>C'est généralement une bonne pratique d'utiliser les marqueurs de début de
ligne ( <code>^</code> ) et de fin de ligne ( <code>$</code> ) pour
contrôler vos motifs avec précision, car la règle est appliquée si n'importe
quelle partie d'une ligne correspond à l'expression.</para>
      </tip>

      <example>
        <title>Exemples de filtres de lignes</title>

<screen format="linespecific">^MYTAG$</screen><para>Filtre les lignes qui correspondent exactement à <literal>MYTAG</literal></para>

<screen format="linespecific">^::</screen><para>Filtre les lignes commençant par <literal>::</literal></para>

<screen format="linespecific">^/\*.*\*/$</screen><para>Filtre les lignes commençant par <literal><constant>/*</constant></literal>
et se terminant par <literal>*/</literal></para>

<screen format="linespecific">^[1-5]00</screen><para>Filtre les lignes commençant par les nombres 100, 200, 300, 400 et 500</para>
      </example>

      <example>
        <title>Règle de filtrage de ligne correspondant aux lignes d'ID CVS</title>

        <para>Les lignes d'ID CVS ressemblent à ceci :</para>

<screen>// $Id: Filters.xml 7591 2013-01-20 15:47:42Z christianlist $</screen><para>... et peuvent être filtrées avec cette règle :</para>

<screen>^// \WId: .*\$</screen></example>

      <example>
        <title>Filtrer les commentaires de numéro de ligne dans les fichiers po</title>

        <para>les commentaires de numéro de ligne po ressemblent à ceci :</para>

<screen>#: src/filename.c:766</screen><para>... et peuvent être filtrées avec cette règle :</para>

<screen>^#</screen></example>
    </section>
  </section>

  <section id="Filters_DisplayLineFilter">
    <title>Utilisation du filtre de ligne d'affichage<indexterm>
        <primary>filtre de ligne d'affichage</primary>
      </indexterm></title>

    <para>Le filtre d'affichage des lignes détermine les lignes visibles dans la
fenêtre de comparaison de fichiers. Les lignes ne correspondant pas au
filtre sont masquées, mais le résultat de la comparaison reste inchangé.</para>

    <section id="Filters_DisplayLineFilterApply">
      <title>Ouverture de la barre de filtre d'affichage</title>

      <para>Utilisez l'une des méthodes suivantes pour ouvrir la barre de filtre
d'affichage :</para>

      <itemizedlist>
        <listitem>
          <para>Cliquez sur <menuchoice> <guimenu>Afficher</guimenu> <guimenuitem>Afficher
la barre de filtre</guimenuitem> </menuchoice>, ou appuyez sur
<keycombo><keycap>Ctrl</keycap><keycap>Maj</keycap>
<keycap>L</keycap></keycombo>.</para>
        </listitem>
        <listitem>
          <para>Dans la fenêtre Comparaison de fichiers, cliquez avec le bouton droit sur le
texte sélectionné et choisissez <menuchoice> <guimenu>Ajouter aux
filtres</guimenu> <guimenuitem>Ajouter aux filtres d'affichage</guimenuitem>
</menuchoice>. WinMerge construit automatiquement une expression <literal>La
ligne contient "..."</literal> à partir du texte sélectionné et ouvre la
barre de filtre.</para>
        </listitem>
      </itemizedlist>

      <para>Pour supprimer le filtre, effacez le champ de saisie et appuyez sur la
touche <keycap>Entrée</keycap>. Pour masquer la barre de filtre tout en
conservant le filtre actif, cliquez sur le bouton Fermer.</para>
    </section>

    <section id="Filters_DisplayLineFilterInput">
      <title>Saisie d'un filtre</title>

      <para>La barre de filtre d'affichage accepte les entrées sous deux formes, selon
que l'entrée commence ou non par le préfixe <literal>le:</literal> :</para>

      <variablelist>
        <varlistentry>
          <term>Chaîne de caractères simple (sans préfixe)</term>
          <listitem>
            <para>Les données saisies sans le préfixe <literal>le:</literal> sont traitées
comme une chaîne littérale. WinMerge n'affiche que les lignes contenant
cette chaîne. En interne, la saisie est équivalente à <literal>le:La ligne
contient "<replaceable>entrée</replaceable>"</literal>.</para>
            <para>Exemple : la saisie de <userinput>TODO</userinput> affiche toutes les lignes
contenant le texte <literal>TODO</literal>.</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><literal>le:</literal> prefix (filtre d'expression)</term>
          <listitem>
            <para>Si l'entrée commence par <literal>le:</literal>, le reste est interprété
comme une expression de filtre. La syntaxe complète de l'expression, décrite
dans <xref linkend="Filters_DisplayLineFilter_Syntax"/>, est disponible.</para>
            <para>Exemple : <userinput>le:Différent et la ligne contient « ERROR »</userinput></para>

            <important>
              <para>Le préfixe <literal>le:</literal> doit figurer au tout début de la chaîne de
caractères. S'il apparaît ailleurs, la chaîne entière est traitée comme une
simple chaîne de caractères.</para>
              <para>Par exemple, <userinput>Hello or le:Line contains "Hello"</userinput> ne
contient <emphasis>pas</emphasis> d'expression de filtre. L'ensemble de
l'entrée est traité comme une recherche littérale du texte <literal>Hello or
le:Line contains "Hello"</literal>.</para>
            </important>
          </listitem>
        </varlistentry>
      </variablelist>
    </section>

    <section id="Filters_DisplayLineFilter_Syntax">
      <title>Syntaxe des expressions de filtre</title>

      <para>Les expressions de filtre de ligne d'affichage utilisent le même moteur que
les expressions de filtre de comparaison de dossiers (voir <xref
linkend="FilterExpression_Syntax"/>), avec les attributs et fonctions
supplémentaires suivants qui opèrent sur les lignes individuelles.</para>

      <section id="Filters_DisplayLineFilter_Attrs">
        <title>Attributs de ligne</title>

        <para>Les attributs marqués comme prenant en charge les préfixes spécifiques à un
côté acceptent les préfixes <literal>Left</literal>,
<literal>Middle</literal> et <literal>Right</literal>
(p. ex. <literal>LeftLine</literal>,
<literal>RightLineLength</literal>). Les attributs sans préfixe sont évalués
sur tous les panneaux.</para>

        <variablelist>
          <varlistentry>
            <term><varname>Line</varname></term>
            <listitem><para>Contenu textuel de la ligne courante. Prend en charge les préfixes
spécifiques au côté. Exemple : <literal>La ligne contient « TODO »</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>LineLength</varname></term>
            <listitem><para>Longueur de la ligne courante en caractères. Prend en charge les préfixes
spécifiques au côté. Exemple : <literal>LineLength > 120</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>LineNumber</varname></term>
            <listitem><para>Numéro de ligne réel dans le fichier (à partir de 1), sans compter les
lignes fantômes. Prend en charge les préfixes spécifiques au côté. Exemple :
<literal>LineNumber &lt;= 50</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>ViewLineNumber</varname></term>
            <listitem><para>Afficher le numéro de ligne, y compris les lignes fantômes (numérotation à
partir de 1). Attribut global (sans préfixe latéral). Exemple :
<literal>ViewLineNumber &lt;= 100</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Different</varname></term>
            <listitem><para>Vrai si la ligne fait partie d'un bloc de différence. Attribut
global. Exemple : <literal>Different</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Identical</varname></term>
            <listitem><para>Vrai si la ligne est identique sur tous les panneaux. Attribut global.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Trivial</varname></term>
            <listitem><para>Vrai si la ligne ne diffère que par des espaces ou d'autres éléments
ignorés. Attribut global. Exemple : <literal>Different or Trivial</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Exists</varname></term>
            <listitem><para>Vrai si la ligne existe dans le volet (et non une ligne fantôme). Prend en
charge les préfixes spécifiques au côté. Exemple : <literal>LeftExists and
not RightExists</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Missing</varname></term>
            <listitem><para>Vrai si la ligne est une ligne fantôme dans le volet. L'inverse de
<varname>Exists</varname>. Prend en charge les préfixes spécifiques au côté.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Moved</varname></term>
            <listitem><para>Vrai si la ligne est détectée comme une ligne déplacée. Prend en charge les
préfixes spécifiques au côté.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Bookmarked</varname></term>
            <listitem><para>Vrai si la ligne comporte un signet. Prend en charge les préfixes
spécifiques au côté.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>DifferentLeftMiddle</varname>,
<varname>DifferentMiddleRight</varname>,
<varname>DifferentLeftRight</varname></term>
            <listitem><para>Vrai si la paire de panneaux indiquée diffère sur cette ligne. Comparaisons
à trois voies uniquement (sauf <varname>DifferentLeftRight</varname> qui
fonctionne également en comparaison à deux voies). Attributs
globaux. Exemple : <literal>DifferentLeftMiddle and not
DifferentMiddleRight</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>EOL</varname></term>
            <listitem><para>Style de fin de ligne pour la ligne courante (valeur entière). Prend en
charge les préfixes spécifiques à chaque côté. Valeur  : 0 = Aucun, 1 = LF,
2 = CR, 3 = CRLF. Exemple : <literal>le:EOL = 3</literal> affiche uniquement
les lignes se terminant par CRLF</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>EOLStr</varname></term>
            <listitem><para>Style de fin de ligne pour la ligne courante (sous forme de chaîne de
caractères). Prend en charge les préfixes spécifiques à chaque côté. Valeurs
: "None", "LF", "CR", "CRLF". Exemple : <literal>le:EOLStr = "LF"</literal>
affiche uniquement les lignes se terminant par un saut de ligne (LF)</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Column</varname>, <varname>ColumnCount</varname> (mode tableau
uniquement)</term>
            <listitem><para>Contenu des cellules et nombre de colonnes en mode CSV/tableau. Prise en
charge des préfixes spécifiques au côté. Exemple : <literal>Column("Status")
= "FAIL"</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>LineAt</function>(<replaceable>lineNumber</replaceable>),
<function>LineOffsetAt</function>(<replaceable>offset</replaceable>)</term>
            <listitem><para>Texte de la ligne à un numéro de ligne absolu ou à un décalage relatif par
rapport à la ligne courante. Prend en charge les fonctions de préfixe
spécifiques au côté. Exemple : <literal>le:Different and
RightLineOffsetAt(-1)` matches « ^// » `</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>Column</function>(<replaceable>indexOrName</replaceable>),
<function>ColumnAt</function>(<replaceable>line</replaceable>,
<replaceable>indexOrName</replaceable>),
<function>ColumnOffsetAt</function>(<replaceable>offset</replaceable>,
<replaceable>indexOrName</replaceable>) (mode tableau uniquement)</term>
            <listitem><para>Contenu de la cellule par index ou nom, à la ligne courante, absolue ou
relative. Exemple : <literal>le:RightColumn("Category") !=
ColumnOffsetAt(-1, "Category")</literal></para></listitem>
          </varlistentry>
        </variablelist>
      </section>

      <section id="Filters_DisplayLineFilter_Funcs">
        <title>Fonctions de ligne</title>

        <para>
Les expressions de filtre de ligne d'affichage peuvent également utiliser
les fonctions décrites dans <xref linkend="FilterExpression_Functions"/>.</para>

        <variablelist>
          <varlistentry>
            <term><function>matchContext</function>(<replaceable>expr</replaceable>,
<replaceable>linesBefore</replaceable>,
<replaceable>linesAfter</replaceable>)</term>
            <listitem><para>Vrai si la ligne actuelle se situe entre
<replaceable>linesBefore</replaceable> lignes avant et
<replaceable>linesAfter</replaceable> lignes après toute ligne correspondant
à <replaceable>expr</replaceable>. Exemple :
<literal>le:matchContext(Different, 3, 3)</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchNumber</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Indice de la ligne courante (à partir de 1) parmi toutes les lignes
correspondantes. Renvoie <literal>none</literal> si la ligne ne correspond à
aucune correspondance. Exemple : <literal>le:matchNumber(Different) =
1</literal> affiche uniquement la première ligne correspondante (la première
ligne différente).</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchCount</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Nombre total de lignes correspondant à <replaceable>expr</replaceable> dans
l'ensemble du fichier. Exemple : <literal>le:matchNumber(Different) =
matchCount(Different)</literal> affiche uniquement la dernière ligne
correspondante (la dernière ligne de différence).</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchBlockNumber</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Renvoie le numéro du bloc correspondant (à partir de 1) contenant la ligne
courante. Renvoie <literal>none</literal> si la ligne courante ne se trouve
dans aucun bloc correspondant. Exemple :
<literal>le:matchBlockNumber(Different) = 1</literal> affiche uniquement les
lignes du premier bloc de différence.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchBlockOffset</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Renvoie le décalage (à partir de 1) de la ligne courante dans le bloc
correspondant. Renvoie <literal>none</literal> si la ligne courante ne se
trouve dans aucun bloc correspondant. Exemple :
<literal>le:matchBlockOffset(Different) = 1</literal> affiche uniquement la
première ligne de chaque bloc de différence.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchBlockSize</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Renvoie la taille (nombre de lignes) du bloc correspondant contenant la
ligne courante. Renvoie <literal>none</literal> si la ligne courante ne se
trouve dans aucun bloc correspondant. Exemple :
<literal>le:matchBlockSize(Different) &gt; 5</literal> affiche uniquement
les lignes des blocs de différence de plus de 5 lignes.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchBlockCount</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Nombre total de blocs correspondants dans le fichier. Exemple :
<literal>le:matchBlockNumber(Different) =
matchBlockCount(Different)</literal> affiche uniquement les lignes du
dernier bloc de différence.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchDistance</function>(<replaceable>expr</replaceable>),
<function>matchDistanceBefore</function>(<replaceable>expr</replaceable>),
<function>matchDistanceAfter</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Distance en lignes à la plage correspondante la plus proche (dans les deux
sens, avant uniquement ou après uniquement). Exemple :
<literal>le:matchDistance(Different) &lt;= 5</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchInside</function>(<replaceable>beginExpr</replaceable>,
<replaceable>endExpr</replaceable>)</term>
            <listitem><para>Vrai si la ligne actuelle se situe entre une ligne correspondant à
<replaceable>beginExpr</replaceable> et la ligne suivante correspondant à
<replaceable>endExpr</replaceable> (incluse). Exemple :
<literal>le:matchInside(Line matches "^#ifdef", Line matches
"^#endif")</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>moyenne</function>(<replaceable>expr</replaceable>),
<function>moyenne</function>(<replaceable>expr</replaceable>,
<replaceable>condition</replaceable>)</term>
            <listitem><para>Calcule la moyenne arithmétique des valeurs numériques obtenues en évaluant
<replaceable>expr</replaceable> sur toutes les lignes du fichier. Si une
condition est fournie, seules les lignes où
<replaceable>condition</replaceable> est vrai sont prises en compte. Les
résultats non numériques sont ignorés. Renvoie <literal>none</literal> si
aucune valeur numérique n'est trouvée. Exemple :
<literal>le:toInt(Column("Price")) &gt;
average(toInt(Column("Price")))</literal> affiche les lignes où le prix est
supérieur au prix moyen. Exemple avec condition :
<literal>le:average(toInt(Column("Score")), Column("Status") =
"PASS")</literal> calcule le score moyen des lignes dont le statut est «
PASS ».</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>maximum</function>(<replaceable>expr</replaceable>),
<function>maximum</function>(<replaceable>expr</replaceable>,
<replaceable>condition</replaceable>)</term>
            <listitem><para>Renvoie la valeur maximale parmi tous les résultats obtenus en évaluant
<replaceable>expr</replaceable> sur toutes les lignes du fichier. Si
<replaceable>condition</replaceable> est fourni, seules les lignes où
<replaceable>condition</replaceable> est vrai sont prises en
compte. Fonctionne avec les valeurs numériques, les chaînes de caractères
(comparaison alphabétique) et les horodatages. Renvoie
<literal>none</literal> si aucune valeur n'est trouvée. Exemple :
<literal>le:toInt(Column("Quantity")) =
maximum(toInt(Column("Quantity")))</literal> affiche les lignes avec la
quantité la plus élevée.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>minimum</function>(<replaceable>expr</replaceable>),
<function>minimum</function>(<replaceable>expr</replaceable>,
<replaceable>condition</replaceable>)</term>
            <listitem><para>Renvoie la valeur minimale parmi tous les résultats obtenus en évaluant
<replaceable>expr</replaceable> sur toutes les lignes du fichier. Si
<replaceable>condition</replaceable> est fourni, seules les lignes où
<replaceable>condition</replaceable> est vrai sont prises en
compte. Fonctionne avec les valeurs numériques, les chaînes de caractères
(comparaison alphabétique) et les horodatages. Renvoie
<literal>none</literal> si aucune valeur n'est trouvée. Exemple :
<literal>le:Column("Status") = minimum(Column("Status"))</literal> affiche
les lignes dont la valeur de statut est la première par ordre alphabétique.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>sum</function>(<replaceable>expr</replaceable>),
<function>sum</function>(<replaceable>expr</replaceable>,
<replaceable>condition</replaceable>)</term>
            <listitem><para>Calcule la somme de toutes les valeurs numériques obtenues en évaluant
<replaceable>expr</replaceable> pour chaque ligne du fichier. Si
<replaceable>condition</replaceable> est fourni, seules les lignes où
<replaceable>condition</replaceable> est vrai sont prises en compte dans le
calcul. Les résultats non numériques sont ignorés. Renvoie
<literal>none</literal> si aucune valeur numérique n'est trouvée. Exemple :
<literal>le:toInt(Column("Quantity")) / sum(toInt(Column("Quantity"))) *
100</literal> calcule le pourcentage de chaque ligne par rapport à la
quantité totale. Exemple avec condition :
<literal>le:sum(toInt(Column("Sales")), Column("Region") = "East")</literal>
calcule le total des ventes pour la région « East ».</para></listitem>
          </varlistentry>
        </variablelist>
      </section>

      <section id="Filters_DisplayLineFilter_Examples">
        <title>Exemples</title>

        <informaltable>
          <tgroup cols="2">
            <thead>
              <row>
                <entry>Saisie</entry>
                <entry>Effet</entry>
              </row>
            </thead>
            <tbody>
              <row>
                <entry><userinput>TODO</userinput></entry>
                <entry>Affiche les lignes contenant le texte « TODO » (chaîne de caractères brute)</entry>
              </row>
              <row>
                <entry><userinput>le:Different</userinput></entry>
                <entry>Affiche uniquement les lignes des blocs de différence</entry>
              </row>
              <row>
                <entry><userinput>le:Different or Trivial</userinput></entry>
                <entry>Affiche toutes les différences, y compris les différences ignorées</entry>
              </row>
              <row>
                <entry><userinput>le:matchContext(Different, 3, 3)</userinput></entry>
                <entry>Affiche des blocs de différences avec 3 lignes de contexte de chaque côté</entry>
              </row>
              <row>
                <entry><userinput>le:matchNumber(Different) = 1</userinput></entry>
                <entry>Affiche uniquement la première ligne de différence</entry>
              </row>
              <row>
                <entry><userinput>le:matchBlockNumber(Different) &lt;= 3</userinput></entry>
                <entry>N'affiche que les lignes des 3 premiers blocs de différence</entry>
              </row>
              <row>
                <entry><userinput>le:matchBlockOffset(Different) = 1</userinput></entry>
                <entry>Affiche uniquement la première ligne de chaque bloc de différence</entry>
              </row>
              <row>
                <entry><userinput>le:matchBlockSize(Different) &gt; 10</userinput></entry>
                <entry>Affiche uniquement les lignes des blocs de différence supérieurs à 10 lignes</entry>
              </row>
              <row>
                <entry><userinput>le:Different and Line contains "ERROR"</userinput></entry>
                <entry>Affiche les lignes qui sont à la fois différentes et qui contiennent «
ERREUR ».</entry>
              </row>
              <row>
                <entry><userinput>le:strFind(Line, "TODO") &lt; 10</userinput></entry>
                <entry>Affiche les lignes où « TODO » apparaît dans les 10 premiers caractères</entry>
              </row>
              <row>
                <entry><userinput>le:regexFind(Line, "\d{4}") != none</userinput></entry>
                <entry>Affiche les lignes contenant un nombre à 4 chiffres</entry>
              </row>
              <row>
                <entry><userinput>le:matchContext(Bookmarked, 2, 2)</userinput></entry>
                <entry>Affiche les lignes mises en signet avec 2 lignes de contexte</entry>
              </row>
              <row>
                <entry><userinput>le:LineNumber &lt;= 50</userinput></entry>
                <entry>Affiche uniquement les 50 premières lignes</entry>
              </row>
              <row>
                <entry><userinput>le:EOL = 3</userinput></entry>
                <entry>Affiche uniquement les lignes se terminant par CRLF (Windows)</entry>
              </row>
              <row>
                <entry><userinput>le:EOLStr = "LF"</userinput></entry>
                <entry>Affiche uniquement les lignes se terminant par LF (Unix)</entry>
              </row>
              <row>
                <entry><userinput>le:allof(EOL = 1)</userinput></entry>
                <entry>Affiche les lignes où tous les panneaux utilisent des fins de ligne LF</entry>
              </row>
              <row>
                <entry><userinput>le:toInt(Column("Count")) &gt; 100</userinput></entry>
                <entry>Affiche les lignes où la valeur de la colonne « Nombre » dépasse 100 (mode
tableau)</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
      </section>
    </section>
  </section>

  <section id="Filters_DisplayFileFolderFilter">
    <title>Utilisation du filtre de fichier/dossier d'affichage<indexterm>
        <primary>filtre d'affichage de fichiers/dossiers</primary>
      </indexterm></title>

    <para>Le filtre d'affichage des fichiers et dossiers dans la fenêtre de
comparaison de dossiers fonctionne de la même manière que le filtre
d'affichage des lignes dans la fenêtre de comparaison de fichiers, mais il
s'applique aux fichiers et aux dossiers au lieu des lignes. Il détermine les
éléments visibles sans affecter le résultat de la comparaison.</para>

    <para>Pour ouvrir la barre de filtre d'affichage, cliquez sur <menuchoice>
<guimenu>Affichage</guimenu> <guimenuitem>Barre de filtre
d'affichage</guimenuitem> </menuchoice>, ou appuyez sur
<keycombo><keycap>Ctrl</keycap><keycap>Maj</keycap>
<keycap>L</keycap></keycombo>.</para>

    <para>La barre de filtre accepte la même syntaxe que le champ
<guilabel>Filtre</guilabel> de la boîte de dialogue Sélectionner des
fichiers ou des dossiers. Consultez <xref linkend="Filters_MaskSyntax"/> et
<xref linkend="FilterExpression_Syntax"/> pour plus de détails.</para>

    <para>Pour supprimer le filtre, effacez le champ de saisie et appuyez sur la
touche <keycap>Entrée</keycap>. Pour masquer la barre de filtre tout en
conservant le filtre actif, cliquez sur le bouton Fermer.</para>

    <para>Exemples :</para>
    <itemizedlist>
      <listitem><para><userinput>*.cpp;*.h</userinput> - affiche les fichiers sources et d'en-tête
C++</para></listitem>
      <listitem><para><userinput>!.git\;!.vs\</userinput> - exclut les dossiers .git et .vs</para></listitem>
      <listitem><para><userinput>for:Different</userinput> - affiche uniquement les fichiers
différents</para></listitem>
      <listitem><para><userinput>de:Items > 10</userinput> - affiche les dossiers contenant plus
de 10 éléments</para></listitem>
      <listitem><para><userinput>a:Date > aujourd'hui() - 7 jours</userinput> - affiche les
éléments modifiés au cours de la dernière semaine</para></listitem>
    </itemizedlist>
  </section>

  <section id="Filters_SubstitutionFilter">
    <title>Utilisation des filtres de substitution<indexterm>
        <primary>filtres</primary>

        <secondary>substitution</secondary>
      </indexterm><indexterm>
        <primary>filtres</primary>

        <secondary>dans les comparaisons de fichiers</secondary>
      </indexterm></title>

    <para>À déterminer</para>
  </section>

  <section id="Filters_dlg">
    <title>Utilisation de la boîte de dialogue Filtres<indexterm>
        <primary>Boîte de dialogue Filtres</primary>
      </indexterm><indexterm>
        <primary>filtres</primary>

        <secondary>gérer et activer</secondary>
      </indexterm></title>

    <para>Cette section décrit la boîte de dialogue Filtres, qui fournit des fonctions
pour créer et gérer les filtres de fichiers et les filtres de lignes.</para>

    <para>Pour ouvrir la boîte de dialogue Filtres, utilisez l'une ou l'autre de ces
méthodes :</para>

    <itemizedlist>
      <listitem>
        <para>Dans la boîte de dialogue Sélectionner des fichiers ou des dossiers, cliquez
sur <guibutton>Sélectionner</guibutton> à droite du champ
<guilabel>Filtre</guilabel>. Vous utilisez cette méthode lorsque vous
souhaitez appliquer un filtre de fichier à une opération de comparaison de
dossiers.</para>
      </listitem>

      <listitem>
        <para>Cliquez sur <menuchoice> <guimenu>Outils</guimenu>
<guimenuitem>Filtres</guimenuitem> </menuchoice>. Cette méthode peut être
utilisée à tout moment, sauf lorsque la boîte de dialogue Sélectionner des
fichiers ou des dossiers est ouverte.</para>
      </listitem>
    </itemizedlist>

    <para>La boîte de dialogue Filtres possède un onglet pour chaque type de filtre
WinMerge :</para>

    <variablelist>
      <varlistentry>
        <term>Filtres de fichiers</term>

        <listitem>
          <para>Choisissez cet onglet pour travailler avec les filtres de fichiers pour les
opérations de comparaison de dossiers.</para>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>Filtres de lignes</term>

        <listitem>
          <para>Choisissez cet onglet pour travailler avec les filtres de lignes pour les
opérations de comparaison de fichiers.</para>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>Filtres de substitution</term>

        <listitem>
          <para>Choisissez cet onglet pour travailler avec les filtres de substitution pour
les opérations de comparaison de fichiers.</para>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>Afficher le filtre de ligne</term>

        <listitem>
          <para>Le filtre de ligne d'affichage n'est pas configurable via cette boîte de
dialogue. Ouvrez-la via <menuchoice><guimenu>Affichage</guimenu>
<guimenuitem>Barre de filtre d'affichage</guimenuitem></menuchoice>. Voir
<xref linkend="Filters_DisplayLineFilter"/>.</para>
        </listitem>
      </varlistentry>
    </variablelist>

    <section id="Filters_FileFiltersTab">
      <title>Utilisation de l'onglet Filtres de fichiers<indexterm>
          <primary>filtres de fichiers</primary>

          <secondary>activation</secondary>
        </indexterm></title>

      <para>La partie principale de cet onglet est une liste de filtres de fichiers
disponibles pour les opérations de comparaison de dossiers. La liste
comprend les filtres de fichiers partagés, privés et installés que WinMerge
connaît, comme décrit dans <xref linkend="Filters_FileFilterLoc" />.</para>

      <section id="Filters_FileFilterEnabling">
        <title>Activation et désactivation des filtres de fichiers</title>

        <para>Vous devez activer un filtre de fichier pour le rendre disponible dans une
opération de comparaison de dossiers, ou désactiver un filtre actuel pour
qu'il ne soit plus utilisé :</para>

        <orderedlist>
          <listitem>
            <para>Ouvrez la boîte de dialogue Filtres, si elle n'est pas déjà ouverte.</para>
          </listitem>

          <listitem>
            <para>Sélectionnez un filtre de fichier ou
<guimenuitem>&lt;Aucun&gt;</guimenuitem> dans la liste.</para>
          </listitem>

          <listitem>
            <para>Cliquez sur <guibutton>OK</guibutton> pour fermer la boîte de dialogue
Filtres.</para>
          </listitem>
        </orderedlist>

        <para>Il existe plusieurs façons d'appliquer des filtres de fichiers après les
avoir activés. Pour plus de détails, voir <xref
linkend="Filters_FileFilterApply" />.</para>
      </section>

      <section id="Filters_FileFilterCfg">
        <title>Configuration des filtres de fichiers</title>

        <para>Utilisez ces boutons pour gérer votre liste de <guilabel>Filtres de
fichiers</guilabel> et en créer de nouveaux :</para>

        <variablelist>
          <varlistentry>
            <term>Tester</term>

            <listitem>
              <para>Sélectionnez un filtre de fichier dans la liste et cliquez sur
<guibutton>Tester</guibutton> pour voir rapidement comment le filtre
fonctionne. Voir <xref linkend="Filters_TestingDlg" /> pour plus de détails.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>Installer</term>

            <listitem>
              <para>Permet de localiser un filtre de fichier et de l'ajouter à la liste des
filtres. Les filtres qui ne se trouvent ni dans le dossier partagé ni dans
le dossier privé par défaut ne sont pas détectés à moins que vous ne les
installiez.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>Nouveau</term>

            <listitem>
              <para>Crée une nouvelle copie d'un modèle de fichier dans le dossier de filtres
partagés ou privés, et l'ouvre dans votre éditeur par défaut. Modifiez le
modèle et ajoutez vos règles, comme décrit dans <xref
linkend="Filters_CreatingFile" />.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>Modifier</term>

            <listitem>
              <para>Sélectionnez un filtre de fichier dans la liste et cliquez sur
<guibutton>Modifier</guibutton> pour ouvrir le fichier dans votre éditeur
par défaut.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>Supprimer</term>

            <listitem>
              <para>Sélectionnez un filtre de fichier dans la liste et cliquez sur
<guibutton>Supprimer</guibutton> pour supprimer le fichier et le retirer de
la liste. Oui, le fichier est réellement supprimé !</para>
            </listitem>
          </varlistentry>
        </variablelist>

        <para>Vos modifications sont enregistrées lorsque vous cliquez sur
<guibutton>OK</guibutton> pour fermer la boîte de dialogue Filtres. Les
filtres de lignes sont stockés dans le registre Windows.</para>
      </section>

      <section id="Filters_CreatingFile">
        <title>Créer un filtre de fichier</title>

        <para>Si les filtres installés avec WinMerge ne fournissent pas le filtrage dont
vous avez besoin, vous pouvez créer les vôtres :</para>

        <orderedlist>
          <listitem>
            <para>Cliquez sur <menuchoice> <guimenu>Outils</guimenu>
<guimenuitem>Filtres</guimenuitem> </menuchoice>. Ou, depuis la boîte de
dialogue Sélectionner des fichiers ou des dossiers, cliquez sur
<guibutton>Sélectionner</guibutton> à droite du champ
<guilabel>Filtre</guilabel>.</para>
          </listitem>

          <listitem id="Filters_New_step">
            <para>Dans l'onglet Filtres de fichiers de la boîte de dialogue Filtres, cliquez
sur <guibutton>Nouveau</guibutton>.</para>
          </listitem>

          <listitem>
            <para>Dans la boîte de dialogue Filtre partagé ou privé, choisissez
<guilabel>Filtre partagé</guilabel> ou <guilabel>Filtre privé</guilabel>
(voir <xref linkend="Filters_FileFilterLoc" /> pour leurs usages) et cliquez
sur <keycap>OK</keycap>.</para>

            <para>La boîte de dialogue Sélectionner un nom de fichier pour le nouveau filtre
s'ouvre dans le dossier des fichiers partagés ou privés de votre système (si
le dossier privé n'existe pas, WinMerge le crée).</para>
          </listitem>

          <listitem>
            <para>Dans la boîte de dialogue Sélectionner un nom de fichier pour le nouveau
filtre, saisissez un nouveau nom de fichier et cliquez sur
<guibutton>Enregistrer</guibutton>.</para>

            <note>
              <para>Ne choisissez pas un nom de fichier existant : pour modifier un fichier
existant, revenez à l'étape <xref linkend="Filters_New_step" /> et cliquez
sur Modifier au lieu de Nouveau.</para>
            </note>

            <para>WinMerge initialise le nouveau fichier avec le contenu du modèle
<filename>FileFilter.tmpl</filename> et l'ouvre dans votre éditeur de texte
par défaut.</para>
          </listitem>

          <listitem>
            <para>Suivez les instructions du modèle pour l'éditer, en mettant à jour le nom et
la description et en ajoutant des règles de filtrage comme décrit dans <xref
linkend="Filters_FileFilterSyntax" />. Enregistrez le fichier dans votre
éditeur de texte.</para>

            <tip>
              <para>Si vous souhaitez tester rapidement une règle que vous définissez, essayez
de cliquer sur Tester dans la boîte de dialogue Filtres. Voir <xref
linkend="Filters_TestingDlg" /> pour plus de détails.</para>
            </tip>
            <para></para>
          </listitem>

          <listitem>
            <para>Si vous avez créé votre filtre dans l'un des dossiers
<filename>Filters</filename> standards et que la boîte de dialogue Filtres
n'affiche pas votre nouveau filtre, essayez de cliquer sur
<guibutton>OK</guibutton> pour la fermer, puis sur <menuchoice>
<guimenu>Outils</guimenu> <guimenuitem>Filtres</guimenuitem> </menuchoice>
pour la rouvrir. La liste <guilabel>Filtres de fichiers</guilabel> devrait
maintenant inclure le nouveau filtre.</para>

            <para>Si vous avez enregistré le fichier dans un autre emplacement sur votre
système, WinMerge ne pourra pas le détecter à moins que vous ne
l'installiez. Pour rendre un filtre de fichier détectable n'importe où sur
votre système :</para>

            <orderedlist numeration="loweralpha">
              <listitem>
                <para>Cliquez sur <guibutton>Installer</guibutton> dans la boîte de dialogue
Filtres.</para>
              </listitem>

              <listitem>
                <para>Dans la boîte de dialogue Localiser le fichier de filtre à installer,
naviguez jusqu'au fichier <filename>flt</filename> sur votre système et
cliquez sur <guibutton>Ouvrir</guibutton>. La liste des filtres de fichiers
devrait maintenant inclure le filtre installé.</para>
              </listitem>
            </orderedlist>
          </listitem>
        </orderedlist>
      </section>

      <section id="Filters_TestingDlg">
        <title>Test des règles de filtrage de fichiers<indexterm>
            <primary>filtres de fichiers</primary>

            <secondary>test</secondary>
          </indexterm><indexterm>
            <primary>tester les filtres de fichiers</primary>
          </indexterm></title>

        <para>Utilisez la boîte de dialogue Tester le filtre pour tester rapidement un
filtre par rapport à des données d'exemple, afin de vous aider à développer
de nouvelles règles ou à comprendre le fonctionnement des règles
existantes. Cela peut être plus facile que de lancer une opération de
comparaison complète.</para>

        <para>À partir de la boîte de dialogue Filtres :</para>

        <orderedlist>
          <listitem>
            <para>Dans l'onglet Filtres de fichiers, choisissez le filtre que vous souhaitez
tester.</para>
          </listitem>

          <listitem>
            <para>Si vous souhaitez voir les règles que vous allez tester, cliquez sur
<guibutton>Modifier</guibutton> maintenant pour ouvrir le fichier afin de
pouvoir le consulter pendant les étapes suivantes.</para>
          </listitem>

          <listitem>
            <para>Cliquez sur <guibutton>Tester</guibutton>.</para>
          </listitem>

          <listitem>
            <para>Dans la boîte de dialogue Tester le filtre, choisissez le type de règle à
tester :</para>

            <itemizedlist>
              <listitem>
                <para>Pour tester une règle de fichier <guilabel>f:</guilabel> dans votre filtre,
décochez l'option <guilabel>Nom du dossier</guilabel>.</para>
              </listitem>

              <listitem>
                <para>Pour tester une règle de dossier <guilabel>d:</guilabel>, cochez l'option
<guilabel>Nom du dossier</guilabel>.</para>
              </listitem>
            </itemizedlist>
          </listitem>

          <listitem>
            <para>Saisissez le texte à tester.</para>

            <para>Le texte doit être approprié au type de règle que vous testez. Par exemple,
si vous avez coché l'option <guilabel>Nom du dossier</guilabel>, vous
voudrez probablement saisir un nom de dossier, tel que \temp.</para>

            <para>La zone <guilabel>Résultat</guilabel> affiche votre saisie, suivie de son
état : soit <computeroutput>réussi (passed)</computeroutput>, soit
<computeroutput>échoué (failed)</computeroutput>.</para>
          </listitem>
        </orderedlist>
      </section>
    </section>

    <section id="Filters_LineFiltersTab">
      <title>Utilisation de l'onglet Filtres de lignes<indexterm>
          <primary>filtres de lignes</primary>

          <secondary>activation</secondary>
        </indexterm></title>

      <para>Utilisez cet onglet pour configurer et activer des filtres de lignes pour
les opérations de comparaison de fichiers. L'onglet présente une liste de
règles. Chaque règle contient une seule expression régulière. Vous pouvez
appliquer n'importe quelle combinaison de règles de la liste à une
comparaison de fichiers.</para>

      <section id="Filters_LineFilterCfg">
        <title>Configuration des filtres de lignes</title>

        <para>Sous la liste <guilabel>Expressions régulières</guilabel> se trouvent une
zone d'édition et des boutons que vous pouvez utiliser pour mettre à jour la
liste à tout moment en ajoutant, modifiant et supprimant des règles.</para>

        <para>Pour ajouter une nouvelle règle :</para>

        <orderedlist>
          <listitem>
            <para>Cliquez sur <guibutton>Nouveau</guibutton>. Votre curseur d'édition est
automatiquement activé dans la zone d'édition.</para>
          </listitem>

          <listitem>
            <para>Saisissez une expression dans la zone d'édition sous la liste
<guilabel>Expressions régulières</guilabel>.</para>
          </listitem>

          <listitem>
            <para>Cliquez sur <guibutton>Enregistrer</guibutton> pour charger l'expression
dans une nouvelle ligne de la liste.</para>
          </listitem>
        </orderedlist>

        <para>Pour modifier une règle existante :</para>

        <orderedlist>
          <listitem>
            <para>Sélectionnez la ligne et cliquez sur <guibutton>Modifier</guibutton>.</para>
          </listitem>

          <listitem>
            <para>Modifiez l'expression dans la zone d'édition.</para>
          </listitem>

          <listitem>
            <para>Cliquez sur <guibutton>Enregistrer</guibutton> quand vous avez terminé.</para>
          </listitem>
        </orderedlist>

        <para>Pour supprimer une règle existante, sélectionnez (cochez) la règle et
cliquez sur <guibutton>Supprimer</guibutton>.</para>
      </section>

      <section id="Filters_LineFilterEnabling">
        <title>Activation et désactivation des filtres de lignes<indexterm>
            <primary>filtres de lignes</primary>

            <secondary>liste des filtres disponibles</secondary>
          </indexterm></title>

        <orderedlist>
          <listitem>
            <para>Dans la liste <guilabel>Expressions régulières</guilabel>, cochez uniquement
les filtres que vous souhaitez appliquer, et décochez tous les filtres que
vous ne souhaitez pas appliquer.</para>
          </listitem>

          <listitem>
            <para>Cochez ou décochez l'option <guilabel>Activer les filtres de
lignes</guilabel>. Si vous activez le filtrage, toutes les règles
actuellement cochées dans la liste <guilabel>Expressions
régulières</guilabel> seront utilisées. Si le filtrage est désactivé, aucune
règle n'est utilisée, même si elle est cochée.</para>
          </listitem>

          <listitem>
            <para>Cliquez sur <guibutton>OK</guibutton> pour fermer la boîte de dialogue
Filtres et enregistrer vos réglages.</para>
          </listitem>
        </orderedlist>

        <para>Il existe plusieurs façons d'appliquer des filtres de fichiers après les
avoir activés. Pour plus de détails, voir <xref
linkend="Filters_LineFilterApply" />.</para>
      </section>
    </section>

    <section id="Filters_SubstitutionFiltersTab">
      <title>Utilisation de l'onglet Filtres de substitution<indexterm>
          <primary>filtres de substitution</primary>

          <secondary>activation</secondary>
        </indexterm></title>

        <para>À déterminer</para>

      <section id="Filters_SubstitutionFilterCfg">
        <title>Configuration des filtres de substitution</title>

        <para>À déterminer</para>

      </section>

      <section id="Filters_SubstitutionFilterEnabling">
        <title>Activation et désactivation des filtres de substitution<indexterm>
            <primary>filtres de substitution</primary>

            <secondary>liste des filtres disponibles</secondary>
          </indexterm></title>

        <para>À déterminer</para>
      </section>
    </section>
  </section>

  <section id="AboutFilters_regexp">
    <title>Obtenir de l'aide sur les expressions régulières<indexterm>
        <primary>expressions régulières</primary>

        <secondary>obtenir de l'aide</secondary>
      </indexterm></title>

    <para>Les expressions régulières peuvent être très complexes. Heureusement, la
plupart des filtres de fichiers dans WinMerge utilisent des expressions
d'extension simples, comme le montrent les exemples de cette rubrique. Les
fichiers de filtres installés avec WinMerge comprennent de nombreux autres
exemples utiles.</para>

    <para>Enfin, il existe de nombreuses ressources sur le Web pour vous aider avec
les regex, notamment ces sites :</para>

    <variablelist>
      <varlistentry>
        <term>Un bon site consacré aux regex :</term>

        <listitem>
          <simpara><ulink
url="https://www.regular-expressions.info/">https://www.regular-expressions.info/</ulink></simpara>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>Tutoriel :</term>

        <listitem>
          <simpara><ulink
url="http://www.zvon.org/comp/r/tut-Regexp.html">http://www.zvon.org/comp/r/tut-Regexp.html</ulink></simpara>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>Référence rapide PDF :</term>

        <listitem>
          <simpara><ulink
url="https://github.com/GordonMcKinney/gist-assets/raw/master/regex.pdf">
https://github.com/GordonMcKinney/gist-assets/raw/master/regex.pdf</ulink></simpara>
        </listitem>
      </varlistentry>
    </variablelist>
  </section>
</article>
