<?xml version="1.0" ?>
<!DOCTYPE book PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd" [
 <!ENTITY % Polish "INCLUDE">
 <!ENTITY % addindex "IGNORE">
]>

<book lang="&language;">

  <bookinfo>
    <title
>Podręcznik edytora wyrażeń regularnych</title>

    <authorgroup>
      <author
><firstname
>Jesper K.</firstname
> <surname
>Pedersen</surname
> <affiliation
><address
><email
>blackie@kde.org</email
></address
></affiliation>
      </author>
    </authorgroup>

    <date
>2001-07-03</date>
    <releaseinfo
>0.1</releaseinfo>

    <legalnotice
>&underFDL;</legalnotice>

    <copyright>
      <year
>2001</year>
      <holder
>Jesper K. Pedersen</holder>
    </copyright>

    <abstract>
      <para
>Niniejszy podręcznik opisuje moduł edytora wyrażeń regularnych środowiska &kde; </para>
    </abstract>

    <keywordset>
      <keyword
>KDE</keyword>
      <keyword
>wyrażenie regularne</keyword>
    </keywordset>
  </bookinfo>

  <!-- ====================================================================== -->
  <!--                               Introduction                             -->
  <!-- ====================================================================== -->
  <chapter id="introduction">
    <title
>Wprowadzenie</title>


    <para
>Edytor wyrażeń regularnych pozwala na graficzne konstruowanie elementów wyrażenia (bez konieczności stosowania składni w kodzie <acronym
>ASCII</acronym
>). Tradycyjna znakowa postać wyrażenia regularnego wygląda na przykład tak: <literal
>^.*kde\b</literal
>. Główne wady takiego zapisu są następujące: <itemizedlist>
        <listitem
><para
>Jest mało zrozumiały dla przeciętnego użytkownika.</para
></listitem>

        <listitem
><para
>Wymaga stosowania <emphasis
>sekwencji specjalnych</emphasis
> dla pewnych symboli (np. aby wyszukać gwiazdkę '*' należy napisać <literal
>\*</literal
>). </para
></listitem>

        <listitem
><para
>Wymagają pamiętania o odpowiedniej <emphasis
>kolejności</emphasis
> zapisów. (Do czego pasuje wyrażenie <literal
>x|y*</literal
>? Do pojedynczego znaku <literal
>x</literal
> i kilku znaków <literal
>y</literal
>, <emphasis
>LUB</emphasis
> dowolnej kombinacji kilku znaków <literal
>x</literal
> i <literal
>y</literal
>?)</para
></listitem>
      </itemizedlist>
    </para>

    <para
>Edytor wyrażeń regularnych pozwala niemalże na <emphasis
>narysowanie</emphasis
> własnego wyrażenia regularnego w przejrzysty i jednoznaczny sposób. Dzięki niemu rozwiązane są co najmniej 2 z trzech omówionych wcześniej problemów. Nie spowoduje on jednak cudu przyswojenia problematyki wyrażeń regularnych przez osoby nie zajmujące się programowaniem, to jednak mogą potwierdzić jedynie użytkownicy. Prosimy każdego użytkownika nie zajmującego się na co dzień programowaniem, który przyswoił sobie problematykę wyrażeń regularnych dzięki temu edytorowi o kontakt z <ulink url="mailto:blackie@kde.org"
>autorami</ulink
>. </para>

  </chapter>

  <!-- ====================================================================== -->
  <!--                       What is a Regular Expression                     -->
  <!-- ====================================================================== -->
  <chapter id="whatIsARegExp">
    <title
>Co to jest wyrażenie regularne</title>

    <para
>Wyrażenie regularne pozwala na określenie powstałych w umyśle użytkownika <emphasis
>warunków</emphasis
>, które należy spełnić. W typowych sytuacjach poszukując jakiegoś napisu wystarczy go wpisać w polu wyszukiwania w sposób <emphasis
>dosłowny</emphasis
>, z drugiej strony za pomocą wyrażenia regularnego można zapisać jak ma wyglądać dopasowany fragment. Przykładowo: <emphasis
>poszukujemy słowa KDE ale tylko na początku wiersza</emphasis
>, <emphasis
>szukamy słowa <literal
>the</literal
>, ale nie będącego częścią innego wyrazu</emphasis
> lub <emphasis
>szukamy plików o nazwie rozpoczynającej się od słowa <literal
>test</literal
>, po którym następuje pewna liczba cyfr np. <literal
>test12</literal
>, <literal
>test107</literal
> i <literal
>test007</literal
></emphasis
>.</para>

    <para
