calibre - en to cs translation catalogue (64 entries)

en: Function mode for Search & replace in the Editor
cs: Režim funkcí pro Hledat a nahradit v editoru

en: The :guilabel:`Search & replace` tool in the editor support a *function mode*. In this mode, you can combine regular expressions (see :doc:`regexp`) with arbitrarily powerful Python functions to do all sorts of advanced text processing.
cs: Nástroj :guilabel:`Hledat a nahradit` v editoru podporuje *režim funkcí*. V tomto režimu můžete kombinovat regulární výrazy (viz: :doc:`regexp`) s libovolnými výkonnými funkcemi Pythonu pro provádění všech druhů rozšířeného zpracování textu.

en: In the standard *regexp* mode for search and replace, you specify both a regular expression to search for as well as a template that is used to replace all found matches. In function mode, instead of using a fixed template, you specify an arbitrary function, in the `Python programming language <https://docs.python.org>`_. This allows you to do lots of things that are not possible with simple templates.
cs: Ve standardním režimu *regulární výraz* pro hledání a nahrazení zadáváte jak regulární výraz pro hledání, tak šablonu, která je použita pro nahrazení všech nalezených shod. V režimu funkcí, namísto použití pevné šablony, zadáte libovolnou funkci v `programovacím jazyce Python <https://docs.python.org/>`_. Umožní vám to udělat spoustu věcí, které nejsou možné u jednoduchých šablon.

en: Techniques for using function mode and the syntax will be described by means of examples, showing you how to create functions to perform progressively more complex tasks.
cs: Techniky pro použití režimu funkcí a syntaxe budou popsány pomocí příkladů, které vám ukáží, jak vytvořit funkce pro provádění postupně složitějších úloh.

en: The Function mode
cs: Režim funkcí

en: Automatically fixing the case of headings in the document
cs: Automatická oprava velikosti písmen nadpisů v dokumentu

en: Here, we will leverage one of the builtin functions in the editor to automatically change the case of all text inside heading tags to title case::
cs: Zde budeme využívat jednu z vestavěných funkcí v editoru pro automatickou změnu velikosti písmen celého textu uvnitř značek nadpisů, aby byla všechna první písmena velká::

en: For the function, simply choose the :guilabel:`Title-case text (ignore tags)` builtin function. The will change titles that look like: ``<h1>some titLE</h1>`` to ``<h1>Some Title</h1>``. It will work even if there are other HTML tags inside the heading tags.
cs: Pro funkci jednoduše zvolte vestavěnou funkci :guilabel:`Všechna první velká (ignorovat značky)`. Toto změní nadpisy, které vypadají takto: ``<h1>nějaký nadPIS</h1>`` na ``<h1>Nějaký Nadpis</h1>``. Bude to fungovat, i když jsou jiné značky HTML uvnitř značek nadpisů.

en: Your first custom function - smartening hyphens
cs: Vaše první vlastní funkce – vylepšení pomlček

en: The real power of function mode comes from being able to create your own functions to process text in arbitrary ways. The Smarten Punctuation tool in the editor leaves individual hyphens alone, so you can use the this function to replace them with em-dashes.
cs: Skutečná síla režimu funkcí pochází ze schopnosti vytvářet vaše vlastní funkce pro zpracování textu libovolnými způsoby. Nástroj Vylepšit interpunkci v editoru nechává samostatné pomlčky být, takže můžete použít tuto funkci pro jejich nahrazení dlouhými pomlčkami.

en: To create a new function, simply click the :guilabel:`Create/edit` button to create a new function and copy the Python code from below.
cs: Pro vytvoření nové funkce jednoduše klikněte na tlačítko :guilabel:`Vytvořit nebo upravit` pro vytvoření nové funkce a zkopírujte níže uvedený kód Pythonu.

