<?xml version="1.0" encoding="UTF-8"?>
<article id="Filters">
  <title>שימוש במסננים<indexterm>
      <primary>מסננים</primary>

      <seealso>מסנני קבצים</seealso>

      <seealso>מסיכות קבצים</seealso>

      <seealso>מסנני שורות</seealso>

      <seealso>מסנני החלפה</seealso>
    </indexterm></title>

  <para>כשאתה משווה קבצים או תיקיות, אתה יכול להשתמש במסננים כדי לצמצם את היקף
ההשוואה. זה יכול להיות שימושי כשאתה רוצה לפשט את תוצאת ההשוואה על ידי ביטול
הבדלים שאינך מעוניין בהם. מסננים הם כללים המבוססים על ביטויים
רגולריים. WinMerge משתמש במנוע הביטויים הרגולריים הפופולרי PCRE (ביטויים
רגולריים תואמי Perl).<indexterm>
      <primary>ביטויים רגולריים</primary>

      <secondary>מנוע נתמך</secondary>
    </indexterm><indexterm>
      <primary>מנוע ביטויים רגולריים PCRE</primary>
    </indexterm><indexterm>
      <primary>regexp</primary>

      <see>ביטויים רגולריים</see>
    </indexterm></para>

  <para>הפונקציה הבסיסית של סינון היא פשוטה: הערכת כל פריט שבדרך כלל יושווה (תיקייה,
קובץ או שורה בתוך קובץ), ואם ביטוי המסנן תואם לפריט היעד, החל את
המסנן. בהתאם לסוג המסנן, הפריט נכלל או לא נכלל בהשוואה.</para>

  <para>ישנם מסנני WinMerge שונים עבור פעולות השוואת תיקיות והשוואת קבצים:</para>

  <variablelist>
    <varlistentry>
      <term>השוואת תיקיות: מסיכות קבצים ומסנני קבצים<indexterm>
          <primary>השוואת תיקיות</primary>

          <secondary>סינון</secondary>
        </indexterm></term>

      <listitem>
        <para>You can specify files to include in a folder comparison by using simple file
masks, or, for more complex filtering, by applying multiple rules specified
in a file filter.</para>

        <para>קבצים ותיקיות שמסוננים מוסתרים בתוצאה כברירת מחדל, וזה בדרך כלל מה שאתה
רוצה. אתה יכול ללחוץ על <menuchoice> <guimenu>תצוגה</guimenu>
<guimenuitem>הצג פריטים שדולגו</guimenuitem> </menuchoice> כדי לבטל את
ההסתרה של פריטים מסוננים, אך חלון השוואת התיקיות מציג רק מידע מינימלי
עליהם. לדוגמה, אינך יכול לדעת אם קובץ שדולג הוא קובץ טקסט או בינארי.</para>

        <para>The display file/folder filter is also available for folder compare
operations. Unlike file filters, it does not affect the comparison result;
it only controls which items are visible in the Folder Compare window.  See
<xref linkend="Filters_DisplayFileFolderFilter"/>.</para>
      </listitem>
    </varlistentry>

    <varlistentry>
      <term>השוואות קבצים: מסנני שורות ומסנני החלפה<indexterm>
          <primary>השוואת קבצים</primary>

          <secondary>סינון</secondary>
        </indexterm></term>

      <listitem>
        <para>מסנני שורות מוחלים רק על פעולות השוואת קבצים. הם מאפשרים לך להתעלם מהבדלי
שורה בודדים.</para>
        <para>מסנני החלפה מוחלים רק על פעולות השוואת קבצים. הם מחליפים את המחרוזות בגוש
ה-diff במחרוזות שצוינו, משווים אותן ומתעלמים מגוש ה-diff אם תוצאות ההחלפה
תואמות. הם שימושיים להתעלמות ממספר רב של שינויים לא מעניינים.</para>
        <para>The display line filter is also applied only to file compare
operations. Unlike line filters, it does not affect the comparison result;
it only controls which lines are visible in the File Compare window.  See
<xref linkend="Filters_DisplayLineFilter"/>.</para>
      </listitem>
    </varlistentry>
  </variablelist>

  <section id="Filters_Mask">
    <title>שימוש במסיכות קבצים<indexterm>
        <primary>מסיכות קבצים</primary>
      </indexterm><indexterm>
        <primary>מסננים</primary>

        <secondary>מסיכות קבצים</secondary>
      </indexterm><indexterm>
        <primary>מסננים</primary>

        <secondary>בהשוואות תיקיות</secondary>
      </indexterm></title>

    <para>אתה יכול להשתמש במסיכות <glossterm>קבצים</glossterm> אחת או יותר שמציינות
סיומות קבצים שיכללו בהשוואת תיקיות. כל שאר הקבצים מושמטים מהבחירה שלך.</para>

    <section id="Filters_MaskApply">
      <title>הגדרה והחלה של מסיכות קבצים<indexterm>
          <primary>שורת פקודה</primary>

          <secondary>החלת מסיכות קבצים</secondary>
        </indexterm></title>

      <para>הגדר והחל מסיכת קבצים בזמן שאתה מפעיל את פעולת השוואת התיקיות שלך:</para>

      <itemizedlist>
        <listitem>
          <para>אם אתה משתמש בתיבת הדו-שיח בחר קבצים או תיקיות, לאחר בחירת התיקיות
<guilabel>1</guilabel> ו-<guilabel>2</guilabel>, הזן מסיכת קבצים אחת או יותר
בשדה <guilabel>מסנן</guilabel>. המסכות מוחלות כשאתה מתחיל את פעולת השוואת
התיקיות.</para>
        </listitem>

        <listitem>
          <para>אם אתה משתמש בשורת הפקודה של WinMerge, השתמש בדגל <option>-f</option> כדי
לציין מסיכות קבצים (ראה את הדוגמה בסעיף הבא).</para>
        </listitem>
      </itemizedlist>
    </section>

    <section id="Filters_MaskSyntax">
      <title>תחביר ודוגמה של מסיכת קבצים<indexterm>
          <primary>כללים</primary>

          <secondary>מסיכות קבצים</secondary>
        </indexterm><indexterm>
          <primary>מסננים</primary>

          <secondary>מסיכות קבצים</secondary>
        </indexterm><indexterm>
          <primary>ביטויים רגולריים</primary>

          <secondary>במסיכות קבצים</secondary>
        </indexterm></title>

      <para>You can specify file masks and extended filters using this format:</para>

      <synopsis>
        <replaceable>Filter1 of Group1</replaceable>;<replaceable>Filter2</replaceable> ...|<replaceable>Filter1 of Group2</replaceable>;<replaceable>Filter2</replaceable> ...|...
      </synopsis>

      <itemizedlist>
        <listitem><para>The <filename>|</filename> character separates filter groups and acts as a
logical AND.</para></listitem>
        <listitem><para>Filters within the same group are separated by <filename>;</filename> and
are interpreted with a logical OR.</para></listitem>
        <listitem><para>A file is included only if it matches at least one filter in each group.</para></listitem>
        <listitem>
          <para>To include a literal <filename>|</filename> (pipe) character in a regular