>Wyrażenia regularne buduje się z mniejszych wyrażeń regularnych, ta samo jak z małych klocków Lego tworzy się duże budynki. Tak jak w Lego, dostępnych jest kilka podstawowych elementów. W dalszej części zostaną one opisane wraz z przykładami ich wykorzystania.</para>

    <example>
      <title
>Wyszukiwanie zwykłego tekstu.</title>
      <para
>Jeżeli potrzebne jest jedynie wyszukanie podanego tekstu, to wyrażenia regularne nie są zbyt dobrym wyborem, dlatego że w wyrażeniach regularnych część znaków ma specjalne znaczenie. Dotyczy to m.in. następujących znaków: <literal
>.*|$</literal
>. Jeżeli więc użytkownik chce znaleźć napis <literal
>kde.</literal
> (tzn. <literal
>kde</literal
> z kropką na końcu) to musi zapisać to jako wyrażenie <literal
>kde\.</literal
><footnote
><para
>Edytor wyrażeń regularnych pozwala na łatwe ominięcie tego problemu zastępując użytkownika w we wprowadzaniu specjalnych sekwencji dla takich znaków.</para
></footnote
> Zapisanie kropki w postaci wyrażenia <literal
>\.</literal
> to tak zwana <emphasis
>sekwencja specjalna</emphasis
>. </para>
    </example>

    <example id="positionregexp">
      <title
>Dopasowanie adresów URL</title>
      <para
>Jeżeli w dowolnym edytorze środowiska KDE zostanie zaznaczony fragment tekstu wyglądający jak adres URL, program <command
>klipper</command
> zaoferuje uruchomienie polecenia <command
>konqueror</command
> i otworzenie tego adresu.</para>

      <para
>Program <command
>klipper</command
> rozpoznaje adres poprzez porównanie zaznaczenia z kilkoma różnymi wyrażeniami regularnymi. Jeżeli dane wyrażenie pasuje do zaznaczonego tekstu, to udostępnione zostaje odpowiednie polecenie z nim związane.</para>
      
      <para
>Wyrażenie regularne wyszukujące adresy URL zawiera m.in. wymaganie aby napis zaczynał się od tekstu <literal
>http://</literal
>. Osiągane jest to poprzez wprowadzenie znaku daszka (<literal
>^</literal
>) jako poprzedzającego tekst <literal
>http://</literal
>.</para>

      <para
>Powyższy przykład przedstawia dopasowanie pozycji w tekście z wykorzystaniem wyrażeń regularnych. Analogicznie, pozycja <emphasis
>końca wiersza</emphasis
> może być dopasowana za pomocą znaku dolara <literal
>$</literal
>.</para>
    </example>

    <example id="boundaryregexp">
      <title
>Wyszukiwanie słowa <literal
>the</literal
>, ale nie będącego częścią wyrazu jak w np. <emphasis
>the</emphasis
><literal
>re</literal
>, <literal
>brea</literal
><emphasis
>the</emphasis
> lub <literal
>ano</literal
><emphasis
>the</emphasis
><literal
>r</literal
></title>
      <para
>Dodatkowo można dopasowywać pewne specjalne pozycje w tekście, są to odpowiednio:<emphasis
>pozycja na granicy wyrazu</emphasis
> oraz<emphasis
>pozycja, która <emphasis
>nie jest</emphasis
> granicą wyrazu </emphasis
>. Są one w wyrażeniu zapisywane w postaci: <literal
>\b</literal
> (dla granicy wyrazu) oraz <literal
>\B</literal
> (dla pozycji, która nie jest granicą wyrazu).</para>

      <para
>Oznacza to, iż wyszukiwanie wyrazu <literal
>the</literal
> może być wykonane za pomocą wyrażenia <literal
>\bthe\b</literal
>. Oznacza ono iż szukamy napisu <literal
>the</literal
>, który ani na początku, ani na końcu nie ma żadnych dodatkowych znaków (czyli ma granicę wyrazu po obu stronach)</para>

      <para