en: Every :guilabel:`Search & replace` custom function must have a unique name and consist of a Python function named replace, that accepts all the arguments shown above. For the moment, we won't worry about all the different arguments to ``replace()`` function. Just focus on the ``match`` argument. It represents a match when running a search and replace. Its full documentation in available `here <https://docs.python.org/library/re.html#match-objects>`_. ``match.group()`` simply returns all the matched text and all we do is replace hyphens in that text with em-dashes, first replacing double hyphens and then single hyphens.
cs: Každá vlastní funkce :guilabel:`Najít a nahradit` musí mít jedinečný název a skládat se z funkce Pythonu s názvem replace, která přijímá všechny výše uvedené parametry. Pro tuto chvíli se nebudeme starat o všechny různé parametry funkce ``replace()``. Soustředíme se pouze na parametr ``match``. Zastupuje shodu při spuštění hledat a nahradit. Jeho úplná dokumentace je dostupná `zde <https://docs.python.org/library/re.html#match-objects>`_.  ``match.group()`` jednoduše vrátí všechny odpovídající texty a vše, co uděláme je, že nahradíme pomlčky v tomto textu dlouhými pomlčkami, nejdříve se dvojité pomlčky a potom jednotlivé pomlčky.

en: Use this function with the find regular expression::
cs: Použijte tuto funkci s hledáním regulárního výrazu::

en: And it will replace all hyphens with em-dashes, but only in actual text and not inside HTML tag definitions.
cs: A nahradí to všechny pomlčky dlouhými pomlčkami, ale pouze ve skutečném textu a ne uvnitř definicí značek HTML.

en: The power of function mode - using a spelling dictionary to fix mis-hyphenated words
cs: Síla režimu funkcí – používání pravopisného slovníku pro opravu chybně rozdělených slov spojovníkem

en: Often, e-books created from scans of printed books contain mis-hyphenated words -- words that were split at the end of the line on the printed page. We will write a simple function to automatically find and fix such words.
cs: E-knihy vytvořené naskenováním tištěných knih často obsahují chybně rozdělená slova spojovníkem -- slova, která byla rozdělena na konci řádku na vytištěné stránce. Napíšeme si jednoduchou funkci pro automatické nalezení a opravení takových slov.

en: Use this function with the same find expression as before, namely::
cs: Použijte tuto funkci se stejným vyhledávacím výrazem jako předtím, a to::

en: And it will magically fix all mis-hyphenated words in the text of the book. The main trick is to use one of the useful extra arguments to the replace function, ``dictionaries``.  This refers to the dictionaries the editor itself uses to spell check text in the book. What this function does is look for words separated by a hyphen, remove the hyphen and check if the dictionary recognizes the composite word, if it does, the original words are replaced by the hyphen free composite word.
cs: A jako kouzlem to opraví všechna chybně rozdělená slova v textu knihy. Hlavní trik je použít jeden z užitečných dodatečných parametrů pro funkci nahrazení, ``dictionaries``. Ten odkazuje na slovníky, které samotný editor používá pro kontrolu pravopisu textu v knize. Tato funkce hledá slova oddělená spojovníkem, odebere spojovník a zkontrolujte, zda slovník rozpozná složené slovo. Pokud ano, původní slova jsou nahrazena složeným slovem bez spojovníku.

en: Note that one limitation of this technique is it will only work for mono-lingual books, because, by default, ``dictionaries.recognized()`` uses the main language of the book.
cs: Pamatujte, že jediné omezení této techniky je, že to bude fungovat pouze pro jednojazyčné knihy, protože ``dictionaries.recognized()`` ve výchozím nastavení používá hlavní jazyk knihy.

en: Auto numbering sections
cs: Automatické číslování oddílů

en: Now we will see something a little different. Suppose your HTML file has many sections, each with a heading in an :code:`<h2>` tag that looks like :code:`<h2>Some text</h2>`. You can create a custom function that will automatically number these headings with consecutive section numbers, so that they look like :code:`<h2>1. Some text</h2>`.
cs: Nyní uvidíme něco trochu jiného. Předpokládejme, že váš soubor HTML má mnoho oddílů, každý s nadpisem ve značce :code:`<h2>`, která vypadají takto :code:`<h2>Nějaký text</h2>`. Můžete si vytvořit vlastní funkci, která automaticky očísluje tyto nadpisy za sebou následujícími čísly oddílů, takže budou vypadat takto :code:`<h2>1. Nějaký text</h2>`.

en: Use it with the find expression::
cs: Použijte vyhledávací výraz::

en: Place the cursor at the top of the file and click :guilabel:`Replace all`.
cs: Umístěte kurzor na začátek souboru a klikněte na :guilabel:`Nahradit vše`.

en: This function uses another of the useful extra arguments to ``replace()``: the ``number`` argument. When doing a :guilabel:`Replace All` number is automatically incremented for every successive match.
cs: Tato funkce využívá další z užitečných dodatečných parametrů pro ``replace()``: parametr ``number``. Při provádění :guilabel:`Nahradit vše` je číslo automaticky zvýšeno pro každou následující shodu.