expression that is not enclosed in double quotes (such as in
<filename>f:</filename> or <filename>f!:</filename> filters), use
<filename>||</filename> instead.</para>
          <para>Example: <userinput>f:(abc||def)\.txt$</userinput></para>
        </listitem>
        <listitem>
          <para>Each filter (e.g., Filter1, Filter2) can be one of the following types:</para>
          <variablelist>
            <varlistentry><term><replaceable>*.ext</replaceable></term><listitem><para>File mask by extension (e.g., *.txt)</para></listitem></varlistentry>
            <varlistentry><term><replaceable>*.</replaceable></term><listitem><para>Files with no extension (e.g., README)</para></listitem></varlistentry>
            <varlistentry><term>!<replaceable>*.ext</replaceable></term><listitem><para>Exclude files matching the extension (Available since 2.16.19)</para></listitem></varlistentry>
            <varlistentry><term><replaceable>folder</replaceable>\</term><listitem><para>Target folders (must end with \) (Available since 2.16.19)</para></listitem></varlistentry>
            <varlistentry><term>!<replaceable>folder</replaceable>\</term><listitem><para>Exclude matching folders (Available since 2.16.19)</para></listitem></varlistentry>
            <varlistentry><term>f: <replaceable>regexp</replaceable></term><listitem><para>Match file names using regular expressions (Available since 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>f!: <replaceable>regexp</replaceable></term><listitem><para>Exclude files matching regex (Available since 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>d: <replaceable>regexp</replaceable></term><listitem><para>Match folder names using regex (Available since 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>d!: <replaceable>regexp</replaceable></term><listitem><para>Exclude folders matching regex (Available since 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>fe: <replaceable>expr</replaceable></term><listitem><para>Filter expression for files (e.g. fe:Size &lt; 1KB) (Available since
2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>fe!: <replaceable>expr</replaceable></term><listitem><para>Filter expression to exclude files (Available since 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>de: <replaceable>expr</replaceable></term><listitem><para>Filter expression for folders (Available since 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>de!: <replaceable>expr</replaceable></term><listitem><para>Filter expression to exclude folders (Available since 2.16.49)</para></listitem></varlistentry>
            <varlistentry><term>pf: <replaceable>file filter name</replaceable></term><listitem><para>Apply a file filter by name (Available since 2.16.49)</para></listitem></varlistentry>
          </variablelist>
        </listitem>
      </itemizedlist>

      <example>
        <title>מסיכת קבצים</title>

        <para>בדוגמה זו של שורת הפקודה, פעולת השוואת התיקיות כוללת רק קבצים עם סיומות
<filename>xml</filename> או <filename>txt</filename>. כל שאר הקבצים מושמטים:</para>

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

      <example>
        <title>Excluding folders (since version 2.16.19)</title>

        <para>בדוגמה זו של שורת הפקודה, פעולת השוואת התיקיות אינה כוללת תיקיות
<filename>.git</filename> ו-<filename>.vs</filename>:</para>

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

      <example>
        <title>Filter expression (since version 2.16.49)</title>

        <para>In this command-line example, the folder compare operation includes only
files with <filename>cpp</filename> or <filename>h</filename> extensions and
a file size less than 1KB:</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>Filter Expression Syntax</title>

      <para>
WinMerge allows powerful filtering using expressions that operate on file
metadata, contents, and comparison context. This section describes the
supported attributes, operators, functions, data types, and evaluation
rules.</para>

      <section id="FilterExpression_Literals">
        <title>Literals and Types</title>

        <para>Supported literal types include:</para>
        <itemizedlist>
          <listitem><para><emphasis>Boolean</emphasis>: <literal>true</literal>,
<literal>false</literal></para></listitem>
          <listitem><para><emphasis>Null</emphasis>: <literal>none</literal> (represents a null or
missing value)</para></listitem>
          <listitem><para><emphasis>Integer</emphasis>: 64-bit signed integers (e.g.,
<literal>1024</literal>, or with units like <literal>100KB</literal>,
<literal>7days</literal>)</para></listitem>
          <listitem><para><emphasis>Real (Double)</emphasis>: Floating-point numbers with optional
decimal or exponent (e.g., <literal>3.14</literal>, <literal>.5</literal>,
<literal>1e6</literal>)</para></listitem>
          <listitem><para><emphasis>String</emphasis>: Enclosed in double quotes (e.g.,
<literal>"example"</literal>)</para></listitem>
          <listitem><para><emphasis>Date/Time</emphasis>: Prefixed with <literal>d</literal> and
enclosed in double quotes (e.g., <literal>d"2026-05-21 07:16:33"</literal>,
<literal>d"2026-05-21"</literal>)</para></listitem>
        </itemizedlist>

        <para>
Internally, values may be of the following types: Boolean, Integer, Real,
Timestamp, String, File Content, Array, or <literal>none</literal>.</para>
      </section>

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

        <para>
Filter expressions support directives that control how the expression is
evaluated.  Directives are specified at the beginning of the expression,
prefixed with <literal>@</literal>, and separated from the expression by
whitespace.</para>

        <section id="FilterExpression_CaseSensitivity">
          <title>Case Sensitivity Directives</title>

          <para>
By default, all string comparison operators (<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>)  are
case-insensitive. You can control this behavior using the following
directives:</para>

          <variablelist>
            <varlistentry>
              <term><literal>@cs</literal>, <literal>@casesensitive</literal></term>
              <listitem>
                <para>
Enable case-sensitive comparison. With these directives,
<literal>"ABC"</literal> and <literal>"abc"</literal> are considered
different.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><literal>@ci</literal>, <literal>@caseinsensitive</literal></term>
              <listitem>
                <para>
Enable case-insensitive comparison (default behavior). With these
directives, <literal>"ABC"</literal> and <literal>"abc"</literal> are
considered identical.</para>
              </listitem>
            </varlistentry>
          </variablelist>

          <example>
            <title>Case Sensitivity Examples</title>
<programlisting>@cs Name = "README.txt"           ## Case-sensitive: matches only "README.txt"
@ci Name = "readme.txt"           ## Case-insensitive: matches "README.txt", "readme.txt", "ReadMe.TXT", etc.
@casesensitive Extension = "TXT"  ## Case-sensitive: matches only files with ".TXT" extension
@caseinsensitive Content contains "error"  ## Case-insensitive: matches "Error", "ERROR", "error", etc.</programlisting></example>
        </section>

        <section id="FilterExpression_Optimize">
          <title>Optimization Directives</title>

          <para>
By default, filter expressions are optimized to improve performance. You can
control this behavior using the following directives:</para>

          <variablelist>
            <varlistentry>
              <term><literal>@optimize</literal>, <literal>@opt</literal></term>
              <listitem>
                <para>
Enable filter expression optimization (default behavior). This may improve
performance for complex expressions.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><literal>@nooptimize</literal>, <literal>@noopt</literal></term>
              <listitem>
                <para>
Disable filter expression optimization. This is useful for debugging or when
optimization causes unexpected results.</para>
              </listitem>
            </varlistentry>
          </variablelist>

          <example>
            <title>Optimization Examples</title>
<programlisting>@optimize Size &gt; 10MB and Extension = "log"     ## Enable optimization (default)
@noopt Name matches "complex[0-9]+pattern"    ## Disable optimization for debugging
@nooptimize Content contains "special-case"   ## Disable optimization</programlisting></example>
        </section>

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

          <para>
The <literal>@name</literal> directive allows you to assign a descriptive
name to a filter expression.  This name is intended for use in error
messages and logs to help identify which filter expression caused an issue.</para>

          <variablelist>
            <varlistentry>
              <term><literal>@name="Filter Name"</literal>, <literal>@name=FilterName</literal></term>
              <listitem>
                <para>
Assigns a name to the filter expression. If the name contains spaces or
special characters, it must be enclosed in double quotes. Names without
spaces can be specified without quotes.</para>
                <para>
The specified name will be used in error messages and diagnostic output to
identify the filter.  This is particularly useful when working with multiple
complex filter expressions.</para>
              </listitem>
            </varlistentry>
          </variablelist>

          <example>
            <title>Name Directive Examples</title>
<programlisting>@name="Large Image Files" Size &gt; 10MB and Extension = "png"
@name=SmallTextFiles Size &lt; 1KB and Extension = "txt"
@name="Modified Today" Date &gt;= today()
@name="Test Filter" @cs Name like "test_*.cpp"</programlisting></example>

          <note>
            <para>
The <literal>@name</literal> directive can be combined with other
directives.  When multiple directives are used, they should all appear at
the beginning of the expression, separated by whitespace.</para>
          </note>
        </section>
      </section>

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

        <para>
Filter expressions support a variety of attributes referring to file
metadata and content.  Attribute names are case-insensitive. You can
optionally specify which side of the comparison (Left, Right, or Middle) an
attribute applies to by using a prefix.</para>

        <section>
          <title>Core Attributes</title>
          <variablelist>
            <varlistentry>
              <term><varname>Exists</varname></term>
              <listitem><para>Returns <literal>true</literal> if the file exists, <literal>false</literal>
otherwise</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Name</varname></term>
              <listitem><para>File name</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>BaseName</varname></term>
              <listitem><para>Returns the filename without extension. For example, "document.txt" returns
"document".</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Extension</varname></term>
              <listitem><para>File extension</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>IsFolder</varname></term>
              <listitem><para>Returns true if the item is a folder/directory, false if it's a file.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Folder</varname></term>
              <listitem><para>Returns the relative path excluding the file name and base folder</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>RelPath</varname></term>
              <listitem><para>Returns the relative path from the comparison root directory, including both
folder path and filename. For example, if comparing "C:\Project" and the
file is at "C:\Project\src\main.cpp", RelPath returns "src\main.cpp".</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>FullPath</varname></term>
              <listitem><para>Returns the full path of the file</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Size</varname></term>
              <listitem><para>File size</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Date</varname></term>
              <listitem><para>Last modified timestamp</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>DateStr</varname></term>
              <listitem><para>Last modified date string in <literal>yyyy-MM-dd</literal> format</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>CreationTime</varname></term>
              <listitem><para>Creation date timestamp</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Attributes</varname></term>
              <listitem><para>Returns the file attributes as an integer value</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>AttrStr</varname></term>
              <listitem>
                <para>Returns file attribute string. Examples: <literal>"R"</literal> for
Read-only, <literal>"H"</literal> for Hidden, <literal>"A"</literal> for
Archive, <literal>"S"</literal> for System file.</para>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section>
          <title>File-only Attributes</title>
          <para>
The following attributes are available only for file comparison items.  When
used with folder items, the behavior is undefined.</para>

          <variablelist>
            <varlistentry>
              <term><varname>Content</varname></term>
              <listitem><para>Content of the file. Returns a FileContent-type value. Only
<literal>contains</literal> and <literal>recontains</literal> can be used
with this type.</para></listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section>
          <title>Folder-only Attributes</title>
          <para>
The following attributes are available only for folder comparison items.
When used with file items, the behavior is undefined.</para>

          <variablelist>
            <varlistentry>
              <term><varname>Files</varname></term>
              <listitem><para>Number of files directly contained in the folder.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>RecursiveFiles</varname></term>
              <listitem><para>Number of files contained in the folder, including all subfolders.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Items</varname></term>
              <listitem><para>Number of items (files and subfolders) directly contained in the folder.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>RecursiveItems</varname></term>
              <listitem><para>Number of items (files and subfolders) contained in the folder, including
all subfolders.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>TotalSize</varname></term>
              <listitem><para>Total size of all files directly contained in the folder, in bytes.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>RecursiveTotalSize</varname></term>
              <listitem><para>Total size of all files contained in the folder, including all subfolders,
in bytes.</para></listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section>
          <title>Side-Specific Prefixes</title>
          <para>
Prefixes may be added to specify the comparison side:</para>
          <itemizedlist>
            <listitem><para><emphasis>Left</emphasis>: Applies to the file on the left side (e.g.,
<literal>LeftSize</literal>)</para></listitem>
            <listitem><para><emphasis>Right</emphasis>: Applies to the file on the right side (e.g.,
<literal>RightDate</literal>)</para></listitem>
            <listitem><para><emphasis>Middle</emphasis>: Applies to the middle file in 3-way comparison
(e.g., <literal>MiddleName</literal>)</para></listitem>
          </itemizedlist>

          <para>
Attributes without a prefix (e.g., <literal>Size</literal>) return an array
of values from all available sides (Left, Middle, Right).</para>
        </section>

        <section>
          <title>Windows Property Attributes</title>
          <para>
These attributes provide access to Windows Property System values, such as
metadata defined by the Windows Property System schema (e.g.,
<literal>System.Title</literal>, <literal>System.FileOwner</literal>,
<literal>System.Image.HorizontalResolution</literal>).</para>

          <variablelist>
            <varlistentry>
              <term><varname>Prop</varname></term>
              <listitem>
                <para>
Returns an array of property values (Left, Middle, Right) for the specified
canonical property name.  Example: <literal>prop("System.Title")</literal></para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>LeftProp</varname></term>
              <listitem>
                <para>
Property value of the left-side file. Example:
<literal>leftprop("System.FileOwner")</literal></para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>MiddleProp</varname></term>
              <listitem>
                <para>Property value of the middle file (in 3-way comparison).</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>RightProp</varname></term>
              <listitem>
                <para>Property value of the right-side file.</para>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section>
          <title>Display Filters Only Attributes</title>
          <para>
The following attributes are designed for use in <emphasis
role="bold">Display filters only</emphasis> (specified via
<guilabel>e:</guilabel>, <guilabel>e!:</guilabel>, <guilabel>fe:</guilabel>,
<guilabel>fe!:</guilabel>, <guilabel>de:</guilabel>, or
<guilabel>de!:</guilabel> prefixes in the Filter field).  They should not be
used in file filter (<filename>.flt</filename>) include/exclude rules, as
they require the comparison to be completed first and may lead to unexpected
behavior.</para>

          <variablelist>
            <varlistentry>
              <term><varname>Identical</varname></term>
              <listitem>
                <para>
Returns <literal>true</literal> if the comparison result indicates the items
are identical, <literal>false</literal> otherwise.  This is a global
attribute (does not support side-specific prefixes).  Example:
<literal>Identical</literal> to show only identical files.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Different</varname></term>
              <listitem>
                <para>
Returns <literal>true</literal> if the comparison result indicates the items
are different, <literal>false</literal> otherwise.  This is a global
attribute (does not support side-specific prefixes).  Example:
<literal>Different</literal> to show only different files.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Skipped</varname></term>
              <listitem>
                <para>
Returns <literal>true</literal> if the comparison was skipped due to an
error or filter rule, <literal>false</literal> otherwise.  This is a global
attribute (does not support side-specific prefixes).  Example:
<literal>Skipped</literal> to show only skipped items.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Binary</varname></term>
              <listitem>
                <para>
Returns <literal>true</literal> if the file is detected as binary,
<literal>false</literal> if it's text, or <literal>none</literal> if the
file doesn't exist.  This attribute supports side-specific prefixes (e.g.,
<literal>LeftBinary</literal>, <literal>RightBinary</literal>).  Example:
<literal>allof(Binary)</literal> to show files that are binary on all sides.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>DifferentLeftMiddle</varname></term>
              <listitem>
                <para>
Returns <literal>true</literal> if the left and middle files are different
in a 3-way comparison, <literal>false</literal> otherwise.  Returns
<literal>none</literal> in 2-way comparisons.  This is a global attribute
(does not support side-specific prefixes).  Example:
<literal>DifferentLeftMiddle and not DifferentMiddleRight</literal> to find
files where only left differs from middle.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>DifferentMiddleRight</varname></term>
              <listitem>
                <para>
Returns <literal>true</literal> if the middle and right files are different
in a 3-way comparison, <literal>false</literal> otherwise.  Returns
<literal>none</literal> in 2-way comparisons.  This is a global attribute
(does not support side-specific prefixes).  Example:
<literal>DifferentMiddleRight</literal> to show files where middle and right
differ.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>DifferentLeftRight</varname></term>
              <listitem>
                <para>
In 3-way comparisons, returns <literal>true</literal> if the left and right
files are different, <literal>false</literal> otherwise.  In 2-way
comparisons, returns <literal>true</literal> if both files exist and are
different.  This is a global attribute (does not support side-specific
prefixes).  Example: <literal>DifferentLeftRight</literal> to show files
where left and right differ.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Differences</varname></term>
              <listitem>
                <para>
Returns the number of text differences in the file comparison.  This
attribute is only meaningful for text files that have been compared.  This
is a global attribute (does not support side-specific prefixes).  Example:
<literal>Differences &gt; 0</literal> to show files with differences, or
<literal>Differences &gt; 10</literal> to show files with more than 10
differences.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>IgnoredDiffs</varname></term>
              <listitem>
                <para>
Returns the number of ignored differences in the file comparison
(differences filtered by line filters or whitespace settings).  This
attribute is only meaningful for text files that have been compared.  This
is a global attribute (does not support side-specific prefixes).  Example:
<literal>IgnoredDiffs &gt; 0</literal> to show files with ignored
differences, or <literal>Differences = 0 and IgnoredDiffs &gt; 0</literal>
to show files that are identical except for ignored differences.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Unpacker</varname></term>
              <listitem>
                <para>
Returns the name of the unpacker plugin used for the file comparison, or an
empty string if no unpacker was used.  This is a global attribute (does not
support side-specific prefixes).  Example: <literal>Unpacker =
"CompareMSExcelFiles"</literal> to show files compared using the Excel
unpacker, or <literal>Unpacker != ""</literal> to show all files where an
unpacker was used.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>Prediffer</varname></term>
              <listitem>
                <para>
Returns the name of the prediffer plugin used for the file comparison, or an
empty string if no prediffer was used.  This is a global attribute (does not
support side-specific prefixes).  Example: <literal>Prediffer =
"IgnoreColumns"</literal> to show files compared using the IgnoreColumns
prediffer, or <literal>Prediffer != ""</literal> to show all files where a
prediffer was used.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>EOL</varname></term>
              <listitem>
                <para>Returns the end-of-line (EOL) style as an integer value. For files, returns
the predominant EOL style; for lines, returns the EOL style of that specific
line.</para>
                <para>Values: 0 = None, 1 = LF (Unix), 2 = CR (Mac), 3 = CRLF (Windows), 4 = Mixed
(multiple EOL styles in file)</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>EOLStr</varname></term>
              <listitem>
                <para>Returns the end-of-line (EOL) style as a string. For files, returns the
predominant EOL style; for lines, returns the EOL style of that specific
line.</para>
                <para>Values: "None", "LF", "CR", "CRLF", "Mixed"</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><varname>Codepage</varname></term>
              <listitem>
                <para>
Returns the file's codepage (character encoding) as an integer value.  This
attribute supports side-specific prefixes (e.g.,
<literal>LeftCodepage</literal>, <literal>RightCodepage</literal>).
Example: <literal>Codepage = 65001</literal> to show UTF-8 files, or
<literal>allof(Codepage = 65001)</literal> to show files that are UTF-8 on
all sides.</para>
              </listitem>
            </varlistentry>

            <varlistentry>
              <term><varname>HasBOM</varname></term>
              <listitem>
                <para>
Returns <literal>true</literal> if the file has a Byte Order Mark (BOM),
<literal>false</literal> otherwise.  This attribute supports side-specific
prefixes (e.g., <literal>LeftHasBOM</literal>,
<literal>RightHasBOM</literal>).  Example: <literal>HasBOM</literal> to show
files with BOM, or <literal>not HasBOM</literal> to show files without BOM.</para>
              </listitem>
            </varlistentry>

          </variablelist>
        </section>

        <section id="FilterExpression_ArrayEvaluation">
          <title>Array Evaluation</title>

          <para>
Attributes without a side prefix (e.g., <literal>Size</literal>) return an
array of values from all available sides (Left, Middle, Right). When
applying an operator to such arrays, behavior differs depending on whether
the comparison is with a scalar or another array.</para>

          <section id="FilterExpression_ArrayVsScalar">
            <title>Array vs Scalar</title>
            <para>
When comparing an array to a scalar, the operation is applied to each array
element individually.  This results in a boolean array. If any element in
this boolean array is <literal>true</literal>, the overall expression
evaluates to <literal>true</literal>. Otherwise, it evaluates to
<literal>false</literal>.</para>
            <example>
              <title>דוגמה</title>
<programlisting>[3, 5, 8] &gt; 6 -> [false, false, true] -> true</programlisting></example>
          </section>

          <section id="FilterExpression_ArrayVsArray">
            <title>Array vs Array</title>
            <para>
When comparing two arrays, the behavior depends on the operator:</para>
            <itemizedlist>
              <listitem>
                <para>
For <literal>=</literal> and <literal>!=</literal>: The arrays must have the
same length.  The result is a single boolean value, not an array.
<literal>=</literal> returns <literal>true</literal> only if all elements
are equal.  <literal>!=</literal> returns <literal>true</literal> if any
element differs.</para>
              </listitem>
              <listitem>
                <para>
For all other operators (e.g., <literal>&gt;</literal>,
<literal>&lt;</literal>): the operation is applied element-wise, producing a
boolean array.  The final result of the expression is
<literal>true</literal> if any element in the boolean array is
<literal>true</literal>, and <literal>false</literal> if all elements are
<literal>false</literal>.</para>
              </listitem>
            </itemizedlist>

            <example>
              <title>Examples</title>
<programlisting>[2, 4] = [2, 4] -> true</programlisting> <programlisting>[2, 4] != [2, 5] -> true (because 4 != 5)</programlisting> <programlisting>[3, 5, 8] &gt; [6, 4, 2]
 -> [false, true, true]
 -> true (because at least one comparison is true)
              </programlisting></example>
          </section>

          <section id="FilterExpression_ArraySummary">
            <title>Summary</title>
            <itemizedlist>
              <listitem>
                <para>
Array vs scalar comparisons produce a boolean array.  The overall expression
result is <literal>true</literal> if at least one element is
<literal>true</literal>.</para>
              </listitem>
              <listitem>
                <para>
Array vs array with <literal>=</literal> or <literal>!=</literal> returns a
single boolean value.</para>
              </listitem>
              <listitem>
                <para>
Array vs array with other operators produces a boolean array.  The final
result is <literal>true</literal> if any element is <literal>true</literal>.</para>
              </listitem>
            </itemizedlist>
          </section>
        </section>
      </section>

      <section id="FilterExpression_Operators">
        <title>Operators</title>

        <para>
By default, all string comparison operators (such as <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>, and
<literal>recontains</literal>)  are case-insensitive. You can control this
behavior using directives (see <xref
linkend="FilterExpression_CaseSensitivity" />).</para>

        <variablelist>
          <varlistentry>
            <term><literal>&lt;</literal>, <literal>&lt;=</literal>, <literal>&gt;</literal>,
<literal>&gt;=</literal></term>
            <listitem><para>Numeric, timestamp, or string comparison</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>=</literal></term>
            <listitem><para>Equality comparison</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>!=</literal></term>
            <listitem><para>Inequality comparison</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>+</literal>, <literal>-</literal>, <literal>*</literal>,
<literal>/</literal>, <literal>%</literal></term>
            <listitem>
              <para>
Arithmetic operators. <literal>+</literal> and <literal>-</literal> perform
addition and subtraction. <literal>*</literal> and <literal>/</literal>
perform multiplication and division. <literal>%</literal> is the modulo
operator (remainder).</para>
            </listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>and</literal>, <literal>or</literal>, <literal>not</literal></term>
            <listitem><para>Logical operators</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>like</literal></term>
            <listitem>
              <para>Wildcard string match</para>
              <para>You can also use <literal>not like</literal> to perform the inverse match.</para>
            </listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>matches</literal></term>
            <listitem>
              <para>Matches regular expressions</para>
              <para>You can also use <literal>not matches</literal> to perform the inverse
match.</para>
            </listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>contains</literal></term>
            <listitem>
              <para>Checks if a string contains a substring</para>
              <para>You can also use <literal>not contains</literal> to check for absence of the
substring.</para>
            </listitem>
          </varlistentry>
          <varlistentry>
            <term><literal>recontains</literal></term>
            <listitem>
              <para>Checks if any substring matches a regular expression</para>
              <para>You can also use <literal>not recontains</literal> to ensure no match
exists.</para>
            </listitem>
          </varlistentry>
        </variablelist>
      </section>

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

        <para>
Filter expressions support various functions for manipulating and analyzing
data.  Functions are organized by category for easier reference.</para>

        <section id="FilterExpression_StringFunctions">
          <title>String Functions</title>
          <variablelist>
            <varlistentry>
              <term><function>strlen</function>(<replaceable>source</replaceable>)</term>
              <listitem><para>Returns the length of the string as an <literal>Integer</literal>. If
<replaceable>source</replaceable> is a string array, the result is an
integer array. Example: <literal>strlen(Name)</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>strCount</function>(<replaceable>str</replaceable>,
<replaceable>substr</replaceable>)</term>
              <listitem>
                <para>
Counts how many times the substring <replaceable>substr</replaceable>
appears in <replaceable>str</replaceable>.  The search is case-insensitive
by default (respects <literal>@cs</literal>/<literal>@ci</literal>
directives).  If <replaceable>str</replaceable> is an array, the result is
an integer array with counts for each element.  Overlapping matches are
counted separately (e.g., <literal>strCount("aaaa", "aa")</literal> returns
2).</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>strCount("hello hello world", "hello")</literal> returns 2</para></listitem>
                  <listitem><para><literal>strCount("Test TEST test", "test")</literal> returns 3
(case-insensitive)</para></listitem>
                  <listitem><para><literal>@cs strCount("Test TEST test", "test")</literal> returns 1
(case-sensitive)</para></listitem>
                  <listitem><para><literal>le:strCount(Line, "ERROR") > 2</literal> shows lines containing
"ERROR" more than twice</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>regexCount</function>(<replaceable>str</replaceable>,
<replaceable>pattern</replaceable>)</term>
              <listitem>
                <para>
Counts how many times the regular expression
<replaceable>pattern</replaceable> matches in
<replaceable>str</replaceable>.  The search is case-insensitive by default
(respects <literal>@cs</literal>/<literal>@ci</literal> directives).  If
<replaceable>str</replaceable> is an array, the result is an integer array
with counts for each element.  Zero-length matches are handled gracefully to
avoid infinite loops.</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>regexCount("test123abc456", "\d+")</literal> returns 2</para></listitem>
                  <listitem><para><literal>regexCount("AAA BBB CCC", "[A-Z]+")</literal> returns 3</para></listitem>
                  <listitem><para><literal>@cs regexCount("Test TEST", "TEST")</literal> returns 1</para></listitem>
                  <listitem><para><literal>le:regexCount(Line, "\b(error|warning)\b") > 0</literal> shows
lines with error or warning keywords</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>strFind</function>(<replaceable>str</replaceable>,
<replaceable>substr</replaceable>[, <replaceable>occurrence</replaceable>])</term>
              <listitem>
                <para>
Finds the position (0-based) of the Nth occurrence of substring
<replaceable>substr</replaceable> in <replaceable>str</replaceable>.  The
optional <replaceable>occurrence</replaceable> parameter specifies which
occurrence to find (0-based, default is 0 for the first occurrence).  The
search is case-insensitive by default (respects
<literal>@cs</literal>/<literal>@ci</literal> directives).  Returns
<literal>none</literal> if the substring is not found or if the occurrence
index is out of range.  If <replaceable>str</replaceable> is an array, the
result is an array of positions (or none values).</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>strFind("hello world", "o")</literal> returns 4 (first 'o')</para></listitem>
                  <listitem><para><literal>strFind("hello world", "o", 1)</literal> returns 7 (second 'o')</para></listitem>
                  <listitem><para><literal>@cs strFind("Test TEST test", "test")</literal> returns 10
(case-sensitive)</para></listitem>
                  <listitem><para><literal>strFind(array("abc", "def"), "b")</literal> returns
<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>
Finds the position (0-based) of the Nth occurrence of a regular expression
match in <replaceable>str</replaceable>.  The optional
<replaceable>group</replaceable> parameter specifies which capture group to
locate (0-based, default is 0 for the entire match).  The optional
<replaceable>occurrence</replaceable> parameter specifies which occurrence
of the pattern to find (0-based, default is 0 for the first occurrence).
The search is case-insensitive by default (respects
<literal>@cs</literal>/<literal>@ci</literal> directives).  Returns
<literal>none</literal> if the pattern doesn't match, the group index is out
of range, or the occurrence index is out of range.  If
<replaceable>str</replaceable> is an array, the result is an array of
positions (or none values).</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>regexFind("test123abc456", "\d+")</literal> returns 4 (position of
"123")</para></listitem>
                  <listitem><para><literal>regexFind("test123abc456", "\d+", 0, 1)</literal> returns 10
(position of "456", second match)</para></listitem>
                  <listitem><para><literal>regexFind("abc-def-ghi", "([a-z]+)-([a-z]+)", 1)</literal> returns
0 (position of first capture group "abc")</para></listitem>
                  <listitem><para><literal>regexFind("v1.0 and v2.5", "v(\d+)\.(\d+)", 1, 1)</literal> returns
10 (major version "2" in second occurrence)</para></listitem>
                  <listitem><para><literal>regexFind(array("test123", "abc"), "\d+")</literal> returns
<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>Returns a specific range of text from the <emphasis>string or string
array</emphasis> as a <literal>String</literal>. If
<replaceable>source</replaceable> is a string array, the result is a string
array. Example: <literal>substr(Name, 0, 3)</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>replace</function>(str, from, to)</term>
              <listitem>
                <para>
Replaces all occurrences of the string <replaceable>from</replaceable> with
<replaceable>to</replaceable>.  If <replaceable>str</replaceable> is an
array, the result is an array of strings with replacements applied.
Example: <literal>replace(name, ".bak", ".txt")</literal></para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>regexReplace</function>(str, pattern, replacement)</term>
              <listitem>
                <para>
Replaces all matches of the regular expression pattern with the replacement
string.  Supports backreferences ($1, $2, etc.) in the replacement string.
If <replaceable>str</replaceable> is an array, the result is an array of
strings with replacements applied.  Example: <literal>regexReplace(name,
"^(\w+)_(\w+)$", "$2_$1")</literal> swaps words separated by underscore.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>replaceWithList</function>(str, filepath)</term>
              <listitem>
                <para>
Replaces multiple strings in <replaceable>str</replaceable> using
replacement rules loaded from a tab-separated file.  The file format is one
replacement rule per line:
<literal>search_string&lt;TAB&gt;replacement_string</literal>.  Lines
starting with <literal>#</literal> are treated as comments and ignored.
Empty lines are also ignored.  If <replaceable>str</replaceable> is an
array, the result is an array of strings with replacements applied.</para>
                <para>File format example:</para>
                <screen># Comment line
apple	orange
cat	dog
old	new</screen>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>replaceWithList(Name, "C:\Filters\replacements.txt")</literal> -
applies replacements from file to file name</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>regexReplaceWithList</function>(str, filepath)</term>
              <listitem>
                <para>
Replaces strings in <replaceable>str</replaceable> using regular expression
patterns loaded from a tab-separated file.  The file format is one pattern
per line: <literal>regex_pattern&lt;TAB&gt;replacement_string</literal>.
The replacement string can include backreferences ($1, $2, etc.) to captured
groups.  Lines starting with <literal>#</literal> are treated as comments
and ignored.  Empty lines are also ignored.  If
<replaceable>str</replaceable> is an array, the result is an array of
strings with replacements applied.</para>
                <para>File format example:</para>
                <screen># Comment line
\d+	NUMBER
(\d{4})-(\d{2})-(\d{2})	$1_$2_$3</screen>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>regexReplaceWithList(Name,
"C:\Filters\regex_replacements.txt")</literal> - applies regex replacements
to file name</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>
Captures text matching a regular expression pattern from the string.  The
optional <replaceable>group</replaceable> parameter specifies which capture
group to extract (0-based).  Group 0 (default) returns the entire match;
groups 1, 2, etc. return the corresponding capture groups defined by
parentheses in the pattern.  The optional <replaceable>offset</replaceable>
parameter specifies which occurrence of the pattern to capture (0-based).
Offset 0 (default) returns the first match; offset 1 returns the second
match, etc.  This is useful for capturing the Nth occurrence in a line, such
as the second number in a string.  Returns <literal>none</literal> if the
pattern doesn't match, the group index is out of range, or the offset
exceeds the number of matches.  If <replaceable>str</replaceable> is an
array, the result is an array with captures for each element.  The search is
case-insensitive by default (respects
<literal>@cs</literal>/<literal>@ci</literal> directives).</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>regexExtract("abc123", "[a-z]+\d+")</literal> returns
<literal>"abc123"</literal> (entire match)</para></listitem>
                  <listitem><para><literal>regexExtract("abc123", "([a-z]+)(\d+)", 1)</literal> returns
<literal>"abc"</literal> (first capture group)</para></listitem>
                  <listitem><para><literal>regexExtract("abc123", "([a-z]+)(\d+)", 2)</literal> returns
<literal>"123"</literal> (second capture group)</para></listitem>
                  <listitem><para><literal>regexExtract("2025-05-16", "(\d{4})-(\d{2})-(\d{2})", 1)</literal>
returns <literal>"2025"</literal></para></listitem>
                  <listitem><para><literal>regexExtract("user@example.com", "([^@]+)@([^@]+)", 1)</literal>
returns <literal>"user"</literal></para></listitem>
                  <listitem><para><literal>regexExtract("user@example.com", "([^@]+)@([^@]+)", 2)</literal>
returns <literal>"example.com"</literal></para></listitem>
                  <listitem><para><literal>regexExtract("value 123 and value 456", "(\d+)", 0, 0)</literal>
returns <literal>"123"</literal> (first number)</para></listitem>
                  <listitem><para><literal>regexExtract("value 123 and value 456", "(\d+)", 0, 1)</literal>
returns <literal>"456"</literal> (second number)</para></listitem>
                  <listitem><para><literal>regexExtract("v1.0.0 and v2.0.0", "v(\d+)\.(\d+)\.(\d+)", 1,
1)</literal> returns <literal>"2"</literal> (major version of second
occurrence)</para></listitem>
                  <listitem><para><literal>regexExtract("test", "\d+")</literal> returns
<literal>none</literal> (no match)</para></listitem>
                  <listitem><para><literal>regexExtract("abc", "([a-z])", 5)</literal> returns
<literal>none</literal> (group out of range)</para></listitem>
                  <listitem><para><literal>regexExtract(array("abc123", "def456"), "([a-z]+)(\d+)",
1)</literal> returns <literal>array("abc", "def")</literal></para></listitem>
                  <listitem><para><literal>@cs regexExtract("ABC123", "([a-z]+)", 1)</literal> returns
<literal>none</literal> (case-sensitive, no match)</para></listitem>
                  <listitem><para><literal>le:regexExtract(Line, "error:\s+(\w+)", 1)</literal> extracts error
type from log lines</para></listitem>
                  <listitem><para><literal>fe:regexExtract(Name, "v(\d+)\.(\d+)\.(\d+)", 1) = "2"</literal>
filters files with major version 2</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>normalizeUnicode</function>(str[, form])</term>
              <listitem>
                <para>
Normalizes Unicode string. The optional form parameter specifies the
normalization form: "NFC" or "C" (default), "NFD" or "D", "NFKC" or "KC",
"NFKD" or "KD".  Can also use numeric forms: 1=NFC, 2=NFD, 5=NFKC, 6=NFKD.
If <replaceable>str</replaceable> is an array, the result is an array of
normalized strings.  Example: <literal>normalizeUnicode(name,
"NFC")</literal></para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toLower</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converts all characters in the string to lowercase.  If
<replaceable>str</replaceable> is an array, the result is an array of
lowercase strings.  Example: <literal>toLower("Hello World")</literal>
returns <literal>"hello world"</literal></para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toUpper</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converts all characters in the string to uppercase.  If
<replaceable>str</replaceable> is an array, the result is an array of
uppercase strings.  Example: <literal>toUpper("Hello World")</literal>
returns <literal>"HELLO WORLD"</literal></para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toHalfWidth</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converts full-width characters to half-width characters.  Primarily used for
converting full-width alphanumeric and katakana characters to half-width.
If <replaceable>str</replaceable> is an array, the result is an array of
converted strings.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toFullWidth</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converts half-width characters to full-width characters.  Primarily used for
converting half-width alphanumeric and katakana characters to full-width.
If <replaceable>str</replaceable> is an array, the result is an array of
converted strings.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toKatakana</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converts hiragana characters to katakana.  Non-hiragana characters remain
unchanged.  If <replaceable>str</replaceable> is an array, the result is an
array of converted strings.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toHiragana</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converts katakana characters to hiragana.  Non-katakana characters remain
unchanged.  If <replaceable>str</replaceable> is an array, the result is an
array of converted strings.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toSimplifiedChinese</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converts traditional Chinese characters to simplified Chinese characters.
Characters that don't have a simplified form remain unchanged.  If
<replaceable>str</replaceable> is an array, the result is an array of
converted strings.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>toTraditionalChinese</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converts simplified Chinese characters to traditional Chinese characters.
Characters that don't have a traditional form remain unchanged.  If
<replaceable>str</replaceable> is an array, the result is an array of
converted strings.</para>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>trim</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Removes leading and trailing whitespace characters (space, tab, newline,
carriage return) from the string.  If <replaceable>str</replaceable> is an
array, the result is an array of trimmed strings.</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>trim(" hello ")</literal> returns <literal>"hello"</literal></para></listitem>
                  <listitem><para><literal>trim(array(" test ", " data "))</literal> returns
<literal>array("test", "data")</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>trimLeft</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Removes leading whitespace characters (space, tab, newline, carriage return)
from the beginning of the string.  Trailing whitespace is preserved.  If
<replaceable>str</replaceable> is an array, the result is an array of
left-trimmed strings.</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>trimLeft(" hello ")</literal> returns <literal>"hello "</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term>
<function>trimRight</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Removes trailing whitespace characters (space, tab, newline, carriage
return) from the end of the string.  Leading whitespace is preserved.  If
<replaceable>str</replaceable> is an array, the result is an array of
right-trimmed strings.</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>trimRight(" hello ")</literal> returns <literal>" hello"</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_FileContentFunctions">
          <title>File Content Functions</title>
          <variablelist>
            <varlistentry>
              <term><function>lineCount</function>(<replaceable>content</replaceable>)</term>
              <listitem><para>Returns the number of lines in the file content or file content array as an
<literal>Integer</literal>. If <replaceable>content</replaceable> is an
array, the result is an integer array. Example:
<literal>lineCount(Content)</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>sublines</function>(<replaceable>content</replaceable>,
<replaceable>start</replaceable>, <replaceable>count</replaceable>)</term>
              <listitem>
                <para>
Extracts the specified number of lines starting from the given line index in
the file content or file content array, and returns them as a single
concatenated string.  If <replaceable>content</replaceable> is an array, the
result is an array of strings.</para>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_TypeConversionFunctions">
          <title>Type Conversion Functions</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>Convert a string to a number. <function>toNumber</function> returns an
integer or floating-point number depending on the input format;
<function>toInt</function> returns only integers;
<function>toDouble</function> returns only floating-point numbers.  Commas
in the input are ignored. Returns <literal>none</literal>on parse failure.
Example: <literal>le:toInt(Column("Count")) &gt; 100</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>toDateTime</function>(<replaceable>str</replaceable>)</term>
              <listitem>
                <para>
Converts a string to a timestamp value. Supports multiple date/time
formats.  Returns <literal>none</literal>if the string cannot be parsed.
Example: <literal>toDateTime("2025-01-15") &gt; today()</literal></para>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_DateTimeFunctions">
          <title>Date/Time Functions</title>
          <variablelist>
            <varlistentry>
              <term><function>now</function>()</term>
              <listitem><para>Returns the current date and time as a <literal>Timestamp</literal> value.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>today</function>()</term>
              <listitem><para>Returns today's date as a <literal>Timestamp</literal> value representing
<literal>00:00:00.000</literal> at the start of the day.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>startOfWeek</function>(<replaceable>timestamp</replaceable>)</term>
              <listitem><para>Returns the first day of the week, which is always Sunday regardless of
locale.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>startOfMonth</function>(<replaceable>timestamp</replaceable>)</term>
              <listitem><para>Returns the first day of the month.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>startOfYear</function>(<replaceable>timestamp</replaceable>)</term>
              <listitem><para>Returns the first day of the year.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>toDateStr</function>(<replaceable>timestamp</replaceable>)</term>
              <listitem><para>Converts the given timestamp to a date string in
<literal>yyyy-MM-dd</literal> format. If
<replaceable>timestamp</replaceable> is a timestamp array, the result is a
string array.</para></listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_MathFunctions">
          <title>Math and Comparison Functions</title>
          <variablelist>
            <varlistentry>
              <term><function>abs</function>(<replaceable>value</replaceable>)</term>
              <listitem><para>Returns the absolute value of the <emphasis>integer or integer
array</emphasis>. If <replaceable>value</replaceable> is an integer array,
the result is an integer array.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>isWithin</function>(<replaceable>value</replaceable>,
<replaceable>min</replaceable>, <replaceable>max</replaceable>)</term>
              <listitem>
                <para>
Returns <literal>true</literal> if <replaceable>value</replaceable> is
within the range <literal>[min, max]</literal> (inclusive on both ends).
Supports integers, floating-point numbers, timestamps, and strings
(case-insensitive comparison).  If <replaceable>value</replaceable> is an
array, the result is a boolean array with each element checked individually.</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>isWithin(5, 1, 10)</literal> returns <literal>true</literal></para></listitem>
                  <listitem><para><literal>isWithin(Size, 1KB, 10MB)</literal> checks if any file size is
between 1KB and 10MB</para></listitem>
                  <listitem><para><literal>isWithin(Date, today() - 7days, today())</literal> checks if file
was modified within the last week</para></listitem>
                  <listitem><para><literal>allof(isWithin(Size, 1KB, 10MB))</literal> checks if all file sizes
are between 1KB and 10MB</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>inRange</function>(<replaceable>value</replaceable>,
<replaceable>min</replaceable>, <replaceable>max</replaceable>)</term>
              <listitem>
                <para>
Returns <literal>true</literal> if <replaceable>value</replaceable> is
within the range <literal>[min, max)</literal> (inclusive on the lower
bound, exclusive on the upper bound).  Supports integers, floating-point
numbers, timestamps, and strings (case-insensitive comparison).  If
<replaceable>value</replaceable> is an array, the result is a boolean array
with each element checked individually.</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>inRange(5, 1, 10)</literal> returns <literal>true</literal></para></listitem>
                  <listitem><para><literal>inRange(10, 1, 10)</literal> returns <literal>false</literal></para></listitem>
                  <listitem><para><literal>inRange(Size, 0, 1MB)</literal> checks if any file size is less
than 1MB</para></listitem>
                  <listitem><para><literal>anyof(inRange(Date, startOfMonth(today()), today()))</literal>
checks if any file was modified this month (excluding today)</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_ArrayFunctions">
          <title>Array Functions</title>
          <variablelist>
            <varlistentry>
              <term><function>array</function>(<replaceable>value1</replaceable>,
<replaceable>value2</replaceable>, ...)</term>
              <listitem><para>Creates an array from the given values. Example: <literal>array(1, 2,
3)</literal></para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>at</function>(<replaceable>array</replaceable>,
<replaceable>index</replaceable>)</term>
              <listitem><para>Returns the element at the specified index (0-based). Negative indices count
from the end. Example: <literal>at(array(1, 2, 3), -1)</literal> returns 3</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>anyof</function>(<replaceable>booleans</replaceable>)</term>
              <listitem><para>Returns <literal>true</literal> if any element in the <emphasis>boolean
array</emphasis> satisfies the condition.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>allof</function>(<replaceable>booleans</replaceable>)</term>
              <listitem><para>Returns <literal>true</literal> if all elements in the <emphasis>boolean
array</emphasis> satisfy the condition.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>allequal</function>(<replaceable>array</replaceable>)</term>
              <listitem><para>Returns <literal>true</literal> if all values in the array are equal.</para></listitem>
            </varlistentry>
            <varlistentry>
              <term><function>len</function>(<replaceable>value</replaceable>)</term>
              <listitem>
                <para>Returns the length of the value as an <literal>Integer</literal>.</para>
                <para>Behavior:</para>
                <itemizedlist>
                  <listitem><para><emphasis>Array</emphasis>: Returns the number of elements in the array</para></listitem>
                  <listitem><para><emphasis>String</emphasis>: Returns the UTF-8 character count</para></listitem>
                  <listitem><para><emphasis>None (monostate)</emphasis>: Returns 0</para></listitem>
                  <listitem><para><emphasis>Other scalar values</emphasis> (Integer, Real, Boolean, Timestamp,
etc.): Returns 1</para></listitem>
                </itemizedlist>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>len(array(1, 2, 3))</literal> - returns 3</para></listitem>
                  <listitem><para><literal>len("hello")</literal> - returns 5</para></listitem>
                  <listitem><para><literal>len(123)</literal> - returns 1</para></listitem>
                  <listitem><para><literal>len(Size)</literal> - returns the number of sides (2 or 3) in a
folder comparison</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_ConditionalFunctions">
          <title>Conditional Functions</title>
          <variablelist>
            <varlistentry>
              <term><function>if</function>(<replaceable>condition</replaceable>,
<replaceable>trueValue</replaceable>, <replaceable>falseValue</replaceable>)</term>
              <listitem>
                <para>
Returns <replaceable>trueValue</replaceable> if
<replaceable>condition</replaceable> evaluates to true, otherwise returns
<replaceable>falseValue</replaceable>.  This function performs short-circuit
evaluation (it only evaluates the branch that will be returned).</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>if(Size > 1MB, "large", "small")</literal> - returns "large" or
"small" based on file size</para></listitem>
                  <listitem><para><literal>if(Extension = "txt", "text file", "other file")</literal> -
classifies files by extension</para></listitem>
                  <listitem><para><literal>if(Exists, Size, 0)</literal> - returns file size or 0 if file
doesn't exist</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>ifEach</function>(<replaceable>conditionArray</replaceable>,
<replaceable>trueValue</replaceable>, <replaceable>falseValue</replaceable>)</term>
              <listitem>
                <para>
Element-wise conditional selection. For each element in
<replaceable>conditionArray</replaceable>, returns the corresponding element
from <replaceable>trueValue</replaceable> if the condition is true,
otherwise returns the corresponding element from
<replaceable>falseValue</replaceable>.  If
<replaceable>trueValue</replaceable> or
<replaceable>falseValue</replaceable> is a scalar, it is broadcast to all
elements.</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>ifEach(Size &gt; 1MB, "large", "small")</literal> - returns array
of "large"/"small" labels for each file</para></listitem>
                  <listitem><para><literal>ifEach(array(true, false, true), array("a", "b", "c"), array("x",
"y", "z"))</literal> - returns <literal>array("a", "y", "c")</literal></para></listitem>
                  <listitem><para><literal>anyof(ifEach(Size &gt; 100KB, Size &lt; 10MB, false))</literal> -
checks if any file is between 100KB and 10MB</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>choose</function>(<replaceable>index</replaceable>,
<replaceable>value0</replaceable>, <replaceable>value1</replaceable>, ...)</term>
              <listitem>
                <para>
Selects a value from the arguments based on
<replaceable>index</replaceable>.  If <replaceable>index</replaceable> is 0,
returns <replaceable>value0</replaceable>; if 1, returns
<replaceable>value1</replaceable>, etc.  Negative indices are clamped to
0. Indices beyond the last value return the last value.</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>choose(0, "first", "second", "third")</literal> - returns "first"</para></listitem>
                  <listitem><para><literal>choose(DiffCode % 3, "equal", "different", "unique")</literal> -
maps diff codes to labels</para></listitem>
                  <listitem><para><literal>choose(5, "a", "b", "c")</literal> - returns "c" (out of bounds,
returns last value)</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
            <varlistentry>
              <term><function>chooseEach</function>(<replaceable>indexArray</replaceable>,
<replaceable>value0</replaceable>, <replaceable>value1</replaceable>, ...)</term>
              <listitem>
                <para>
Element-wise value selection. For each index in
<replaceable>indexArray</replaceable>, selects the corresponding value from
the remaining arguments.  If <replaceable>indexArray</replaceable> is a
scalar, behaves like <literal>choose</literal>.</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>chooseEach(array(0, 1, 2), "a", "b", "c")</literal> - returns
<literal>array("a", "b", "c")</literal></para></listitem>
                  <listitem><para><literal>chooseEach(array(0, 0, 1), "x", "y")</literal> - returns
<literal>array("x", "x", "y")</literal></para></listitem>
                  <listitem><para><literal>chooseEach(array(2, 0, 1), "first", "second", "third")</literal> -
returns <literal>array("third", "first", "second")</literal></para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_LogicalFunctions">
          <title>Element-wise Logical Functions</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>
Element-wise logical operations. These functions operate on booleans,
boolean arrays, or a combination of both:</para>
                <itemizedlist>
                  <listitem><para><literal>andEach</literal> - Logical AND operation</para></listitem>
                  <listitem><para><literal>orEach</literal> - Logical OR operation</para></listitem>
                  <listitem><para><literal>notEach</literal> - Logical NOT operation (single argument)</para></listitem>
                </itemizedlist>
                <para>
When arguments are scalars, returns a scalar boolean result.  When one
argument is an array and the other is a scalar, the scalar is broadcast to
all elements.  When both arguments are arrays, performs element-wise
operation.</para>
                <para>Examples:</para>
                <itemizedlist>
                  <listitem><para><literal>andEach(Size &gt; 1KB, Size &lt; 1MB)</literal> - files between 1KB
and 1MB</para></listitem>
                  <listitem><para><literal>orEach(Extension = "txt", Extension = "log")</literal> - txt or log
files</para></listitem>
                  <listitem><para><literal>notEach(Exists)</literal> - files that don't exist</para></listitem>
                  <listitem><para><literal>allof(andEach(Exists, Size &gt; 0))</literal> - all files exist
with non-zero size</para></listitem>
                  <listitem><para><literal>anyof(notEach(Size &gt; 1MB))</literal> - any file 1MB or smaller</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>

        <section id="FilterExpression_DiagnosticFunctions">
          <title>Diagnostic and Logging Functions</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>
Outputs the concatenated string representation of all arguments to the log
(at error, warning, or information level respectively), separated by spaces,
and returns the last argument value.  These functions are useful for
debugging filter expressions.</para>
                <para>Examples (using return value):</para>
                <itemizedlist>
                  <listitem><para><literal>logInfo("File size:", Size) > 1MB</literal> - logs the file size(s)
and checks if greater than 1MB</para></listitem>
                  <listitem><para><literal>logWarn("Processing:", Name) like "*.tmp"</literal> - logs the file
name(s) and checks if it's a temporary file</para></listitem>
                  <listitem><para><literal>Size > 1KB and logInfo("Large file:", Name) contains
"test"</literal> - logs only when size condition is true, then checks name</para></listitem>
                </itemizedlist>
              </listitem>
            </varlistentry>
          </variablelist>
        </section>
      </section>

      <section id="FilterExpression_Units">
        <title>Units</title>
        <para>File sizes support these suffixes:</para>
        <simplelist type="inline">
          <member>KB</member>
          <member>MB</member>
          <member>GB</member>
          <member>TB</member>
        </simplelist>
        <para>Time durations support these suffixes:</para>
        <simplelist type="inline">
          <member>weeks</member><member>week</member><member>w</member>
          <member>days</member><member>day</member><member>d</member>
          <member>hours</member><member>hour</member><member>hr</member><member>h</member>
          <member>minutes</member><member>minute</member><member>min</member><member>m</member>
          <member>seconds</member><member>second</member><member>sec</member><member>s</member>
          <member>milliseconds</member><member>millisecond</member><member>msec</member><member>ms</member>
        </simplelist>
      </section>

      <section id="FilterExpression_Examples">
        <title>Examples</title>
        <itemizedlist>
          <listitem><para><literal>Size &lt; 10KB</literal> - Any side's size is less than 10KB</para></listitem>
          <listitem><para><literal>LeftSize &gt;= 10MB</literal> - Left side file is at least 10MB</para></listitem>
          <listitem><para><literal>allof(Size &lt; 1MB)</literal> - All sides are under 1MB</para></listitem>
          <listitem><para><literal>abs(LeftSize - RightSize) &lt; 1KB</literal> - Size difference is
small</para></listitem>
          <listitem><para><literal>DateStr = "2025-07-20"</literal> - File was last modified on that
date</para></listitem>
          <listitem><para><literal>Date &gt;= today()</literal> - Modified today or later</para></listitem>
          <listitem><para><literal>Date &gt; d"2026-05-21 07:16:33"</literal> - Modified after a
specific date and time</para></listitem>
          <listitem><para><literal>isWithin(Date, d"2026-01-01", d"2026-12-31 23:59:59")</literal> -
Modified during the year 2026</para></listitem>
          <listitem><para><literal>isWithin(Date, today() - 7days, today())</literal> - File modified
within the last week</para></listitem>
          <listitem><para><literal>inRange(Size, 1KB, 10MB)</literal> - File size is between 1KB
(inclusive) and 10MB (exclusive)</para></listitem>
          <listitem><para><literal>allof(isWithin(Size, 100KB, 1MB))</literal> - All file sizes are
between 100KB and 1MB</para></listitem>
          <listitem><para><literal>AttrStr contains "R"</literal> - File is read-only</para></listitem>
          <listitem><para><literal>Name matches "file[0-9]\.txt"</literal> - Regex on filename</para></listitem>
          <listitem><para><literal>Content contains "Test"</literal> - File content includes keyword</para></listitem>
          <listitem><para><literal>sublines(Content, 0, 1) contains "XML"</literal> - First line
contains "XML"</para></listitem>
          <listitem><para><literal>strCount(Content, "TODO") &gt; 5</literal> - File contains more
than 5 TODO comments</para></listitem>
          <listitem><para><literal>regexCount(Content, "\bFIXME\b") &gt; 0</literal> - File contains
at least one FIXME marker</para></listitem>
          <listitem><para><literal>strFind(Name, "_test") != none</literal> - Files containing "_test"
in their name</para></listitem>
          <listitem><para><literal>strFind(Name, ".", 1) &gt; 0</literal> - Files with multiple dots
in their name (second dot exists)</para></listitem>
          <listitem><para><literal>regexFind(Name, "\d{4}") &lt; 5</literal> - Files where a 4-digit
number appears within the first 5 characters</para></listitem>
          <listitem><para><literal>regexExtract(Name, "v(\d+)\.(\d+)\.(\d+)", 1) = "2"</literal> -
Files with major version 2 (e.g., "v2.16.48")</para></listitem>
          <listitem><para><literal>regexExtract(Name, "([^_]+)_([^_]+)\.txt", 2) like
"test*"</literal> - Files where second part of name starts with "test"</para></listitem>
          <listitem><para><literal>le:regexExtract(Line, "(\d+)", 0, 1)</literal> - Extracts the
second number in each line (offset=1)</para></listitem>
          <listitem><para><literal>(Extension = "log" and Size > 10MB) or (Date &lt; today() -
7days)</literal> - Large log files or files older than a week</para></listitem>
          <listitem><para><literal>AttrStr not contains "H" and Name like "*.tmp"</literal> -
Non-hidden temporary files</para></listitem>
          <listitem><para><literal>isWithin(Extension, "a", "m") and inRange(Size, 0, 1MB)</literal> -
Files with extensions from 'a' to 'm' and size less than 1MB</para></listitem>
          <listitem><para><literal>toLower(Name) = "readme.txt"</literal> - Case-insensitive filename
matching</para></listitem>
          <listitem><para><literal>toHalfWidth(Name) like "*.txt"</literal> - Match after converting
full-width to half-width</para></listitem>
          <listitem><para><literal>trim(Name) = "readme.txt"</literal> - Match filename after removing
leading/trailing whitespace</para></listitem>
          <listitem><para><literal>trimLeft(Column("Value")) = "123"</literal> - Match column value
after removing leading whitespace (table mode)</para></listitem>
          <listitem><para><literal>trimRight(Line) contains "end"</literal> - Check if line (without
trailing whitespace) contains "end"</para></listitem>
          <listitem><para><literal>EOL = 3</literal> - Files with CRLF (Windows) line endings</para></listitem>
          <listitem><para><literal>EOLStr = "LF"</literal> - Files with LF (Unix) line endings</para></listitem>
          <listitem><para><literal>allof(EOL = 1)</literal> - Checks whether all compared files use LF
line endings</para></listitem>
          <listitem><para><literal>leftprop("System.Title") != none</literal> - Left file has a title
property set</para></listitem>
          <listitem><para><literal>prop("System.Author") = none</literal> - No author property is set
on any side</para></listitem>
          <listitem><para><literal>if(LeftExists, LeftSize, 0) == 0</literal> - Checks whether the
left file is missing or empty</para></listitem>
          <listitem><para><literal>Different</literal> - Show only files/folders that are different
(Display filter only)</para></listitem>
          <listitem><para><literal>Identical</literal> - Show only files/folders that are identical
(Display filter only)</para></listitem>
          <listitem><para><literal>allof(Binary)</literal> - Show only files that are binary on all
sides (Display filter only)</para></listitem>
          <listitem><para><literal>DifferentLeftMiddle and not DifferentMiddleRight</literal> - In
3-way comparison, show files where only left-middle pair differs (Display
filter only)</para></listitem>
        </itemizedlist>
      </section>
    </section>
  </section>

  <section id="Filters_FileFilter">
    <title>שימוש במסנני קבצים<indexterm>
        <primary>מסננים</primary>

        <secondary>מסנני קבצים</secondary>
      </indexterm><indexterm>
        <primary>מסננים</primary>

        <secondary>בהשוואות תיקיות</secondary>
      </indexterm></title>

    <para><glossterm>מסנני קבצים</glossterm> הם קבצי טקסט עם סיומת של
<filename>flt</filename>. הם מאפשרים לך להחיל כללי סינון מרובים על השוואת
תיקיות. בניגוד למסיכות קבצים, מסנני קבצים יכולים לכלול או לא לכלול התאמות.</para>

    <para><indexterm>
        <primary>מסנני קבצים</primary>

        <secondary>תבנית</secondary>
      </indexterm>WinMerge מתקין מספר מסנני קבצים
מוגדרים מראש. אם מסנני קבצים אלה אינם מספקים את הסינון הדרוש לך, תוכל ליצור
מסננים משלך. כדי להקל על משימה זו, WinMerge מספק גם קובץ תבנית בשם
<filename>FileFilter.tmpl</filename>. סעיף זה מתאר כיצד להחיל מסנני קבצים על
השוואות, ומתעד את תחביר מסנן הקבצים. <xref linkend="Filters_dlg" /> מתאר
כיצד להוסיף, לערוך ולנהל מסננים.</para>

    <section id="Filters_FileFilterLoc">
      <title>מיקומי מסנני קבצים<indexterm>
          <primary>תיקיות סינון</primary>

          <secondary>מיקומים</secondary>
        </indexterm><indexterm>
          <primary>מסנני קבצים</primary>

          <secondary>מיקומים</secondary>
        </indexterm></title>

      <para>WinMerge מזהה אוטומטית מסנני קבצים במיקומים אלה:</para>

      <variablelist>
        <varlistentry>
          <term>תיקיית המשנה מסננים בתיקיית ההתקנה של WinMerge</term>

          <listitem>
            <para>כאן מותקנים מסנני הקבצים המוגדרים מראש. לדוגמה, <filename>C:\Program
Files\WinMerge\Filters</filename>. אתה יכול ליצור או להעתיק קבצי מסנן במיקום
זה כדי להפוך אותם לזמינים לכל המשתמשים במערכת שלך.</para>

            <para>לפני יצירת מסנן קבצים חדש, בדוק אם המסננים המוגדרים מראש כבר מכילים את מה
שאתה צריך. אם לא, ייתכן שתמצא דוגמאות שימושיות לכללים בקבצים הקיימים.</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term>תיקיית מסננים פרטית ברירת מחדל</term>

          <listitem>
            <para>המיקום של תיקייה זו מוגדר בדף מערכת של אפשרויות WinMerge. כברירת מחדל, הוא
מצוין כתיקיית משנה בתיקיית פרופיל המשתמש שלך (לדוגמה,
<filename>Documents</filename> ב-Windows 10). מסננים שנוצרים או מועתקים לכאן
בדרך כלל גלויים רק לך. אם אתה יוצר מסנני קבצים חדשים, אתה יכול להעתיק אותם
לכאן כדי לשמור אותם פרטיים.</para>
          </listitem>
        </varlistentry>
      </variablelist>

      <para>לפני שתוכל להחיל מסנני קבצים הקיימים בכל תיקייה אחרת, עליך להתקין אותם
תחילה.</para>
    </section>

    <section id="Filters_FileFilterApply">
      <title>החלת מסנני קבצים<indexterm>
          <primary>מסנני קבצים</primary>

          <secondary>החלה</secondary>
        </indexterm></title>

      <para>אתה יכול להחיל מסנן קבצים באמצעות אחת מהשיטות הבאות:</para>

      <itemizedlist>
        <listitem>
          <para>כשאתה מפעיל השוואת תיקיות מתיבת הדו-שיח בחר קבצים או תיקיות:</para>

          <orderedlist>
            <listitem>
              <para>לאחר בחירת התיקיות <guilabel>1</guilabel> ו-<guilabel>2</guilabel>, לחץ על
<guibutton>בחר</guibutton> ליד השדה <guilabel>מסנן</guilabel>.</para>
            </listitem>

            <listitem>
              <para>בתיבת הדו-שיח מסננים, השתמש בכרטיסייה מסנני קבצים כדי לבחור מסנן קבצים
ולטעון אותו בשדה <guilabel>מסנן</guilabel>.</para>

              <note>
                <para>אם מסנן קבצים מופעל כעת, מסנן הקבצים שנבחר כבר נטען בשדה
<guilabel>מסנן</guilabel>.</para>
              </note>
              <para></para>
            </listitem>

            <listitem>
              <para>המשך בפעולת ההשוואה. הקובץ בשדה <guilabel>מסנן</guilabel> מוחל כשאתה מתחיל
את הפעולה.</para>
            </listitem>
          </orderedlist>
        </listitem>

        <listitem>
          <para>כדי לשנות את סינון הקבצים לאחר שכבר הפעלת פעולת השוואת תיקיות (לדוגמה, החלת
מסנן אחר או השבתת סינון):</para>

          <orderedlist>
            <listitem>
              <para>לחץ על <menuchoice> <guimenu>כלים</guimenu>
<guimenuitem>מסננים</guimenuitem> </menuchoice>.</para>
            </listitem>

            <listitem>
              <para>בתיבת הדו-שיח מסננים, הגדר את הגדרת מסנן הקבצים החדשה שלך ולחץ על
<guibutton>אישור</guibutton>.</para>
            </listitem>

            <listitem>
              <para>הסינון החדש לא מוחל אוטומטית כשאתה סוגר את תיבת הדו-שיח מסננים: הקש
<keycap>F5</keycap> כדי לראות את התוצאות החדשות בחלון השוואת התיקיות.</para>
            </listitem>
          </orderedlist>
        </listitem>

        <listitem>
          <para><indexterm>
              <primary>שורת פקודה</primary>

              <secondary>החלת מסנני קבצים</secondary>
            </indexterm>כשאתה מפעיל השוואת תיקיות משורת הפקודה
של WinMerge, השתמש בדגל <option>-f</option> כדי לציין מסנן קבצים.</para>
        </listitem>
      </itemizedlist>
    </section>

    <section id="Filters_FileFilterSyntax">
      <title>תחביר מסנן קבצים<indexterm>
          <primary>כללים</primary>

          <secondary>מסנן קבצים</secondary>
        </indexterm><indexterm>
          <primary>מסנני קבצים</primary>

          <secondary>תחביר</secondary>
        </indexterm></title>

      <para>סעיף זה מתאר את התחביר של מסנני קבצים של WinMerge ומספק הנחיות לכתיבתם.</para>

      <para>תו המפריד להערות הוא <code>##</code>. לאחר מפריד הערות, כל התווים בשורה
מתעלמים מהם. WinMerge מתעלם מרוב תווי הרווח הלבן בכללים. עם זאת, הערה חייבת
תמיד להיות מוקדמת על ידי תו רווח לבן (רווח או טאב) אחד או יותר. כדי להשתמש
ב-<code>##</code> כתווים בכלל, השמט את קידומת הרווח הלבן.</para>

      <para>שתי השורות הנדרשות הראשונות של מסנן קבצים הן:</para>

      <variablelist>
        <varlistentry>
          <term>שם</term>

          <listitem>
            <para>שם המסנן המופיע בתיבת הדו-שיח קבצים</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term>def</term>

          <listitem>
            <para>סוג הסינון שיש להחיל. ציין אחד מהערכים הבאים:</para>

            <variablelist>
              <varlistentry>
                <term>כלול</term>

                <listitem>
                  <para>כולל הכל מלבד פריטים התואמים לכלל שצוין.</para>
                </listitem>
              </varlistentry>

              <varlistentry>
                <term>אל תכלול</term>

                <listitem>
                  <para>לא כולל הכל מלבד פריטים התואמים לכלל שצוין.</para>

                  <para>כשאתה בוחר בשיטת החרגה, עליך גם להוסיף כלל <guilabel>d</guilabel> (ספרייה)
שמציין את תיקיות המשנה. בדרך כלל כדאי לציין את כל תיקיות המשנה, כך:</para>

                  <screen>d: \\*$ ## תיקיות משנה</screen>
                </listitem>
              </varlistentry>
            </variablelist>

            <tip>
              <para>אל תבלבל בין מונחים אלה. זכור, במסנני קבצים, כלל <guilabel>כלול</guilabel>
לא מציין מה לכלול, הוא מציין מה <emphasis>לא</emphasis> לכלול. באופן דומה,
<guilabel>אל תכלול</guilabel> לא מציין מה לא לכלול, הוא מציין מה לא לא
לכלול.</para>
            </tip>
          </listitem>
        </varlistentry>
      </variablelist>

      <para>Next, your file should contain one or more filter rules. You can add as many
rules as you like. There must be one rule per line, and each rule must be
entirely on one line (no line breaks are allowed in a rule).  A rule begins
with a type designator, followed by either a regular expression or a filter
expression.  The supported type designators are:</para>

      <variablelist>
        <varlistentry><term>f: <replaceable>regexp</replaceable></term><listitem><para>Match file names using regular expressions</para></listitem></varlistentry>
        <varlistentry><term>f!: <replaceable>regexp</replaceable></term><listitem><para>Exclude files matching regex (Available since 2.16.19)</para></listitem></varlistentry>
        <varlistentry><term>d: <replaceable>regexp</replaceable></term><listitem><para>Match folder names using regex</para></listitem></varlistentry>
        <varlistentry><term>d!: <replaceable>regexp</replaceable></term><listitem><para>Exclude folders matching regex (Available since 2.16.19)</para></listitem></varlistentry>
        <varlistentry><term>fe: <replaceable>expr</replaceable></term><listitem><para>Filter expression for files (e.g. fe:Size &lt; 1KB) (Available since
2.16.49)</para></listitem></varlistentry>
        <varlistentry><term>fe!: <replaceable>expr</replaceable></term><listitem><para>Filter expression to exclude files (Available since 2.16.49)</para></listitem></varlistentry>
        <varlistentry><term>de: <replaceable>expr</replaceable></term><listitem><para>Filter expression for folders (Available since 2.16.49)</para></listitem></varlistentry>
        <varlistentry><term>de!: <replaceable>expr</replaceable></term><listitem><para>Filter expression to exclude folders (Available since 2.16.49)</para></listitem></varlistentry>
        <varlistentry><term>e: <replaceable>expr</replaceable></term><listitem><para>Filter expression applied to both files and folders (e.g. e:Name like
"Common*.*") (Available since 2.16.56)</para></listitem></varlistentry>
        <varlistentry><term>e!: <replaceable>expr</replaceable></term><listitem><para>Filter expression to exclude both files and folders (Available since
2.16.56)</para></listitem></varlistentry>
      </variablelist>

      <para>בין רבים מתווים מיוחדים של regexp, הבאים חשובים במיוחד בכללי מסנן
קבצים:<indexterm>
          <primary>ביטויים רגולריים</primary>

          <secondary>תווים מיוחדים במסננים</secondary>
        </indexterm><indexterm>
          <primary>ביטויים רגולריים</primary>

          <secondary>במסנני קבצים</secondary>
        </indexterm></para>

      <variablelist>
        <varlistentry>
          <term>^ (תחילת שורה)</term>

          <listitem>
            <para>נדרש לעתים קרובות כדי שהכללים יעבדו כראוי.</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term>$ (סוף שורה)</term>

          <listitem>
            <para>נדרש לעתים קרובות כדי שהכללים יעבדו כראוי. לדוגמה:</para>

            <screen>\.c$ ## תואם רק לשמות קבצים עם הסיומת <filename>c</filename>.
\.c ## תואם לכל סיומת שמתחילה ב-<filename>c</filename>, כמו <filename>cpp</filename> ו-<filename>com</filename>.</screen>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term>\ (בריחה)</term>

          <listitem>
            <para>מכריח תווים מיוחדים להתאים לתווים רגילים. לדוגמה, כדי להתאים שם תיקייה, הקדם
את תו המפריד של קו נטוי הפוך של התיקייה עם קו נטוי הפוך
(<code>\\</code>). כדי להתאים את הנקודה בשם קובץ, ציין קו נטוי הפוך ואחריו
נקודה (<code>\.</code>).</para>
          </listitem>
        </varlistentry>
      </variablelist>

      <para>לא נעשה שימוש בתווים מיוחדים או בתווים כלליים כדי להתאים לשמות קבצים. כדי
להתאים את כל שמות הקבצים מסוג מסוים, פשוט השמט את שם הקובץ.</para>

      <para>הכללים אינם תלויי אותיות רישיות/קטנות. לדוגמה, <code>f: \.bat$</code> תואם
ל-<filename>winmerge.bat</filename> ו-<filename>compare.BAT</filename>.</para>

      <example>
        <title>דוגמאות לכללי סינון קבצים</title>

        <para>כמה כללי סינון קבצים פשוטים:</para>

<screen>f: \.cpp$ ## התאם לקבצי <filename>*.cpp</filename>
f: \.h$ ## התאם לקבצי <filename>*.h</filename>
f: ^My ## התאם לקבצי <filename>My*.*</filename>
f: Dlg\. ## התאם לקבצי <filename>*Dlg.*</filename>
d: \\test$ ## התאם לתיקיות <filename>test</filename>
d: ^\\Build$ ## התאם לתיקיות <filename>Build</filename>
d: Temp$ ## התאם לתיקיות <filename>*Temp</filename> (לדוגמה, <filename>FirstTemp</filename>)
d: Src ## התאם לתיקיות <filename>*Src*</filename></screen><para>כמה כללים עם ביטויים רגולריים מורכבים יותר:</para>

<screen format="linespecific">f: ^\.#.*$ ## קבצי <filename>.#filename.version</filename>
f: Dlg\.c(pp)?$ ## קבצי <filename>*Dlg.c</filename> ו-<filename>*Dlg.cpp</filename>
f: ^I.*\.h$ ## קבצי <filename>I*.h</filename>
f: Srv[1-9]\.def$ ## קבצי <filename>*Srv1.def</filename> עד <filename>*Srv9.def</filename>
f: ^[h,k,m] ## קבצי <filename>h*.*</filename>, <filename>k*.*</filename> ו-<filename>m*.*</filename></screen></example>
    </section>
  </section>

  <section id="Filters_LineFilter">
    <title>שימוש במסנני שורות<indexterm>
        <primary>מסננים</primary>

        <secondary>שורה</secondary>
      </indexterm><indexterm>
        <primary>מסננים</primary>

        <secondary>בהשוואות קבצים</secondary>
      </indexterm></title>

    <para>בהשוואת קבצים, אתה יכול להשתמש במסנני שורות כדי להתעלם משורות
בודדות. לדוגמה, אתה עשוי להשתמש במסנני שורות כדי להתעלם מהערות או מסוג קוד
שנוצר מסוים, כמו חותמות זמן של מערכת בקרת גרסאות. כל מסנן שורות הוא כלל,
ואתה יכול להחיל כל מספר של מסנני שורות על השוואת קבצים.</para>

    <para>כדי ללמוד כיצד להוסיף, לערוך ולנהל מסננים, ראה <xref linkend="Filters_dlg"
/>.</para>

    <section id="Filters_LineFilterApply">
      <title>החלת מסנני שורות</title>

      <para>אתה יכול להחיל מסנני שורות באמצעות אחת מהשיטות הבאות:</para>

      <itemizedlist>
        <listitem>
          <para>כשאתה מפעיל השוואת קבצים מתיבת הדו-שיח בחר קבצים או תיקיות</para>

          <orderedlist>
            <listitem>
              <para>לאחר בחירת הקבצים <guilabel>1</guilabel> ו-<guilabel>2</guilabel>, לחץ על
<guibutton>בחר</guibutton> ליד השדה <guilabel>מסנן</guilabel>.</para>
            </listitem>

            <listitem>
              <para>בתיבת הדו-שיח מסננים, השתמש בכרטיסייה מסנני שורות כדי להפעיל את מסנני השורות
שבהם ברצונך להשתמש (אם יש), או כדי לראות אילו מסנני שורות מופעלים כעת.</para>

              <note>
                <para>השדה <guilabel>מסנן</guilabel> לא מציין אילו מסנני שורות מופעלים.</para>
              </note>
              <para></para>
            </listitem>

            <listitem>
              <para>המשך בפעולת השוואת הקבצים. מסנני השורות המופעלים מוחלים כשאתה מתחיל את
הפעולה.</para>
            </listitem>
          </orderedlist>
        </listitem>

        <listitem>
          <para>לאחר שכבר הפעלת פעולת השוואת קבצים (לדוגמה, כדי להחיל מסננים שונים או להשבית
סינון)</para>

          <orderedlist>
            <listitem>
              <para>לחץ על <menuchoice> <guimenu>כלים</guimenu>
<guimenuitem>מסננים</guimenuitem> </menuchoice>.</para>
            </listitem>

            <listitem>
              <para>פתח את הכרטיסייה מסנני קבצים.</para>
            </listitem>

            <listitem>
              <para>סמן את מסנני השורות הבודדים שברצונך להחיל ובטל את הסימון של מסננים שאינך
רוצה להחיל.</para>

              <para>אתה יכול גם להוסיף, לערוך ולהסיר מסננים מהרשימה באמצעות הכפתורים
<guibutton>חדש</guibutton>, <guibutton>ערוך</guibutton>
ו-<guibutton>הסר</guibutton>.</para>
            </listitem>

            <listitem>
              <para>כדי להפעיל סינון שורות, סמן את <guilabel>אפשר מסנני שורות</guilabel>. כדי
לכבות סינון שורות, בטל את הסימון של האפשרות.</para>
            </listitem>

            <listitem>
              <para>לחץ על <guibutton>אישור</guibutton> כדי לסגור את תיבת הדו-שיח מסנני קבצים.</para>
            </listitem>

            <listitem>
              <para>לחץ על <keycap>F5</keycap> כדי להחיל את השינויים שלך ולרענן את חלון השוואת
הקבצים.</para>
            </listitem>
          </orderedlist>
        </listitem>
      </itemizedlist>
    </section>

    <section id="Filters_LineFilterSyntax">
      <title>תחביר מסנן שורות<indexterm>
          <primary>כללים</primary>

          <secondary>מסנן שורות</secondary>
        </indexterm><indexterm>
          <primary>מסננים</primary>

          <secondary>שורה</secondary>
        </indexterm><indexterm>
          <primary>ביטויים רגולריים</primary>

          <secondary>במסנני שורות</secondary>
        </indexterm></title>

      <para>מסנן שורות הוא כלל המוערך כנגד כל הבדל בשורה בודדת בקבצים המושווים שלך, אם
כללי מסנן שורות מופעלים. כאשר כלל תואם להבדל בשורה בודדת, ההבדל מתעלם ממנו.</para>

      <para>הבדלים שמתעלמים מהם מסומנים בחלון השוואת הקבצים בצבע <guilabel>הבדל שמתעלמים
ממנו</guilabel> (כפי שהוגדר בדף צבעים של אפשרויות WinMerge). זה מאפשר לך
להבחין בין הבדלים שמתעלמים מהם מסוגים אחרים. עם זאת, אינך יכול לבחור או למזג
הבדל שמתעלמים ממנו.</para>

      <para>התאמת מסנן שורות ניתנת לתיאור במונחים של שני רעיונות:</para>

      <itemizedlist>
        <listitem>
          <para>כאשר כלל תואם לכל חלק מהשורה, ההבדל כולו מתעלמים ממנו. לכן, אינך יכול לסנן
רק חלק משורה. לדוגמה, נניח שלשני קבצים יש את ההבדל הבא בשורה בודדת:</para>

          <formalpara>
            <title>קובץ 1:</title>

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

          <formalpara>
            <title>קובץ 2:</title>

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

          <para>ללא סינון, השורה מזוהה כהבדל. אבל אם נחיל כלל מסנן שורות עם הביטוי,
<code>^#</code>, השורות מדווחות כזהות, מכיוון שהביטוי מציין רק את התו
הראשון, התואם בשני הקבצים.</para>
        </listitem>

        <listitem>
          <para>כלל מוחל על הבדל מרובה שורות רק אם כל השורות תואמות. לדוגמה, שקול את ההבדל
הזה בשתי שורות:</para>

          <formalpara>
            <title>קובץ 1:</title>

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

          <formalpara>
            <title>קובץ 2:</title>

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

          <para>אותו כלל <code>^#</code> תואם לשורה הראשונה, אך לא לשורה השנייה. לכן, לא
מתעלמים מההבדל.</para>
        </listitem>
      </itemizedlist>

      <tip>
        <para>בדרך כלל מומלץ להשתמש בסמן תחילת שורה ( <code>^</code> ) וסוף שורה (
<code>$</code> ) כדי לשלוט בדפוסים שלך במדויק, מכיוון שהכלל מוחל אם כל חלק
משורה תואם לביטוי.</para>
      </tip>

      <example>
        <title>מסנני שורות לדוגמה</title>

<screen format="linespecific">^MYTAG$</screen><para>מסנן שורות שתואמות בדיוק ל-<literal>MYTAG</literal></para>

<screen format="linespecific">^::</screen><para>מסנן שורות שמתחילות ב-<literal>::</literal></para>

<screen format="linespecific">^/\*.*\*/$</screen><para>מסנן שורות שמתחילות ב-<literal><constant>/*</constant></literal> ומסתיימות
ב-<literal>*/</literal></para>

<screen format="linespecific">^[1-5]00</screen><para>מסנן שורות שמתחילות במספרים 100, 200, 300, 400 ו-500</para>
      </example>

      <example>
        <title>כלל מסנן שורות התואם לשורות CVS Id</title>

        <para>שורות CVS Id נראות כך:</para>

<screen>// $Id: Filters.xml 7591 2013-01-20 15:47:42Z christianlist $</screen><para>... וניתן לסנן עם כלל זה:</para>

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

      <example>
        <title>סנן הערות מספרי שורות בקבצי po</title>

        <para>הערות מספרי שורות של po נראות כך:</para>

<screen>#: src/filename.c:766</screen><para>... וניתן לסנן עם כלל זה:</para>

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

  <section id="Filters_DisplayLineFilter">
    <title>Using the display line filter<indexterm>
        <primary>display line filter</primary>
      </indexterm></title>

    <para>The display line filter controls which lines are visible in the File Compare
window. Lines that do not match the filter are hidden, but the comparison
result itself is not affected.</para>

    <section id="Filters_DisplayLineFilterApply">
      <title>Opening the display filter bar</title>

      <para>Use any of the following methods to open the display filter bar:</para>

      <itemizedlist>
        <listitem>
          <para>Click <menuchoice> <guimenu>View</guimenu> <guimenuitem>Display Filter
Bar</guimenuitem> </menuchoice>, or press
<keycombo><keycap>Ctrl</keycap><keycap>Shift</keycap>
<keycap>L</keycap></keycombo>.</para>
        </listitem>
        <listitem>
          <para>Right-click selected text in the File Compare window and choose <menuchoice>
<guimenu>Add to Filters</guimenu> <guimenuitem>Add to Display
Filters</guimenuitem> </menuchoice>. WinMerge automatically builds a
<literal>Line contains "..."</literal> expression from the selected text and
opens the filter bar.</para>
        </listitem>
      </itemizedlist>

      <para>To remove the filter, clear the input field and press
<keycap>Enter</keycap>. To hide the filter bar while keeping the filter
active, click the close button.</para>
    </section>

    <section id="Filters_DisplayLineFilterInput">
      <title>Entering a filter</title>

      <para>The display filter bar accepts input in two forms, determined by whether the
input starts with the <literal>le:</literal> prefix:</para>

      <variablelist>
        <varlistentry>
          <term>Plain string (no prefix)</term>
          <listitem>
            <para>Input without the <literal>le:</literal> prefix is treated as a literal
string. WinMerge shows only lines that contain that string. Internally, the
input is equivalent to <literal>le:Line contains
"<replaceable>input</replaceable>"</literal>.</para>
            <para>Example: entering <userinput>TODO</userinput> shows all lines that contain
the text <literal>TODO</literal>.</para>
          </listitem>
        </varlistentry>

        <varlistentry>
          <term><literal>le:</literal> prefix (filter expression)</term>
          <listitem>
            <para>If the input starts with <literal>le:</literal>, the remainder is
interpreted as a filter expression. The full expression syntax described in
<xref linkend="Filters_DisplayLineFilter_Syntax"/> is available.</para>
            <para>Example: <userinput>le:Different and Line contains "ERROR"</userinput></para>

            <important>
              <para>The <literal>le:</literal> prefix must appear at the very beginning of the
input. If it appears anywhere else, the entire input is treated as a plain
string.</para>
              <para>For example, <userinput>Hello or le:Line contains "Hello"</userinput> does
<emphasis>not</emphasis> contain a filter expression.  The whole input is
treated as a literal string search for the text <literal>Hello or le:Line
contains "Hello"</literal>.</para>
            </important>
          </listitem>
        </varlistentry>
      </variablelist>
    </section>

    <section id="Filters_DisplayLineFilter_Syntax">
      <title>Filter expression syntax</title>

      <para>Display line filter expressions use the same engine as folder compare filter
expressions (see <xref linkend="FilterExpression_Syntax"/>), with the
following additional attributes and functions that operate on individual
lines.</para>

      <section id="Filters_DisplayLineFilter_Attrs">
        <title>Line attributes</title>

        <para>Attributes marked as supporting side-specific prefixes accept
<literal>Left</literal>, <literal>Middle</literal>, and
<literal>Right</literal> prefixes (e.g., <literal>LeftLine</literal>,
<literal>RightLineLength</literal>).  Attributes without a prefix evaluate
across all panes.</para>

        <variablelist>
          <varlistentry>
            <term><varname>Line</varname></term>
            <listitem><para>Text content of the current line.  Supports side-specific prefixes.
Example: <literal>Line contains "TODO"</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>LineLength</varname></term>
            <listitem><para>Length of the current line in characters.  Supports side-specific prefixes.
Example: <literal>LineLength &gt; 120</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>LineNumber</varname></term>
            <listitem><para>Real line number in the file (1-based), not counting ghost lines.  Supports
side-specific prefixes.  Example: <literal>LineNumber &lt;= 50</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>ViewLineNumber</varname></term>
            <listitem><para>Display line number including ghost lines (1-based). Global attribute (no
side prefix).  Example: <literal>ViewLineNumber &lt;= 100</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Different</varname></term>
            <listitem><para>True if the line is part of a difference block.  Global attribute.  Example:
<literal>Different</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Identical</varname></term>
            <listitem><para>True if the line is identical across all panes.  Global attribute.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Trivial</varname></term>
            <listitem><para>True if the line differs only in whitespace or other ignored content. Global
attribute.  Example: <literal>Different or Trivial</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Exists</varname></term>
            <listitem><para>True if the line exists in the pane (not a ghost line). Supports
side-specific prefixes.  Example: <literal>LeftExists and not
RightExists</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Missing</varname></term>
            <listitem><para>True if the line is a ghost line in the pane.  The opposite of
<varname>Exists</varname>.  Supports side-specific prefixes.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Moved</varname></term>
            <listitem><para>True if the line is detected as a moved line.  Supports side-specific
prefixes.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Bookmarked</varname></term>
            <listitem><para>True if the line has a bookmark.  Supports side-specific prefixes.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>DifferentLeftMiddle</varname>,
<varname>DifferentMiddleRight</varname>,
<varname>DifferentLeftRight</varname></term>
            <listitem><para>True if the indicated pair of panes differs on this line. 3-way comparisons
only (except <varname>DifferentLeftRight</varname> which also works in
2-way).  Global attributes.  Example: <literal>DifferentLeftMiddle and not
DifferentMiddleRight</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>EOL</varname></term>
            <listitem><para>End-of-line style for the current line as an integer value.  Supports
side-specific prefixes.  Values: 0 = None, 1 = LF, 2 = CR, 3 = CRLF Example:
<literal>le:EOL = 3</literal> shows only lines with CRLF endings</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>EOLStr</varname></term>
            <listitem><para>End-of-line style for the current line as a string.  Supports side-specific
prefixes.  Values: "None", "LF", "CR", "CRLF" Example: <literal>le:EOLStr =
"LF"</literal> shows only lines with LF endings</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><varname>Column</varname>, <varname>ColumnCount</varname> (table mode only)</term>
            <listitem><para>Cell content and column count in CSV/table mode.  Support side-specific
prefixes.  Example: <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>Text of the line at an absolute line number or at a relative offset from the
current line.  Supports side-specific prefix functions.  Example:
<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>)  (table mode only)</term>
            <listitem><para>Cell content by index or name, at the current, absolute, or relative line.
Example: <literal>le:RightColumn("Category") != ColumnOffsetAt(-1,
"Category")</literal></para></listitem>
          </varlistentry>
        </variablelist>
      </section>

      <section id="Filters_DisplayLineFilter_Funcs">
        <title>Line functions</title>

        <para>
Display line filter expressions can also use functions described in <xref
linkend="FilterExpression_Functions"/>.</para>

        <variablelist>
          <varlistentry>
            <term><function>matchContext</function>(<replaceable>expr</replaceable>,
<replaceable>linesBefore</replaceable>,
<replaceable>linesAfter</replaceable>)</term>
            <listitem><para>True if the current line is within <replaceable>linesBefore</replaceable>
lines before or <replaceable>linesAfter</replaceable> lines after any line
matching <replaceable>expr</replaceable>.  Example:
<literal>le:matchContext(Different, 3, 3)</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchNumber</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>1-based index of the current line within all matching lines. Returns
<literal>none</literal>if the line does not match.  Example:
<literal>le:matchNumber(Different) = 1</literal> shows only the first line
that matches (the first difference line).</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchCount</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Total number of lines matching <replaceable>expr</replaceable> across the
whole file.  Example: <literal>le:matchNumber(Different) =
matchCount(Different)</literal> shows only the last line that matches (the
last difference line).</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchBlockNumber</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Returns the 1-based block number of the matching block containing the
current line. Returns <literal>none</literal> if the current line is not in
any matching block.  Example: <literal>le:matchBlockNumber(Different) =
1</literal> shows only lines in the first difference block.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchBlockOffset</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Returns the 1-based offset of the current line within the matching
block. Returns <literal>none</literal> if the current line is not in any
matching block.  Example: <literal>le:matchBlockOffset(Different) =
1</literal> shows only the first line of each difference block.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchBlockSize</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Returns the size (number of lines) of the matching block containing the
current line. Returns <literal>none</literal> if the current line is not in
any matching block.  Example: <literal>le:matchBlockSize(Different) &gt;
5</literal> shows only lines in difference blocks larger than 5 lines.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchBlockCount</function>(<replaceable>expr</replaceable>)</term>
            <listitem><para>Total number of matching blocks in the file.  Example:
<literal>le:matchBlockNumber(Different) =
matchBlockCount(Different)</literal> shows only lines in the last difference
block.</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 in lines to the nearest matching range (both directions, before
only, or after only).  Example: <literal>le:matchDistance(Different) &lt;=
5</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>matchInside</function>(<replaceable>beginExpr</replaceable>,
<replaceable>endExpr</replaceable>)</term>
            <listitem><para>True if the current line falls between a line matching
<replaceable>beginExpr</replaceable> and the next line matching
<replaceable>endExpr</replaceable> (inclusive).  Example:
<literal>le:matchInside(Line matches "^#ifdef", Line matches
"^#endif")</literal></para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>average</function>(<replaceable>expr</replaceable>),
<function>average</function>(<replaceable>expr</replaceable>,
<replaceable>condition</replaceable>)</term>
            <listitem><para>Calculates the average (arithmetic mean) of numeric values produced by
evaluating <replaceable>expr</replaceable> for all lines in the file.  If
<replaceable>condition</replaceable> is provided, only lines where
<replaceable>condition</replaceable> evaluates to true are included in the
calculation.  Non-numeric results are ignored. Returns
<literal>none</literal>if no numeric values are found.  Example:
<literal>le:toInt(Column("Price")) &gt;
average(toInt(Column("Price")))</literal> shows rows where the price exceeds
the average price.  Example with condition:
<literal>le:average(toInt(Column("Score")), Column("Status") =
"PASS")</literal> calculates the average score for rows with status "PASS".</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>maximum</function>(<replaceable>expr</replaceable>),
<function>maximum</function>(<replaceable>expr</replaceable>,
<replaceable>condition</replaceable>)</term>
            <listitem><para>Returns the maximum value among all results produced by evaluating
<replaceable>expr</replaceable> for all lines in the file.  If
<replaceable>condition</replaceable> is provided, only lines where
<replaceable>condition</replaceable> evaluates to true are considered.
Works with numeric values, strings (alphabetical comparison), and
timestamps.  Returns <literal>none</literal>if no values are found.
Example: <literal>le:toInt(Column("Quantity")) =
maximum(toInt(Column("Quantity")))</literal> shows rows with the highest
quantity.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>minimum</function>(<replaceable>expr</replaceable>),
<function>minimum</function>(<replaceable>expr</replaceable>,
<replaceable>condition</replaceable>)</term>
            <listitem><para>Returns the minimum value among all results produced by evaluating
<replaceable>expr</replaceable> for all lines in the file.  If
<replaceable>condition</replaceable> is provided, only lines where
<replaceable>condition</replaceable> evaluates to true are considered.
Works with numeric values, strings (alphabetical comparison), and
timestamps.  Returns <literal>none</literal>if no values are found.
Example: <literal>le:Column("Status") = minimum(Column("Status"))</literal>
shows rows with the alphabetically first status value.</para></listitem>
          </varlistentry>
          <varlistentry>
            <term><function>sum</function>(<replaceable>expr</replaceable>),
<function>sum</function>(<replaceable>expr</replaceable>,
<replaceable>condition</replaceable>)</term>
            <listitem><para>Calculates the sum of all numeric values produced by evaluating
<replaceable>expr</replaceable> for all lines in the file.  If
<replaceable>condition</replaceable> is provided, only lines where
<replaceable>condition</replaceable> evaluates to true are included in the
calculation.  Non-numeric results are ignored. Returns
<literal>none</literal>if no numeric values are found.  Example:
<literal>le:toInt(Column("Quantity")) / sum(toInt(Column("Quantity"))) *
100</literal> calculates each row's percentage of the total quantity.
Example with condition: <literal>le:sum(toInt(Column("Sales")),
Column("Region") = "East")</literal> calculates total sales for the "East"
region.</para></listitem>
          </varlistentry>
        </variablelist>
      </section>

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

        <informaltable>
          <tgroup cols="2">
            <thead>
              <row>
                <entry>קלט</entry>
                <entry>Effect</entry>
              </row>
            </thead>
            <tbody>
              <row>
                <entry><userinput>TODO</userinput></entry>
                <entry>Shows lines containing the text "TODO" (plain string)</entry>
              </row>
              <row>
                <entry><userinput>le:Different</userinput></entry>
                <entry>Shows only lines in difference blocks</entry>
              </row>
              <row>
                <entry><userinput>le:Different or Trivial</userinput></entry>
                <entry>Shows all differences, including ignored differences</entry>
              </row>
              <row>
                <entry><userinput>le:matchContext(Different, 3, 3)</userinput></entry>
                <entry>Shows difference blocks with 3 lines of context on each side</entry>
              </row>
              <row>
                <entry><userinput>le:matchNumber(Different) = 1</userinput></entry>
                <entry>Shows only the first difference line</entry>
              </row>
              <row>
                <entry><userinput>le:matchBlockNumber(Different) &lt;= 3</userinput></entry>
                <entry>Shows only lines in the first 3 difference blocks</entry>
              </row>
              <row>
                <entry><userinput>le:matchBlockOffset(Different) = 1</userinput></entry>
                <entry>Shows only the first line of each difference block</entry>
              </row>
              <row>
                <entry><userinput>le:matchBlockSize(Different) &gt; 10</userinput></entry>
                <entry>Shows only lines in difference blocks larger than 10 lines</entry>
              </row>
              <row>
                <entry><userinput>le:Different and Line contains "ERROR"</userinput></entry>
                <entry>Shows lines that are both different and contain "ERROR"</entry>
              </row>
              <row>
                <entry><userinput>le:strFind(Line, "TODO") &lt; 10</userinput></entry>
                <entry>Shows lines where "TODO" appears within the first 10 characters</entry>
              </row>
              <row>
                <entry><userinput>le:regexFind(Line, "\d{4}") != none</userinput></entry>
                <entry>Shows lines containing a 4-digit number</entry>
              </row>
              <row>
                <entry><userinput>le:matchContext(Bookmarked, 2, 2)</userinput></entry>
                <entry>Shows bookmarked lines with 2 lines of context</entry>
              </row>
              <row>
                <entry><userinput>le:LineNumber &lt;= 50</userinput></entry>
                <entry>Shows only the first 50 lines</entry>
              </row>
              <row>
                <entry><userinput>le:EOL = 3</userinput></entry>
                <entry>Shows only lines with CRLF (Windows) line endings</entry>
              </row>
              <row>
                <entry><userinput>le:EOLStr = "LF"</userinput></entry>
                <entry>Shows only lines with LF (Unix) line endings</entry>
              </row>
              <row>
                <entry><userinput>le:allof(EOL = 1)</userinput></entry>
                <entry>Shows lines where all panes use LF line endings</entry>
              </row>
              <row>
                <entry><userinput>le:toInt(Column("Count")) &gt; 100</userinput></entry>
                <entry>Shows rows where the "Count" column value exceeds 100 (table mode)</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
      </section>
    </section>
  </section>

  <section id="Filters_DisplayFileFolderFilter">
    <title>Using the display file/folder filter<indexterm>
        <primary>display file/folder filter</primary>
      </indexterm></title>

    <para>The display file/folder filter in the Folder Compare window works the same
way as the display line filter in the File Compare window, but operates on
files and folders instead of lines. It controls which items are visible
without affecting the comparison result.</para>

    <para>To open the display filter bar, click <menuchoice> <guimenu>View</guimenu>
<guimenuitem>Display Filter Bar</guimenuitem> </menuchoice>, or press
<keycombo><keycap>Ctrl</keycap><keycap>Shift</keycap>
<keycap>L</keycap></keycombo>.</para>

    <para>The filter bar accepts the same syntax as the <guilabel>Filter</guilabel>
field in the Select Files or Folders dialog. See <xref
linkend="Filters_MaskSyntax"/> and <xref linkend="FilterExpression_Syntax"/>
for details.</para>

    <para>To remove the filter, clear the input field and press
<keycap>Enter</keycap>. To hide the filter bar while keeping the filter
active, click the close button.</para>

    <para>Examples:</para>
    <itemizedlist>
      <listitem><para><userinput>*.cpp;*.h</userinput> - shows C++ source and header files</para></listitem>
      <listitem><para><userinput>!.git\;!.vs\</userinput> - excludes .git and .vs folders</para></listitem>
      <listitem><para><userinput>fe:Different</userinput> - shows only different files</para></listitem>
      <listitem><para><userinput>de:Items &gt; 10</userinput> - shows folders with more than 10
items</para></listitem>
      <listitem><para><userinput>e:Date &gt; today() - 7days</userinput> - shows items modified
within the last week</para></listitem>
    </itemizedlist>
  </section>

  <section id="Filters_SubstitutionFilter">
    <title>שימוש במסנני החלפה<indexterm>
        <primary>מסננים</primary>

        <secondary>החלפה</secondary>
      </indexterm><indexterm>
        <primary>מסננים</primary>

        <secondary>בהשוואות קבצים</secondary>
      </indexterm></title>

    <para>TBD</para>
  </section>

  <section id="Filters_dlg">
    <title>שימוש בתיבת הדו-שיח מסננים<indexterm>
        <primary>תיבת דו-שיח מסננים</primary>
      </indexterm><indexterm>
        <primary>מסננים</primary>

        <secondary>ניהול והפעלה</secondary>
      </indexterm></title>

    <para>סעיף זה מתאר את תיבת הדו-שיח מסננים, המספקת פונקציות ליצירה וניהול של מסנני
קבצים ומסנני שורות.</para>

    <para>כדי לפתוח את תיבת הדו-שיח מסננים, השתמש באחת מהשיטות הבאות:</para>

    <itemizedlist>
      <listitem>
        <para>בתיבת הדו-שיח בחר קבצים או תיקיות, לחץ על <guibutton>בחר</guibutton> מימין
לשדה <guilabel>מסנן</guilabel>. אתה משתמש בשיטה זו כשאתה רוצה להחיל מסנן
קבצים על פעולת השוואת תיקיות.</para>
      </listitem>

      <listitem>
        <para>לחץ על <menuchoice> <guimenu>כלים</guimenu>
<guimenuitem>מסננים</guimenuitem> </menuchoice>. ניתן להשתמש בשיטה זו בכל
עת, למעט כאשר תיבת הדו-שיח בחר קבצים או תיקיות פתוחה.</para>
      </listitem>
    </itemizedlist>

    <para>בתיבת הדו-שיח מסננים יש כרטיסייה לכל סוג של מסנן WinMerge:</para>

    <variablelist>
      <varlistentry>
        <term>מסנני קבצים</term>

        <listitem>
          <para>בחר כרטיסייה זו כדי לעבוד עם מסנני קבצים עבור פעולות השוואת תיקיות.</para>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>מסנני שורות</term>

        <listitem>
          <para>בחר כרטיסייה זו כדי לעבוד עם מסנני שורות עבור פעולות השוואת קבצים.</para>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>מסנני החלפה</term>

        <listitem>
          <para>בחר כרטיסייה זו כדי לעבוד עם מסנני החלפה עבור פעולות השוואת קבצים.</para>
        </listitem>
      </varlistentry>

      <varlistentry>
        <term>Display Line Filter</term>

        <listitem>
          <para>The display line filter is not configured through this dialog.  Open it via
<menuchoice><guimenu>View</guimenu> <guimenuitem>Display Filter
Bar</guimenuitem></menuchoice>.  See <xref
linkend="Filters_DisplayLineFilter"/>.</para>
        </listitem>
      </varlistentry>
    </variablelist>

    <section id="Filters_FileFiltersTab">
      <title>שימוש בכרטיסייה מסנני קבצים<indexterm>
          <primary>מסנני קבצים</primary>

          <secondary>הפעלה</secondary>
        </indexterm></title>

      <para>החלק העיקרי של כרטיסייה זו הוא רשימה של מסנני קבצים הזמינים עבור פעולות
השוואת תיקיות. הרשימה כוללת מסנני קבצים משותפים, פרטיים ומוגדרים ש-WinMerge
מכיר, כמתואר ב-<xref linkend="Filters_FileFilterLoc" />.</para>

      <section id="Filters_FileFilterEnabling">
        <title>הפעלה והשבתה של מסנני קבצים</title>

        <para>עליך להפעיל מסנן קבצים כדי להפוך אותו לזמין בפעולת השוואת תיקיות, או להשבית
מסנן נוכחי כדי למנוע את השימוש בו:</para>

        <orderedlist>
          <listitem>
            <para>פתח את תיבת הדו-שיח מסננים, אם היא עדיין לא פתוחה.</para>
          </listitem>

          <listitem>
            <para>בחר מסנן קבצים או <guimenuitem>&lt;ללא&gt;</guimenuitem> מהרשימה.</para>
          </listitem>

          <listitem>
            <para>לחץ על <guibutton>אישור</guibutton> כדי לסגור את תיבת הדו-שיח מסננים.</para>
          </listitem>
        </orderedlist>

        <para>ישנן מספר דרכים להחיל מסנני קבצים לאחר הפעלתם. לפרטים, ראה <xref
linkend="Filters_FileFilterApply" />.</para>
      </section>

      <section id="Filters_FileFilterCfg">
        <title>הגדרת מסנני קבצים</title>

        <para>השתמש בלחצנים אלה כדי לנהל את רשימת <guilabel>מסנני קבצים</guilabel> שלך
וליצור מסנני קבצים חדשים:</para>

        <variablelist>
          <varlistentry>
            <term>בדוק</term>

            <listitem>
              <para>בחר מסנן קבצים ברשימה ולחץ על <guibutton>בדוק</guibutton> כדי לראות במהירות
כיצד המסנן עובד. ראה <xref linkend="Filters_TestingDlg" /> לפרטים.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>התקן</term>

            <listitem>
              <para>מאפשר לך לאתר מסנן קבצים ומוסיף אותו לרשימת המסננים. מסנני קבצים שאינם
בתיקייה המשותפת או הפרטית המוגדרת כברירת מחדל אינם מזוהים אלא אם אתה מתקין
אותם.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>חדש</term>

            <listitem>
              <para>יוצר עותק חדש של תבנית קבצים בתיקיות המסננים המשותפות או הפרטיות, ופותח אותו
בעורך ברירת המחדל שלך. ערוך את התבנית והוסף את הכללים שלך, כמתואר ב-<xref
linkend="Filters_CreatingFile" />.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>ערוך</term>

            <listitem>
              <para>בחר מסנן קבצים ברשימה ולחץ על <guibutton>ערוך</guibutton> כדי לפתוח את הקובץ
בעורך ברירת המחדל שלך.</para>
            </listitem>
          </varlistentry>

          <varlistentry>
            <term>מחק</term>

            <listitem>
              <para>בחר מסנן קבצים ברשימה ולחץ על <guibutton>מחק</guibutton> כדי למחוק את הקובץ
ולהסיר אותו מהרשימה. כן, הקובץ באמת נמחק!</para>
            </listitem>
          </varlistentry>
        </variablelist>

        <para>השינויים שלך נשמרים כשאתה לוחץ על <guibutton>אישור</guibutton> כדי לסגור את
תיבת הדו-שיח מסננים. מסנני שורות מאוחסנים ברישום של Windows.</para>
      </section>

      <section id="Filters_CreatingFile">
        <title>יצירת מסנן קבצים</title>

        <para>אם מסנני הקבצים המותקנים עם WinMerge אינם מספקים את הסינון הדרוש לך, אתה
יכול ליצור מסננים משלך:</para>

        <orderedlist>
          <listitem>
            <para>לחץ על <menuchoice> <guimenu>כלים</guimenu>
<guimenuitem>מסננים</guimenuitem> </menuchoice>. או, מתיבת הדו-שיח בחר קבצים
או תיקיות, לחץ על <guibutton>בחר</guibutton> מימין לשדה
<guilabel>מסנן</guilabel>.</para>
          </listitem>

          <listitem id="Filters_New_step">
            <para>בכרטיסייה מסנני קבצים של תיבת הדו-שיח מסננים, לחץ על
<guibutton>חדש</guibutton>.</para>
          </listitem>

          <listitem>
            <para>בתיבת הדו-שיח מסנן משותף או פרטי, בחר <guilabel>מסנן משותף</guilabel> או
<guilabel>מסנן פרטי</guilabel> (ראה <xref linkend="Filters_FileFilterLoc" />
לשימושים בהם) ולחץ על <keycap>אישור</keycap>.</para>

            <para>תיבת הדו-שיח בחר שם קובץ למסנן חדש נפתחת בתיקיית הקבצים המשותפת או הפרטית
במערכת שלך (אם התיקייה הפרטית אינה קיימת, WinMerge יוצר אותה).</para>
          </listitem>

          <listitem>
            <para>בתיבת הדו-שיח בחר שם קובץ למסנן חדש, הזן שם קובץ חדש ולחץ על
<guibutton>שמור</guibutton>.</para>

            <note>
              <para>אל תבחר שם קובץ קיים: כדי לערוך קובץ קיים, חזור לשלב <xref
linkend="Filters_New_step" /> ולחץ על ערוך במקום על חדש.</para>
            </note>

            <para>WinMerge מאתחל את הקובץ החדש עם התוכן של התבנית
<filename>FileFilter.tmpl</filename>, ופותח אותו בעורך הטקסט המוגדר כברירת
מחדל שלך.</para>
          </listitem>

          <listitem>
            <para>פעל בהתאם להוראות התבנית כדי לערוך את התבנית, לעדכן את שם מציין המיקום
והתיאור ולהוסיף כללי מסנן כמתואר ב-<xref linkend="Filters_FileFilterSyntax"
/>. שמור את הקובץ בעורך הטקסט שלך.</para>

            <tip>
              <para>אם אתה רוצה לבדוק במהירות כלל שאתה מגדיר, נסה ללחוץ על בדוק בתיבת הדו-שיח
מסננים. ראה <xref linkend="Filters_TestingDlg" /> לפרטים.</para>
            </tip>
            <para></para>
          </listitem>

          <listitem>
            <para>אם יצרת את מסנן הקבצים שלך באחת מתיקיות <filename>מסננים</filename>
הסטנדרטיות, ותיבת הדו-שיח מסננים אינה מציגה את מסנן הקבצים החדש שלך, נסה
ללחוץ על <guibutton>אישור</guibutton> כדי לסגור אותה, ואז לחץ על
<menuchoice> <guimenu>כלים</guimenu> <guimenuitem>מסננים</guimenuitem>
</menuchoice> שוב כדי לפתוח אותה מחדש. רשימת <guilabel>מסנני
קבצים</guilabel> צריכה לכלול כעת את מסנן הקבצים החדש.</para>

            <para>אם שמרת את הקובץ במיקום חלופי במערכת הקבצים שלך), WinMerge לא יכול לזהות
אותו אלא אם אתה מתקין אותו. כדי להפוך מסנן קבצים לניתן לזיהוי בכל מקום
במערכת שלך:</para>

            <orderedlist numeration="loweralpha">
              <listitem>
                <para>לחץ על <guibutton>התקן</guibutton> בתיבת הדו-שיח מסננים.</para>
              </listitem>

              <listitem>
                <para>בתיבת הדו-שיח אתר קובץ מסנן להתקנה, נווט לקובץ <filename>flt</filename>
במערכת שלך ולחץ על <guibutton>פתח</guibutton>. רשימת מסנני הקבצים צריכה
לכלול כעת את מסנן הקבצים המותקן.</para>
              </listitem>
            </orderedlist>
          </listitem>
        </orderedlist>
      </section>

      <section id="Filters_TestingDlg">
        <title>בדיקת כללי מסנן קבצים<indexterm>
            <primary>מסנני קבצים</primary>

            <secondary>בדיקה</secondary>
          </indexterm><indexterm>
            <primary>בדיקת מסנני קבצים</primary>
          </indexterm></title>

        <para>השתמש בתיבת הדו-שיח בדוק מסנן כדי לבדוק במהירות מסנן קבצים כנגד נתוני דוגמה,
כדי לעזור לך לפתח כללים חדשים או כדי להבין כיצד כללים קיימים עובדים. זה יכול
להיות קל יותר מאשר הפעלת פעולת השוואה מלאה.</para>

        <para>החל מתיבת הדו-שיח מסננים:</para>

        <orderedlist>
          <listitem>
            <para>בכרטיסייה מסנני קבצים, בחר את מסנן הקבצים שברצונך לבדוק.</para>
          </listitem>

          <listitem>
            <para>אם אתה רוצה לראות את הכללים שאתה הולך לבדוק, לחץ על
<guibutton>ערוך</guibutton> עכשיו כדי לפתוח את הקובץ כדי שתוכל לצפות בו
במהלך השלבים הבאים.</para>
          </listitem>

          <listitem>
            <para>לחץ על <guibutton>בדוק</guibutton>.</para>
          </listitem>

          <listitem>
            <para>בתיבת הדו-שיח בדוק מסנן, בחר את סוג הכלל לבדיקה:</para>

            <itemizedlist>
              <listitem>
                <para>כדי לבדוק כלל קובץ <guilabel>f:</guilabel> במסנן הקבצים שלך, בטל את הסימון
של האפשרות <guilabel>שם תיקייה</guilabel>.</para>
              </listitem>

              <listitem>
                <para>כדי לבדוק כלל תיקייה <guilabel>d:</guilabel>, סמן את האפשרות <guilabel>שם
תיקייה</guilabel>.</para>
              </listitem>
            </itemizedlist>
          </listitem>

          <listitem>
            <para>הזן את הטקסט לבדיקה.</para>

            <para>הטקסט צריך להיות מתאים לסוג הכלל שאתה בודק. לדוגמה, אם סימנת את האפשרות
<guilabel>שם תיקייה</guilabel>, סביר להניח שתרצה להזין שם תיקייה, כגון
\temp.</para>

            <para>התיבה <guilabel>תוצאה</guilabel> מציגה את הערך שהזנת, ואחריו את הסטטוס שלו:
<computeroutput>עבר</computeroutput> או
<computeroutput>נכשל</computeroutput>.</para>
          </listitem>
        </orderedlist>
      </section>
    </section>

    <section id="Filters_LineFiltersTab">
      <title>שימוש בכרטיסייה מסנני שורות<indexterm>
          <primary>מסנני שורות</primary>

          <secondary>הפעלה</secondary>
        </indexterm></title>

      <para>השתמש בכרטיסייה זו כדי להגדיר ולהפעיל מסנני שורות עבור פעולות השוואת
קבצים. הכרטיסייה כוללת רשימה של כללים. כל כלל מכיל ביטוי רגולרי יחיד. אתה
יכול להחיל כל שילוב של כללים מהרשימה על השוואת קבצים.</para>

      <section id="Filters_LineFilterCfg">
        <title>הגדרת מסנני שורות</title>

        <para>מתחת לרשימת <guilabel>ביטויים רגולריים</guilabel> יש תיבת עריכה ולחצנים שבהם
תוכל להשתמש כדי לתחזק את הרשימה בכל עת על ידי הוספה, עריכה והסרה של כללים.</para>

        <para>כדי להוסיף כלל חדש:</para>

        <orderedlist>
          <listitem>
            <para>לחץ על <guibutton>חדש</guibutton>. סמן העריכה שלך מופעל אוטומטית בתיבת
העריכה.</para>
          </listitem>

          <listitem>
            <para>הזן ביטוי בתיבת העריכה שמתחת לרשימת <guilabel>ביטויים רגולריים</guilabel>.</para>
          </listitem>

          <listitem>
            <para>לחץ על <guibutton>שמור</guibutton> כדי לטעון את הביטוי בשורה חדשה ברשימה.</para>
          </listitem>
        </orderedlist>

        <para>כדי לערוך כלל קיים:</para>

        <orderedlist>
          <listitem>
            <para>בחר את השורה ולחץ על <guibutton>ערוך</guibutton>.</para>
          </listitem>

          <listitem>
            <para>ערוך את הביטוי בתיבת העריכה.</para>
          </listitem>

          <listitem>
            <para>לחץ על <guibutton>שמור</guibutton><guibutton> </guibutton>כשסיימת.</para>
          </listitem>
        </orderedlist>

        <para>כדי למחוק כלל קיים, בחר (סמן) את הכלל ולחץ על <guibutton>הסר</guibutton>.</para>
      </section>

      <section id="Filters_LineFilterEnabling">
        <title>הפעלה והשבתה של מסנני שורות<indexterm>
            <primary>מסנני שורות</primary>

            <secondary>רשימת זמינים</secondary>
          </indexterm></title>

        <orderedlist>
          <listitem>
            <para>ברשימת <guilabel>ביטויים רגולריים</guilabel>, סמן רק את המסננים שברצונך
להחיל ובטל את הסימון של כל המסננים שאינך רוצה להחיל.</para>
          </listitem>

          <listitem>
            <para>סמן או בטל את הסימון של האפשרות <guilabel>אפשר מסנני שורות</guilabel>. אם
תפעיל סינון, כל הכללים המסומנים כעת ברשימת <guilabel>ביטוי רגולרי</guilabel>
ישמשו. אם הסינון כבוי, לא ישמשו כללים גם אם הם מסומנים.</para>
          </listitem>

          <listitem>
            <para>לחץ על <guibutton>אישור</guibutton> כדי לסגור את תיבת הדו-שיח מסננים ולשמור
את ההגדרות שלך.</para>
          </listitem>
        </orderedlist>

        <para>ישנן מספר דרכים להחיל מסנני קבצים לאחר הפעלתם. לפרטים, ראה <xref
linkend="Filters_LineFilterApply" />.</para>
      </section>
    </section>

    <section id="Filters_SubstitutionFiltersTab">
      <title>שימוש בכרטיסייה מסנני החלפה<indexterm>
          <primary>מסנני החלפה</primary>

          <secondary>הפעלה</secondary>
        </indexterm></title>

        <para>TBD</para>

      <section id="Filters_SubstitutionFilterCfg">
        <title>הגדרת מסנני החלפה</title>

        <para>TBD</para>

      </section>

      <section id="Filters_SubstitutionFilterEnabling">
        <title>הפעלה והשבתה של מסנני החלפה<indexterm>
            <primary>מסנני החלפה</primary>

            <secondary>רשימת זמינים</secondary>
          </indexterm></title>

        <para>TBD</para>
      </section>
    </section>
  </section>

  <section id="AboutFilters_regexp">
    <title>קבלת עזרה בביטויים רגולריים<indexterm>
        <primary>ביטויים רגולריים</primary>

        <secondary>קבלת עזרה</secondary>
      </indexterm></title>

    <para>ביטויים רגולריים יכולים להיות מורכבים מאוד. למרבה המזל, רוב מסנני הקבצים
ב-WinMerge כוללים ביטויי סיומת פשוטים, כפי שמוצג בדוגמאות בנושא זה. קבצי
המסנן המותקנים עם WinMerge כוללים דוגמאות שימושיות רבות אחרות.</para>

    <para>לבסוף, ישנם משאבים רבים באינטרנט לעזרה ב-regexps, כולל אתרים אלה:</para>

    <variablelist>
      <varlistentry>
        <term>אתר טוב המוקדש ל-regexps:</term>

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

      <varlistentry>
        <term>הדרכה:</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>עיון מהיר ב-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>