>Cztery omawiane wyrażenia dopasowania pozycji w wyrażeniach regularnych są wstawiane w edytorze wyrażeń za pomocą <link linkend="positiontool"
>narzędzia pozycji</link
>.</para>
    </example>

    <example id="altnregexp">
      <title
>Szukanie słów <literal
>this</literal
> albo <literal
>that</literal
></title>
      <para
>Przypuśćmy iż chcemy w dokumencie wyszukać słowa <literal
>this</literal
> oraz <literal
>that</literal
>. Normalna metoda wyszukiwania polegałaby na dwukrotnej operacji wyszukiwania, najpierw dla wyrazu <literal
>this</literal
>, a następnie dla wyrazu <literal
>that</literal
>.</para>

      <para
>Dzięki wyrażeniom regularnym wyszukiwanie obu wyrazów może być wykonane za pomocą jednej operacji wyszukiwania. Postać takiego wyrażenia to: <literal
>this|that</literal
> czyli oba szukane wyrazy rozdzielone pionową kreską.<footnote
><para
>Należy podkreślić iż po obu stronach pionowej kreski może znaleźć się wyrażenie regularne czyli można go stosować nie tylko dla poszukiwania różnych alternatywnych napisów, ale także dla różnych alternatywnych wyrażeń regularnych.</para
></footnote
></para>

      <para
>W edytorze wyrażeń regularnych zamiast wpisania pionowej kreski z klawiatury, należy skorzystać z <link linkend="altntool"
>narzędzia alternatywy</link
> i wprowadzić alternatywne wyrażenia jedno nad drugim.</para>
    </example>

    <example id="repeatregexp">
      <title
>Dopasowanie dowolnego wyrażenia</title>
      <para
>Wyrażenia regularne często są porównywane do wzorców dopasowania nazw plików w powłoce systemowej - pozwalających określić pewien zbiór nazw plików za pomocą gwiazdki. Poniżej przedstawiono kilka przykładów wykorzystania wzorców dopasowania: <itemizedlist>
          <listitem
><para
><literal
>ls *.txt</literal
> - w tym przykładzie <literal
>*.txt</literal
> gwiazdka jest poleceniem dla powłoki dopasowującym każdy plik z rozszerzeniem <literal
>.txt</literal
>.</para
></listitem>
          <listitem
><para
><literal
>cat test??.res</literal
> - pasuje do każdego pliku, którego nazwa rozpoczyna się od <literal
>test</literal
> i zawiera dodatkowo dwa dowolne znaki, oraz rozszerzenie <literal
>.res</literal
></para
></listitem>
        </itemizedlist>
      </para>

      <para
>Przy zapisywaniu wzorców powłoki dla plików, gwiazdka oznacza dowolny znak zapisany dowolną liczbę razy. Innymi słowy, gwiazdka oznacza <emphasis
>cokolwiek</emphasis
>. W składni wyrażeń regularnych ma ona postać <literal
>.*</literal
>. Kropka pasuje do dowolnego pojedynczego znaku tzn. <emphasis
>tylko jednego</emphasis
> znaku, zaś gwiazdka oznacza iż poprzedzające ją wyrażenie regularne powinno być dopasowane dowolną liczbę razy (albo 0 razy). Razem zapisane oznacza to dopasowanie dowolnego pojedynczego znaku dowolną liczbę razy.</para>

      <para
>Mimo iż wydaje się to zbytnio skomplikowane, to jednak daje to ogromne możliwości. Wyobraźmy sobie takie proste wyrażenie regularne: <literal
>a</literal
>. Litera <literal
>a</literal
> sama w sobie jest wyrażeniem regularnym pasującym do pojedynczej litery. Jeżeli dodamy do niej gwiazdkę zapisując <literal
>a*</literal
>, to otrzymujemy wyrażenie pasujące do dowolnej liczby liter <literal
>a</literal
> (lub do pustego ciągu znaków).</para>

      <para