en: Another new feature is the use of ``replace.file_order`` -- setting that to ``'spine'`` means that if this search is run on multiple HTML files, the files are processed in the order in which they appear in the book. See :ref:`file_order_replace_all` for details.
cs: Další novinkou je použití ``replace.file_order`` -- nastavení, které pro ``'páteř'`` znamená, že pokud je toto hledání spuštěno na více souborech HTML, soubory jsou zpracovávány v pořadí, v jakém se objevují v knize. Pro podrobnosti viz :ref:`file_order_replace_all`.

en: Auto create a Table of Contents
cs: Automatické vytvoření obsahu

en: Finally, lets try something a little more ambitious. Suppose your book has headings in ``h1`` and ``h2`` tags that look like ``<h1 id="someid">Some Text</h1>``. We will auto-generate an HTML Table of Contents based on these headings. Create the custom function below:
cs: Nakonec zkusme něco trochu náročnějšího. Předpokládejme, že vaše kniha má nadpisy ve značkách ``h1`` a ``h2``, které vypadají takto ``<h1 id="nejakeid">Nějaký text</h1>``. Automaticky vygenerujeme HTML obsah na základě těchto nadpisů. Vytvořte níže uvedenou vlastní funkci:

en: And use it with the find expression::
cs: A použijte ji s vyhledávacím výrazem::

en: Run the search on :guilabel:`All text files` and at the end of the search, a window will popup with "Debug output from your function" which will have the HTML Table of Contents, ready to be pasted into :file:`toc.html`.
cs: Spusťte hledání nad :guilabel:`Všechny textové soubory` a na konci vyhledávání se otevře okno s "Výstup ladění z vaší funkce", které bude mít HTML obsah připravený k vložení do :file:`toc.html`.

en: The function above is heavily commented, so it should be easy to follow. The key new feature is the use of another useful extra argument to the ``replace()`` function, the ``data`` object. The ``data`` object is a Python *dictionary* that persists between all successive invocations of ``replace()`` during a single :guilabel:`Replace All` operation.
cs: Výše uvedená funkce je silně okomentovaná, takže by měla být snadno pochopitelná. Klíčovou novinkou je použití dalšího užitečného dodatečného parametru funkce ``replace()``, objektu ``data``. Objekt ``data`` je *slovník* Pythonu, který přetrvává mezi všemi po sobě následujícími voláními funkce ``replace()`` během jedné operace :guilabel:`Nahradit vše``.

en: Another new feature is the use of ``call_after_last_match`` -- setting that to ``True`` on the ``replace()`` function means that the editor will call ``replace()`` one extra time after all matches have been found. For this extra call, the match object will be ``None``.
cs: Další novinkou je použití ``call_after_last_match`` -- nastavení, které pro ``True`` nad funkcí ``replace()`` znamená, že editor vyvolá ``replace()`` ještě jednou poté, co byly nalezeny všechny shody. Pro toto dodatečné vyvolání bude shoda objektu ``None``.

en: This was just a demonstration to show you the power of function mode, if you really needed to generate a Table of Contents from headings in your book, you would be better off using the dedicated Table of Contents tool in :guilabel:`Tools->Table of Contents`.
cs: To byla jen ukázka, která vám předvedla sílu režimu funkcí, pokud opravdu potřebujete vygenerovat obsah z nadpisů ve vaší knize, měli byste raději použít vyhrazený nástroj pro obsah v :guilabel:`Nástroje->Obsah`.

en: The API for the function mode
cs: API pro režim funkcí

en: All function mode functions must be Python functions named replace, with the following signature::
cs: Všechny funkce režimu funkcí musí být funkce Pythonu pojmenované replace s následujícím podpisem::

en: When a find/replace is run, for every match that is found, the ``replace()`` function will be called, it must return the replacement string for that match. If no replacements are to be done, it should return ``match.group()`` which is the original string. The various arguments to the ``replace()`` function are documented below.
cs: Když je spuštěno najít a nahradit, pro každou shodu, která je nalezena, bude vyvolána funkce ``replace()``, která musí vrátit nahrazovací řetězec pro tuto shodu. Pokud není třeba provést žádná nahrazení, mělo by se vrátit ``match.group()``, což je původní řetězec. Jednotlivé parametry pro funkci ``replace()`` jsou zdokumentovány níže.

en: The ``match`` argument
cs: Parametr ``match``

en: The ``match`` argument represents the currently found match. It is a `Python Match object <https://docs.python.org/library/re.html#match-objects>`_. Its most useful method is ``group()`` which can be used to get the matched text corresponding to individual capture groups in the search regular expression.
cs: Parametr ``match`` představuje aktuálně nalezenou shodu. Je to `objekt Match Pythonu <https://docs.python.org/library/re.html#match-objects>`_. Jeho nejužitečnější metoda je ``group()``, která může být použita k získání textu odpovídajícího jednotlivým skupin zachycování v hledání regulárního výrazu.