>Wyrażenia regularne można ze sobą łączyć zapisując je po kolei, np. <literal
>ba(na)*</literal
>. <footnote
><para
>Zapis <literal
>(na)*</literal
> oznacza, że wyrażenie w nawiasach może się powtarzać dowolną liczbę razy lub 0 razy .</para
></footnote
> Wyobrazić sobie można co się stanie po wpisaniu tego wyrażenia w polu wyszukiwania edytora tekstu. Spowoduje ono wyszukanie następujących słów: <literal
>ba</literal
>, <literal
>bana</literal
>, <literal
>banana</literal
>, <literal
>bananananananana</literal
> (i innych podobnych). </para>

      <para
>Po przyswojeniu powyższych informacji, użytkownik nie powinien mieć kłopotu z zapisaniem wzorca nazwy pliku dla powłoki <literal
>test??.res</literal
> jako wyrażenia regularnego. Będzie ono mieć postać <literal
>test..\.res</literal
>. Ponieważ kropka w wyrażeniu regularnym oznacza dowolny znak, aby znaleźć kropkę w tekście należy zapisać ją jako <literal
>\.</literal
><footnote
><para
>Jest to tak zwana sekwencja specjalna</para
></footnote
>. Innymi słowy wyrażenie regularne <literal
>\.</literal
> pasuje do kropki w tekście, zaś sama kropka pasuje do dowolnego znaku. </para>

      <para
>W edytorze wyrażeń regularnych, powtarzające się wyrażenia regularne są tworzone za pomocą <link linkend="repeattool"
>narzędzia powtarzania</link
>. </para>
    </example>

    <example id="lookaheadregexp">
      <title
>Zamiana wszystkich znaków <literal
>&amp;</literal
> na <literal
>&amp;amp;</literal
> w dokumencie formatu HTML.</title
> <para
>W składni HTML znak specjalny <literal
>&amp;</literal
> musi być zapisany jako <literal
>&amp;amp;</literal
> - jest to podobne wymaganie jak w sekwencjach specjalnych w wyrażeniach regularnych.</para>

      <para
>Wyobraźmy sobie, iż użytkownik stworzył dokument HTML w zwykłym edytorze (np. XEmacs lub Kate), zapominając o tej zasadzie. Jak by się poczuł gdyby się okazało iż musi zamienić każde wystąpienie <literal
>&amp;</literal
> na <literal
>&amp;amp;</literal
>?</para>

      <para
>Można tego dokonać w prosty sposób za pomocą zwykłego mechanizmu wyszukiwania i zastępowania tekstu. Jednak ma on pewne wady. Wyobraźmy sobie, że użytkownik <emphasis
>czasami</emphasis
> pisał kod HTML zgodnie z zasadami, a czasami nie. Bezwarunkowe zastąpienie tekstów spowodowałoby iż napis <literal
>&amp;amp;</literal
> zostałby zastąpiony napisem <literal
>&amp;amp;amp;</literal
>.</para>

      <para
>Właściwym postępowaniem jest zamienianie napisu <literal
>&amp;</literal
> ale tylko wtedy gdy nie następuje po nim napis: <literal
>amp;</literal
>. Można tego dokonać z wykorzystaniem mechanizmu <emphasis
>pozytywnych odnośników w przód</emphasis
> w wyrażeniach regularnych . </para>

      <para
>Wyrażenie regularne pasujace do znaku &amp;, ale tylko takiego po którym nie występuje napis <literal
>amp;</literal
> wygląda następująco: <literal
>&amp;(?!amp;)</literal
>. Oczywiście jest to bardziej zrozumiałe w graficznym zapisie edytora wyrażeń, gdzie wystarczy skorzystać <link linkend="lookaheadtools"
>narzędzia odnośników do przodu</link
>.</para>
    </example>

  </chapter>

  <!-- ====================================================================== -->
  <!--                    Using the Regular Expression Editor                 -->
  <!-- ====================================================================== -->
  <chapter id="theEditor">
    <title
>Korzystanie z edytora wyrażeń regularnych</title>

    <para
>W tym rozdziale opisane zostaną podstawowe zasady działania programu. </para>

    <!-- ====================================================================== -->
    <!--                   The organization of the screen                       -->
    <!-- ====================================================================== -->
    <sect1 id="screenorganization">
      <title
>Zawartość ekranu</title>

      <mediaobject>
        <imageobject
><imagedata format="PNG" fileref="theEditor.png"/></imageobject>
      </mediaobject>
      
      <para
>Najważniejszą częścią okna edytora jest obszar, w którym użytkownik rysuje swoje wyrażenie regularne. Obszar ten to duża pusta część okna zaznaczona szarym kolorem.</para>

      <para
>Ponad obszarem edycyjnym widoczne są dwa paski narzędzi, pierwszy zawierający <link linkend="editingtools"
>operacje edycyjne</link
> - stanowiące coś w rodzaju narzędzi rysownika w programie graficznym. Drugi pasek narzędzi zawiera przyciski <emphasis
>Co to jest?</emphasis
> oraz przyciski cofania i ponawiania.</para>

      <para
>Poniżej obszaru edycyjnego widoczne jest budowane wyrażenie regularne w tradycyjnej składni znakowej. Jest ono na bieżąco aktualizowane podczas edycji wyrażenia w edytorze graficznym. Można zmieniać wyrażenie regularne w składni znakowej, edytor graficzny na bieżąco przedstawi dokonane tam zmiany.</para>

      <para
>Ostatnią częścią jest widoczne po lewej stronie obszaru edycyjnego pole listy, zawierające zdefiniowane wyrażenia regularne. Służą one dwóm celom: (1) Przy wczytaniu wyrażenia do edytora wyświetlane jest ono w <emphasis
>ładniejszy</emphasis
> lub bardziej czytelny sposób, poprzez zamianę najczęściej występujących wyrażeń regularnych ich opisowymi odpowiednikami. W widocznym powyżej zrzucie ekranu, widać jak zapisane znakowo wyrażenie ".*" zostało zamienione na prostokąt z napisem "anything" (cokolwiek). (2) Przy tworzeniu własnego wyrażenia regularnego, można skorzystać z listy predefiniowanych elementów budulcowych. Więcej na temat tworzenia i zapisywania własnych wyrażeń regularnych na tej liście znajduje się w części: <link linkend="userdefinedregexps"
>wyrażenia regularne użytkownika</link
>.</para
>      
    </sect1>

    <!-- ====================================================================== -->
    <!--                         Editing Tools                                  -->
    <!-- ====================================================================== -->
    <sect1 id="editingtools">
      <title
>Narzędzia edycyjne</title>
      <para
>Niniejszy rozdział zakłada iż czytelnik zaznajomił się z tekstem <link linkend="whatIsARegExp"
>czym są wyrażenia regularne</link
> lub posiada już wiedzę na ten temat.</para>
      
      <para
>Wszystkie narzędzia umieszczone są na pasku znajdującym się nad obszarem roboczym. Poniżej zostały opisane poszczególne narzędzia.</para>
      
      

      <simplesect id="selecttool">
        <title
>Narzędzie zaznaczania</title>
	<mediaobject>
            <imageobject
><imagedata format="PNG" fileref="select.png"/>
        </imageobject
></mediaobject>
        <para
>Narzędzie zaznaczania zachowuje się podobnie jak w dowolnym innych programie graficznym i służy zaznaczaniu elementów dla operacji kopiuj-wklej oraz przenieś i upuść.</para>
      </simplesect>
        
      

      <simplesect id="texttool"
><title
>Narzędzie tekstu</title>
      <mediaobject>
      <imageobject>
	    <imagedata format="PNG" fileref="text.png"/>
	</imageobject
></mediaobject>
		        
        <para
><inlinemediaobject
><imageobject>
              <imagedata format="PNG" fileref="texttool.png"/>
        </imageobject
></inlinemediaobject
></para>

        <para
>Za pomocą tego narzędzia wprowadza się do wyrażenia poszukiwany fragment tekstu. Jest poszukiwany dosłownie ten fragment, użytkownik nie musi się martwić o zapisywanie znaków w postaci sekwencji specjalnych. W omawianym wcześniej przykładzie, utworzone zostanie następujące wyrażenie regularne: <literal
>abc\*\\\)</literal
></para>
      </simplesect>

      

      <simplesect id="characterstool"
><title
>Narzędzie znaków</title>
      <mediaobject