en: The ``number`` argument
cs: Parametr ``number``

en: The ``number`` argument is the number of the current match. When you run :guilabel:`Replace All`, every successive match will cause ``replace()`` to be called with an increasing number. The first match has number 1.
cs: Parametr ``number`` je číslo aktuální shody. Když spustíte :guilabel:`Nahradit vše`, každá po sobě jdoucí shoda způsobí, že bude vyvoláno``replace()`` se zvyšujícím se číslem. První shoda má číslo 1.

en: The ``file_name`` argument
cs: Parametr ``file_name``

en: This is the filename of the file in which the current match was found. When searching inside marked text, the ``file_name`` is empty. The ``file_name`` is in canonical form, a path relative to the root of the book, using ``/`` as the path separator.
cs: Toto je název souboru, ve kterém byla nalezena aktuální shoda. Při hledání uvnitř označeného textu je ``file_name`` prázdný. ``file_name`` je v kanonické podobě, cesta relativní ke kořenu knihy, s ``/`` jako oddělovačem cesty.

en: The ``metadata`` argument
cs: Parametr ``metadata``

en: This represents the metadata of the current book, such as title, authors, language, etc. It is an object of class :class:`calibre.ebooks.metadata.book.base.Metadata`. Useful attributes include, ``title``, ``authors`` (a list of authors) and ``language`` (the language code).
cs: Toto představuje metadata aktuální knihy, jako je název, autoři, jazyk atd. Je to objekt třídy: :class:`calibre.ebooks.metadata.book.base.Metadata`. Užitečné atributy zahrnují ``title``, ``authors`` (seznam autorů) a ``language`` (kód jazyka).

en: The ``dictionaries`` argument
cs: Parametr ``dictionaries``

en: This represents the collection of dictionaries used for spell checking the current book. Its most useful method is ``dictionaries.recognized(word)`` which will return ``True`` if the passed in word is recognized by the dictionary for the current book's language.
cs: Toto představuje sbírku slovníků používaných ke kontrole pravopisu aktuální knihy. Jeho nejužitečnější metoda je ``dictionaries.recognized(word)``, která vrátí ``True``, pokud je předané slovo rozpoznáno slovníkem pro aktuální jazyk knihy.

en: The ``data`` argument
cs: Parametr ``data``

en: This a simple Python ``dictionary``. When you run :guilabel:`Replace all`, every successive match will cause ``replace()`` to be called with the same ``dictionary`` as data. You can thus use it to store arbitrary data between invocations of ``replace()`` during a :guilabel:`Replace all` operation.
cs: Jedná se o jednoduchý ``slovník`` Pythonu. Když spustíte :guilabel:`Nahradit vše``, každá následná shoda způsobí, že se zavolá ``replace()`` se stejným ``slovníkem`` jako data. Můžete jej tedy použít k uložení libovolných dat mezi voláními ``replace()`` během operace :guilabel:`Nahradit vše``.

en: The ``functions`` argument
cs: Parametr ``functions``

en: The ``functions`` argument gives you access to all other user defined functions. This is useful for code re-use. You can define utility functions in one place and re-use them in all your other functions. For example, suppose you create a function name ``My Function`` like this:
cs: Parametr ``functions`` vám dá přístup ke všem ostatním uživatelem definovaným funkcím. To je užitečné pro opětovné použití kódu. Můžete definovat obslužné funkce na jednom místě a znovu je použít ve všech  svých ostatních funkcích. Předpokládejme například, že vytvoříte funkci pojmenovanou ``My Function`` takto:

en: Then, in another function, you can access the ``utility()`` function like this:
cs: Potom v jiné funkci můžete přistupovat k funkci ``utility()`` takto:

en: You can also use the functions object to store persistent data, that can be re-used by other functions. For example, you could have one function that when run with :guilabel:`Replace All` collects some data and another function that uses it when it is run afterwards. Consider the following two functions:
cs: Můžete také použít objekt funkce pro ukládání trvalých dat, která mohou být znovu použita jinými funkcemi. Například byste mohli mít jednu funkci, která při spuštění s :guilabel:`Nahradit vše` shromažďuje některá data, a další funkci, která je používá, když je spuštěna později. Vezměme si následující dvě funkce:

en: Debugging your functions
cs: Ladění vašich funkcí

en: You can debug the functions you create by using the standard ``print()`` function from Python. The output of print will be displayed in a popup window after the Find/replace has completed. You saw an example of using ``print()`` to output an entire table of contents above.
cs: Funkce, které vytvoříte, můžete ladit pomocí standardní funkce ``print()`` z Pythonu. Výstup tisku se zobrazí v automaticky otevíraném okně po dokončení Najít a nahradit. Příklad použití ``print()`` pro výstup celého obsahu jste viděli výše.

en: Choose file order when running on multiple HTML files
cs: Volba pořadí souborů při spuštění na více souborech HTML

en: When you run a :guilabel:`Replace all` on multiple HTML files, the order in which the files are processes depends on what files you have open for editing. You can force the search to process files in the order in which the appear by setting the ``file_order`` attribute on your function, like this:
cs: Když spustíte :guilabel:`Nahradit vše` na více souborech HTML, pořadí, ve kterém jsou soubory zpracovány, závisí na tom, jaké soubory máte otevřené pro úpravy. Můžete vynutit, aby vyhledávání zpracovalo soubory v pořadí, ve kterém se objeví, nastavením parametru ``file_order`` ve vaší funkci takto:

en: ``file_order`` accepts two values, ``spine`` and ``spine-reverse`` which cause the search to process multiple files in the order they appear in the book, either forwards or backwards, respectively.
cs: ``file_order`` přijímá dvě hodnoty, ``spine`` a ``spine-reverse``, které způsobují, že hledání zpracuje více souborů v pořadí, v jakém jsou uvedeny v knize, a to buď vpřed nebo zpět v uvedeném pořadí.

en: Having your function called an extra time after the last match is found
cs: Vyvolání vaší funkce ještě jednou poté, co je nalezena poslední shoda

en: Sometimes, as in the auto generate table of contents example above, it is useful to have your function called an extra time after the last match is found. You can do this by setting the ``call_after_last_match`` attribute on your function, like this:
cs: Někdy, jako ve výše uvedeném příkladu automatického generování obsahu, je užitečné vyvolat vaši funkci ještě jednou poté, co je nalezena poslední shoda. To můžete provést nastavením parametru ``call_after_last_match` ve vaší funkci takto:

en: Appending the output from the function to marked text
cs: Připojování výstupu z funkce pro označený text

en: When running search and replace on marked text, it is sometimes useful to append so text to the end of the marked text. You can do that by setting the ``append_final_output_to_marked`` attribute on your function (note that you also need to set ``call_after_last_match``), like this:
cs: Při spuštění hledání a nahrazení na označeném textu je někdy užitečné připojit nějaký text na konec označeného textu. Můžete to udělat nastavením atributu ``append_final_output_to_marked`` na vaši funkci (pamatujte, že také musíte nastavit ``call_after_last_match``) takto:

en: Suppressing the result dialog when performing searches on marked text
cs: Potlačení dialogového okna výsledku při provádění vyhledávání na označeném textu

en: You can also suppress the result dialog (which can slow down the repeated application of a search/replace on many blocks of text) by setting the ``suppress_result_dialog`` attribute on your function, like this:
cs: Můžete také potlačit dialogové okno výsledku (což může zpomalit opakovanou aplikaci hledání a nahrazení na mnoha blocích textu) nastavením atributu ``suppress_result_dialog`` na vaší funkci takto:

en: More examples
cs: Další příklady

en: More useful examples, contributed by calibre users, can be found in the `calibre E-book editor forum <https://www.mobileread.com/forums/showthread.php?t=237181>`_.
cs: Další užitečné příklady, které vytvořili uživatelé Calibre, můžete nalézt ve `fóru Editoru e-knih Calibre <https://www.mobileread.com/forums/showthread.php?t=237181>`_.