><imageobject>
            <imagedata format="PNG" fileref="characters.png"/>
            </imageobject
></mediaobject>
        <para
><inlinemediaobject
><imageobject>
            <imagedata format="PNG" fileref="charactertool.png"/>
            </imageobject
></inlinemediaobject
></para>
        
        <para
>Za pomocą tego narzędzia wprowadza się do wyrażenia regularnego polecenia wyszukiwania zakresów znaków alfabetycznych. Przykładowe wyrażenia to: <literal
>[0-9]</literal
>, <literal
>[^a-zA-Z,_]</literal
>. Użycie tego narzędzia spowoduje wyświetlenia okna dialogowego, w którym można określić poszukiwane zakresy znaków.</para>
        
        <para
>Więcej na ten temat w części dotyczącej <link linkend="repeatregexp"
>powtórzeń w wyrażeniach regularnych</link
>.</para>
      </simplesect>

      
      
      <simplesect id="anychartool"
><title
>Narzędzie dowolnego znaku</title>
        <mediaobject
><imageobject>
              <imagedata format="PNG" fileref="anychar.png"/>
        </imageobject
></mediaobject>
        <para
><inlinemediaobject
><imageobject
><imagedata format="PNG" fileref="anychartool.png"/>
        </imageobject
></inlinemediaobject
></para>

        <para
>Jest to "kropka" (.) w wyrażeniu regularnym. Pasuje do dowolnego pojedynczego znaku.</para
> 
        
       
        
        </simplesect>



      <simplesect id="repeattool"
><title
>Narzędzie powtórzeń</title>
      <mediaobject
><imageobject>
            <imagedata format="PNG" fileref="repeat.png"/>
            </imageobject
></mediaobject>
        <para
><inlinemediaobject
><imageobject>
            <imagedata format="PNG" fileref="repeattool.png"/>
            </imageobject
></inlinemediaobject
></para>

        <para
>Określa powtarzające się elementy wyrażenia regularnego. W składni znakowej są do tego używane znaki gwiazdki (*), plusa (+), pytajnika (?) oraz zakresu ({3,5}). Po umieszczeniu w obszarze edycyjnym elementu za pomocą tego narzędzia pojawi się okno dialogowe, w którym wprowadza się informacje o wymaganej ilości powtórzeń.</para>
          
          <para
>Użytkownik wprowadza treść, która ma się powtarzać, w polu znajdującym się wewnątrz prostokąta wstawionego za pomocą narzędzia powtórzeń.</para>

          <para
>Elementy powtarzające się mogą być tworzone od zewnątrz lub od wewnątrz. To znaczy iż można najpierw narysować elementy, które należy powtarzać, wybrać je i użyć narzędzia powtórzeń. Można także najpierw wprowadzić element powtórzenia i narysować wewnątrz niego wyrażenia, które mają być powtarzane.</para>

        <para
>Więcej na ten temat w części dotyczącej <link linkend="repeatregexp"
>powtórzeń w wyrażeniach regularnych</link
>.</para>
        </simplesect>




      <simplesect id="altntool"
><title
>Narzędzie alternatywy</title>
      <mediaobject
><imageobject>
            <imagedata format="PNG" fileref="altn.png"/>
            </imageobject
></mediaobject>
        <para
><inlinemediaobject
><imageobject
><imagedata format="PNG" fileref="altntool.png"/>
        </imageobject
></inlinemediaobject
></para>
        
        <para
>Jest to wyrażenie regularne definiujące alternatywę (|). Wprowadzanie alternatywnych wyrażeń polega na wprowadzaniu jedno nad drugim każdego z nich w prostokącie utworzonym przez to narzędzie.</para>

        <para
>Więcej na ten temat w sekcji <link linkend="altnregexp"
>wyrażenia alternatywne</link
>.</para>
      </simplesect>
      



      <simplesect id="compoundtool"
><title
>Narzędzie złożonych wyrażeń regularnych</title>
        <mediaobject
><imageobject>
              <imagedata format="PNG" fileref="compound.png"/>
        </imageobject
></mediaobject>
        <para
><inlinemediaobject
><imageobject
><imagedata format="PNG" fileref="compoundtool.png"/>
        </imageobject
></inlinemediaobject
></para>
        
        <para
>Narzędzie to nie stanowi samo w sobie wyrażenia regularnego. Jest wykorzystywane do grupowania części wyrażenia w prostokącie, który w prosty sposób może być zwinięty (wyświetlany będzie jedynie tytuł). Widoczne jest to w prawej części zrzutu ekranu znajdującego się powyżej.</para>
      </simplesect>





      <simplesect id="positiontool"
><title
>Narzędzia: początek i koniec wiersza</title>
        <mediaobject
><imageobject>
            <imagedata format="PNG" fileref="begline.png"/>
        </imageobject
></mediaobject>
          <mediaobject
><imageobject>
              <imagedata format="PNG" fileref="endline.png"/>
        </imageobject
></mediaobject>
        <para
><inlinemediaobject
><imageobject
><imagedata format="PNG" fileref="linestartendtool.png"/>
        </imageobject
></inlinemediaobject
></para>

        <para
>Narzędzia początku i końca wiersza dopasowują odpowiednio początek i koniec wiersza w przeszukiwanym tekście. Wyrażenie regularne na przedstawionym powyżej ekranie dopasowuje jedynie spacje.</para>
        
        <para
>Więcej na ten temat w <link linkend="positionregexp"
>wyrażenia regularne określające pozycję</link
>.</para>
      </simplesect>





      <simplesect
><title
>Narzędzia dopasowujące granicę wyrazu (lub jej brak) </title>
      <mediaobject
><imageobject>
            <imagedata format="PNG" fileref="wordboundary.png"/>
            </imageobject
></mediaobject>
          <mediaobject
><imageobject
><imagedata format="PNG" fileref="nonwordboundary.png"/>
        </imageobject
></mediaobject>
        <para
><inlinemediaobject
><imageobject
><imagedata format="PNG" fileref="boundarytools.png"/>
        </imageobject
></inlinemediaobject
></para>

        <para
>Narzędzia te pasują do granicy wyrazu lub granicy nie-wyrazu. Wyrażenie przedstawione na ekranie dopasuje więc wszystkie wyrazy zaczynające się od <literal
>the</literal
>. Jednak sam wyraz <literal
>the</literal
> nie zostanie dopasowany.</para>

        <para
>Więcej na ten temat w <link linkend="boundaryregexp"
>wyrażenia regularne określające granice tekstu</link
>.</para>
      </simplesect>





      <simplesect id="lookaheadtools"
><title
>Narzędzia pozytywnego/negatywnego odnośnika w przód</title>
	  <mediaobject
><imageobject
> <imagedata format="PNG" fileref="poslookahead.png"/>
        </imageobject
></mediaobject>
          <mediaobject
><imageobject
> <imagedata format="PNG" fileref="neglookahead.png"/>
        </imageobject
></mediaobject>

        <para
><inlinemediaobject
><imageobject
> <imagedata format="PNG" fileref="lookaheadtools.png"/>
        </imageobject
></inlinemediaobject
></para>

        <para
>Narzędzia odnośników w przód określają pozytywne lub negatywne wyrażenie regularne. Dopasowane wyrażenie częściowe (zdefiniowane w odnośniku) nie stanie się jednak częścią dopasowania całego wyrażenia.</para>

        <para
>Uwaga: Odnośniki w przód można umieszczać tylko na końcu wyrażenia regularnego. Edytor wyrażeń nie posiada mechanizmu wymuszającego takie zachowanie.</para>

        <para
>Więcej na ten temat <link linkend="lookaheadregexp"
>odnośniki w przód w wyrażeniach regularnych</link
>.</para>
      </simplesect>
    </sect1>

  <!-- ====================================================================== -->
  <!--                  User Defined Regular Expressions                      -->
  <!-- ====================================================================== -->
    <sect1 id="userdefinedregexps">
      <title
>Wyrażenia regularne użytkownika</title>
      <para
>Po lewej stronie obszaru edycji widoczne jest pole listy zawierające zdefiniowane przez użytkownika wyrażenia regularne. Część z nich jest dostarczana wraz z instalacją środowiska KDE, pozostałe są dodawane samodzielnie.</para
> 

      <para
>Ta lista wyrażeń służy dwóm celom (<link linkend="screenorganization"
>opisanym tutaj</link
>): pierwszy to dostarczenie elementów budulcowych dla tworzonych wyrażeń, drugi to ładniejsze i bardziej czytelne ich wyświetlanie.</para>

      <para
>Można zapisywać stworzone wyrażenia regularne, naciskając prawym przyciskiem myszki w obszarze edycyjnym i wybierając z menu <literal
>Zapisz wyrażenie regularne</literal
>.</para>

      <para
>Jeżeli zapisywane wyrażenie zostało zgrupowane za pomocą <link linkend="compoundtool"
>narzędzia złożonych wyrażeń regularnych</link
> to spowoduje że budowane z niego inne wyrażenia będą wyświetlane w sposób bardziej czytelny.</para>

      <para
>Użytkownik może zmieniać nazwę lub usuwać zdefiniowane wyrażenia regularne naciskając prawym przyciskiem na odpowiedniej pozycji wyświetlonej na liście zapisanych wyrażeń.</para>
    </sect1>
  </chapter>

  <!-- ====================================================================== -->
  <!--                  Reporting a bug and Suggesting Features               -->
  <!-- ====================================================================== -->
  <chapter id="bugreport">
    <title
>Zgłaszanie błędów i propozycji nowych funkcji programu</title>
    <para
>Zgłaszanie błędów i propozycji ulepszeń powinno się odbywać za pomocą <ulink url="http://bugs.kde.org/"
>Systemu śledzenia błędów KDE</ulink
>. <emphasis role="strong"
>Zanim</emphasis
> użytkownik zgłosi błąd lub propozycję usprawnienia, powinien sprawdzić czy wcześniej ktoś już <ulink url="http://bugs.kde.org/simple_search.cgi?id=kregexpeditor"
>czegoś podobnego nie zgłosił.</ulink
></para>
  </chapter>

  <!-- ====================================================================== -->
  <!--                                 FAQ                                    -->
  <!-- ====================================================================== -->
  <chapter id="faq">
    <title
>Najczęściej zadawane pytania</title>
    <sect1 id="question1">
      <title
>Czy edytor wyrażeń regularnych obsługuje mechanizm odwołań wstecznych?</title>
      <para
>W chwili obecnej program nie obsługuje tego mechanizmu. Jego obsługa planowana jest w kolejnej wersji programu.</para>
    </sect1>

    <sect1 id="question2">
      <title
>Czy edytor wyrażeń regularnych ma funkcję pokazywania dopasowanych fragmentów?</title>
      <para
>Nie, ale możliwe iż ta funkcja pojawi się w kolejnej wersji.</para>
    </sect1>

    <sect1 id="question3">
      <title
>Tworzę programy dla środowiska KDE, czy mogę używać komponentu wyrażeń regularnych w swoich programach?</title>
      <para
>Zobacz <ulink url="http://developer.kde.org/documentation/library/cvs-api/kdelibs-apidocs/interfaces/html/classKRegExpEditorInterface.html"
>dokumentację interfejsu klasy KRegExpEditorInterface</ulink
>.</para>
    </sect1>

    <sect1 id="question4">
      <title
>Dlaczego nie widać przycisku <emphasis
>Edytuj wyrażenie regularne</emphasis
> w Konquerorze lub innych programach środowiska KDE?</title>
      <para
>Komponent wyrażeń regularnych jest częścią pakiedu KDE-utils. Jeżeli ten pakiet nie został zainstalowany w systemie to przycisk <emphasis
>edytora wyrażeń regularnych</emphasis
> nie będzie widoczny w innych programach.</para>
    </sect1>
  </chapter>

  <!-- ====================================================================== -->
  <!--                           Credits and Licenses                         -->
  <!-- ====================================================================== -->
  <chapter id="credits-and-license">
    <title
>Zasługi i licencje</title>

    <para
>Prawa autorskie do dokumentacji (c) 2001, Jesper K. Pedersen <email
>blackie@kde.org</email
> </para>
&underGPL; &underFDL; </chapter>


</book>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-namecase-general:t
sgml-general-insert-case:lower
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:2
sgml-indent-data:t
sgml-parent-document:nil
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
-->
