calibre - en to ta translation catalogue (211 entries)

en: The calibre template language
ta: காலிபர் வார்ப்புரு மொழி

en: The calibre template language is a calibre-specific language used throughout calibre for tasks such as specifying file paths, formatting values, and computing the value for user-specified columns. Examples:
ta: காலிபர் வார்ப்புரு மொழி என்பது கோப்பு பாதைகளைக் குறிப்பிடுவது, மதிப்புகளை வடிவமைத்தல் மற்றும் பயனர் குறிப்பிட்ட நெடுவரிசைகளுக்கான மதிப்பைக் கணக்கிடுதல் போன்ற பணிகளுக்கு காலிபர் முழுவதும் பயன்படுத்தப்படும் ஒரு காலிபர்-குறிப்பிட்ட மொழியாகும். எடுத்துக்காட்டுகள்:

en: Specify the folder structure and file names when saving files from the calibre library to the disk or e-book reader.
ta: காலிபர் நூலகத்திலிருந்து வட்டு அல்லது மின் புத்தக வாசகருக்கு கோப்புகளைச் சேமிக்கும்போது கோப்புறை அமைப்பு மற்றும் கோப்பு பெயர்களைக் குறிப்பிடவும்.

en: Define rules for adding icons and colors to the calibre book list.
ta: காலிபர் புத்தக பட்டியலில் ஐகான்கள் மற்றும் வண்ணங்களைச் சேர்ப்பதற்கான விதிகளை வரையறுக்கவும்.

en: Define `virtual columns` that contain data from other columns.
ta: மற்ற நெடுவரிசைகளிலிருந்து தரவைக் கொண்ட `மெய்நிகர் நெடுவரிசைகளை` வரையறுக்கவும்.

en: Advanced library searching.
ta: மேம்பட்ட நூலக தேடல்.

en: Advanced metadata search and replace.
ta: மேம்பட்ட மேனிலை தரவு தேடல் மற்றும் மாற்றவும்.

en: The language is built around the notion of a `template`, which specifies which book metadata to use, computations on that metadata, and how it is to be formatted.
ta: ஒரு `வார்ப்புரு` என்ற கருத்தைச் சுற்றி மொழி கட்டப்பட்டுள்ளது, இது எந்த புத்தக மெட்டாடேட்டாவைப் பயன்படுத்த வேண்டும், அந்த மெட்டாடேட்டாவில் கணக்கீடுகள் மற்றும் அது எவ்வாறு வடிவமைக்கப்பட வேண்டும் என்பதைக் குறிப்பிடுகிறது.

en: Basic templates
ta: அடிப்படை வார்ப்புருக்கள்

en: A basic template consists one or more ``template expressions``. A ``template expression`` consists of text and names in curly brackets (``{}``) that is replaced by the corresponding metadata from the book being processed. For example, the default template in calibre used for saving books to device has 4 ``template expressions``::
ta: ஒரு அடிப்படை வார்ப்புரு ஒன்று அல்லது அதற்கு மேற்பட்ட `` வார்ப்புரு வெளிப்பாடுகள்`` கொண்டுள்ளது. ஒரு `` வார்ப்புரு வெளிப்பாடு`` சுருள் அடைப்புக்குறிக்குள் உரை மற்றும் பெயர்களைக் கொண்டுள்ளது (`` {} ``) இது செயலாக்கப்படும் புத்தகத்திலிருந்து தொடர்புடைய மெட்டாடேட்டாவால் மாற்றப்படுகிறது. எடுத்துக்காட்டாக, சாதனத்தில் புத்தகங்களைச் சேமிக்கப் பயன்படுத்தப்படும் காலிபரில் உள்ள இயல்புநிலை வார்ப்புருவில் 4 `` வார்ப்புரு வெளிப்பாடுகள்` ::

en: For the book "The Foundation" by "Isaac Asimov" the  will become::
ta: "ஐசக் அசிமோவ்" எழுதிய "அறக்கட்டளை" புத்தகத்திற்கு விருப்பம் ::

en: The slashes are not ``template expressions`` because they are in between in ``{}``. Such text is left where it appears. For example, if the template is::
ta: ச்லாச்கள் `` வார்ப்புரு வெளிப்பாடுகள்` அல்ல, ஏனென்றால் அவை `` {} `` `க்கு இடையில் உள்ளன. அத்தகைய உரை தோன்றும் இடத்தில் விடப்படுகிறது. உதாரணமாக, வார்ப்புரு இருந்தால் ::

en: then for "The Foundation" the template produces::
ta: "அறக்கட்டளை" க்கு வார்ப்புரு உருவாக்குகிறது ::

en: A ``template expression`` can access all the metadata available in calibre, including custom columns (columns you create yourself), by using a column's ``lookup name``. To find the lookup name for a `column` (sometimes called `fields`), hover your mouse over the column header in calibre's book list. Lookup names for custom columns always begin with ``#``. For series type columns there is an additional field named ``#lookup name_index`` that is the series index for that book in the series. For example, if you have a custom series column named ``#myseries``, there will also be a column named ``#myseries_index``. The standard series column's index is named ``series_index``.
ta: ஒரு நெடுவரிசையின் `` தேடல் பெயர்`` ஐப் பயன்படுத்தி தனிப்பயன் நெடுவரிசைகள் (உங்களை உருவாக்கும் நெடுவரிசைகள்) உட்பட, காலிபரில் கிடைக்கும் அனைத்து மெட்டாடேட்டாவையும் ஒரு `` வார்ப்புரு வெளிப்பாடு`` அணுகலாம். `நெடுவரிசை` (சில நேரங்களில்` புலங்கள்` என்று அழைக்கப்படுகிறது) க்கான தேடல் பெயரைக் கண்டுபிடிக்க, காலிபரின் புத்தக பட்டியலில் நெடுவரிசை தலைப்புக்கு மேல் உங்கள் சுட்டியைச் செல்லுங்கள். தனிப்பயன் நெடுவரிசைகளுக்கான தேடல் பெயர்கள் எப்போதும் ``#`` உடன் தொடங்குகின்றன. தொடர் வகை நெடுவரிசைகளுக்கு `` #lookup name_index`` என்ற கூடுதல் புலம் உள்ளது, இது தொடரில் அந்த புத்தகத்திற்கான தொடர் குறியீடாகும். எடுத்துக்காட்டாக, உங்களிடம் ``#myseries`` என்ற தனிப்பயன் தொடர் நெடுவரிசை இருந்தால், ``#myseries_index`` என்ற நெடுவரிசையும் இருக்கும். நிலையான தொடர் நெடுவரிசையின் குறியீட்டுக்கு `` sitery_index`` என்று பெயரிடப்பட்டுள்ளது.

en: In addition to the standard column based fields, you also can use:
ta: நிலையான நெடுவரிசை அடிப்படையிலான புலங்களுக்கு கூடுதலாக, நீங்கள் பயன்படுத்தலாம்:

en: ``{formats}`` - A list of formats available in the calibre library for a book
ta: `` {formats} `` - ஒரு புத்தகத்திற்கான காலிபர் நூலகத்தில் கிடைக்கும் வடிவங்களின் பட்டியல்

en: ``{identifiers:select(isbn)}`` - The ISBN of the book
ta: `` {அடையாளங்காட்டிகள்: புத்தகத்தின் ஐ.எச்.பி.என்

en: If the metadata for the field for a given book is not defined then the field in the template is replaced by the empty string (``''``). For example, consider the following template::
ta: கொடுக்கப்பட்ட புத்தகத்திற்கான புலத்திற்கான மேனிலை தரவு வரையறுக்கப்படாவிட்டால், வார்ப்புருவில் உள்ள புலம் வெற்று சரத்தால் மாற்றப்படும் (`` '' ``). எடுத்துக்காட்டாக, பின்வரும் வார்ப்புருவைக் கவனியுங்கள் ::

en: If Asimov's book "Second Foundation" is in the series "Foundation" then the template produces::
ta: அசிமோவின் "இரண்டாவது அறக்கட்டளை" நூல் "அறக்கட்டளை" என்ற தொடரில் இருந்தால், வார்ப்புரு உருவாக்குகிறது ::

en: If a series has not been entered for the book then the template produces::
ta: புத்தகத்திற்கு ஒரு தொடர் உள்ளிடப்படவில்லை என்றால், வார்ப்புரு உருவாக்குகிறது ::

en: The template processor automatically removes multiple slashes and leading or trailing spaces.
ta: வார்ப்புரு செயலி தானாக பல ச்லாச்கள் மற்றும் முன்னணி அல்லது பின்தங்கிய இடங்களை நீக்குகிறது.

en: Advanced formatting
ta: மேம்பட்ட வடிவமைப்பு

en: In addition to metadata substitution, templates can conditionally include additional text and control how substituted data is formatted.
ta: மேனிலை தரவு மாற்றீட்டிற்கு கூடுதலாக, வார்ப்புருக்கள் நிபந்தனையுடன் கூடுதல் உரையை உள்ளடக்கியது மற்றும் மாற்று தரவு எவ்வாறு வடிவமைக்கப்படுகிறது என்பதைக் கட்டுப்படுத்தலாம்.

en: **Conditionally including text**
ta: ** உரை உட்பட நிபந்தனையுடன் **

en: Sometimes you want text to appear in the output only if a field is not empty. A common case is ``series`` and ``series_index`` where you want either nothing or the two values separated by a hyphen. calibre handles this case using a special ``template expression`` syntax.
ta: சில நேரங்களில் ஒரு புலம் காலியாக இல்லாவிட்டால் மட்டுமே வெளியீட்டில் உரை தோன்ற வேண்டும். ஒரு பொதுவான வழக்கு `` தொடர்`` மற்றும் `` தொடர்_இண்டெக்ச்`` அங்கு நீங்கள் எதுவும் விரும்பவில்லை அல்லது ஒரு ஐபனால் பிரிக்கப்பட்ட இரண்டு மதிப்புகள். ஒரு சிறப்பு `` வார்ப்புரு வெளிப்பாடு`` தொடரியல் பயன்படுத்தி இந்த வழக்கை காலிபர் கையாளுகிறார்.

en: For example and using the above Foundation example, assume you want the template to produce `Foundation - 3 - Second Foundation`. This template produces that output:
ta: எடுத்துக்காட்டாக, மேலே உள்ள அறக்கட்டளை எடுத்துக்காட்டைப் பயன்படுத்தி, வார்ப்புரு `அறக்கட்டளை - 3 - இரண்டாவது அடித்தளம்` ஐ உருவாக்க வேண்டும் என்று வைத்துக் கொள்ளுங்கள். இந்த வார்ப்புரு அந்த வெளியீட்டை உருவாக்குகிறது:

en: ``{series} - {series_index} - {title}``
ta: `{series} - {series_index} - {title}` `

en: However, if a book has no series the template will produce `- - the title`, which is probably not what you want. Generally, people want the result be the title without the extraneous hyphens. You can accomplish this using the following template syntax:
ta: இருப்பினும், ஒரு புத்தகத்தில் தொடர் இல்லை என்றால், வார்ப்புரு ` - - தலைப்பு` ஐ உருவாக்கும், இது நீங்கள் விரும்பாதது அல்ல. பொதுவாக, மக்கள் முடிவு வெளிப்புற ஐபன்கள் இல்லாமல் தலைப்பாக இருக்க விரும்புகிறார்கள். பின்வரும் வார்ப்புரு தொடரியல் பயன்படுத்தி இதை நீங்கள் நிறைவேற்றலாம்:

en: ``{field:|prefix_text|suffix_text}``
ta: `` {புலம்: | முன்னொட்டு_டெக்ச்ட் | பின்னொட்டு_டெக்ச்ட்} ``

en: This ``template expression`` says that if ``field`` has the value `XXXX` then the result will be `prefix_textXXXXXsuffix_text`. If ``field`` is empty (has no value) then the result will be the empty string (nothing) because the prefix and suffix are ignored. The prefix and suffix can contain blanks.
ta: இந்த `` வார்ப்புரு வெளிப்பாடு`` கூறுகிறது `` புலம்` `xxxx` மதிப்பு இருந்தால், இதன் விளைவாக` முன்னொட்டு `` புலம்`` காலியாக இருந்தால் (மதிப்பு இல்லை), இதன் விளைவாக வெற்று சரம் (ஒன்றுமில்லை) இருக்கும், ஏனெனில் முன்னொட்டு மற்றும் பின்னொட்டு புறக்கணிக்கப்படும். முன்னொட்டு மற்றும் பின்னொட்டு வெற்றிடங்களைக் கொண்டிருக்கலாம்.

en: **Do not use subtemplates (`{ ... }`) or functions (see below) in the prefix or the suffix.**
ta: ** முன்னொட்டு அல்லது பின்னொட்டில் சப்டெம்பிளேட்டுகள் (`{ ... }`) அல்லது செயல்பாடுகளை (கீழே காண்க) பயன்படுத்த வேண்டாம். **

en: Using this syntax, we can solve the above no-series problem with the template::
ta: இந்த தொடரியல் பயன்படுத்தி, வார்ப்புருவில் மேலே உள்ள தொடர் சிக்கலை நாம் தீர்க்க முடியும் ::

en: The hyphens will be included only if the book has a series index, which it has only if it has a series. Continuing the Foundation example again, the template will produce `Foundation - 1 - Second Foundation`.
ta: புத்தகத்தில் தொடர் குறியீடு இருந்தால் மட்டுமே ஐபன்கள் சேர்க்கப்படும், அதில் ஒரு தொடர் இருந்தால் மட்டுமே உள்ளது. அறக்கட்டளை உதாரணத்தைத் தொடர்ந்து, வார்ப்புரு `அறக்கட்டளை - 1 - இரண்டாவது அடித்தளத்தை` உருவாக்கும்.

en: Notes:
ta: குறிப்புகள்:

en: You must include the colon after the ``lookup name`` if you are using a prefix or a suffix.
ta: நீங்கள் ஒரு முன்னொட்டு அல்லது பின்னொட்டைப் பயன்படுத்துகிறீர்கள் என்றால் `` தேடல் பெயர்`` க்குப் பிறகு நீங்கள் பெருங்குடலை சேர்க்க வேண்டும்.

en: You must either use either no or both ``|`` characters. Using one, as in ``{field:| - }``, is not allowed.
ta: நீங்கள் இல்லை அல்லது இரண்டையும் பயன்படுத்த வேண்டும் `` | `` `எழுத்துக்கள். ஒன்றைப் பயன்படுத்துதல், `` {புலம்: | -} ``, அனுமதிக்கப்படவில்லை.

en: It is OK to provide no text for either the prefix or the suffix, such as in ``{series:|| - }``. The template ``{title:||}`` is the same as ``{title}``.
ta: `` {தொடர்: || போன்ற முன்னொட்டு அல்லது பின்னொட்டுக்கு எந்த உரையையும் வழங்குவது சரி -} ``. `` {தலைப்பு: ||} `` வார்ப்புரு `` {title} `` போன்றது.

en: **Formatting**
ta: ** வடிவமைத்தல் **

en: Suppose you want the ``series_index`` to be formatted as three digits with leading zeros. This does the trick:
ta: `` sitery_index`` ஐ முன்னணி பூச்சியங்களுடன் மூன்று இலக்கங்களாக வடிவமைக்க விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். இது தந்திரம் செய்கிறது:

en: ``{series_index:0>3s}`` - Three digits with leading zeros
ta: `{sitery_index: 0> 3s}` ` - முன்னணி பூச்சியங்களுடன் மூன்று இலக்கங்கள்

en: For trailing zeros, use:
ta: பூச்சியங்களைப் பின்தொடர்வதற்கு, பயன்படுத்தவும்:

en: ``{series_index:0<3s}`` - Three digits with trailing zeros
ta: `{sitery_index: 0 <3s}` ` - பூச்சியங்களுடன் மூன்று இலக்கங்கள்

en: If you use series indices with fractional values, e.g., 1.1, you might want the decimal points to line up. For example, you might want the indices 1 and 2.5 to appear as 01.00 and 02.50 so that they will sort correctly on a device that does lexical sorting. To do this, use:
ta: பகுதியளவு மதிப்புகளுடன் தொடர் குறியீடுகளைப் பயன்படுத்தினால், எ.கா., 1.1, தசம புள்ளிகள் வரிசைப்படுத்த வேண்டும் என்று நீங்கள் விரும்பலாம். எடுத்துக்காட்டாக, 1 மற்றும் 2.5 குறியீடுகள் 01.00 மற்றும் 02.50 ஆகத் தோன்ற வேண்டும் என்று நீங்கள் விரும்பலாம், இதனால் அவை லெக்சிக்கல் வரிசையாக்கத்தை செய்யும் சாதனத்தில் சரியாக வரிசைப்படுத்தும். இதைச் செய்ய, பயன்படுத்தவும்:

en: ``{series_index:0>5.2f}`` - Five characters consisting of two digits with leading zeros, a decimal point, then 2 digits after the decimal point.
ta: .

en: If you want only the first two letters of the data, use:
ta: தரவின் முதல் இரண்டு எழுத்துக்களை மட்டுமே நீங்கள் விரும்பினால், பயன்படுத்தவும்:

en: ``{author_sort:.2}`` - Only the first two letters of the author sort name
ta: `` {author_sort:.2} `` - ஆசிரியரின் முதல் இரண்டு எழுத்துக்கள் மட்டுமே

en: Much of the calibre template language formatting comes from Python. For more details on the syntax of these advanced formatting operations see the `Python documentation <https://docs.python.org/3/library/string.html#formatstrings>`_.
ta: காலிபர் வார்ப்புரு மொழி வடிவமைப்பின் பெரும்பகுதி பைத்தானில் இருந்து வருகிறது. இந்த மேம்பட்ட வடிவமைப்பு செயல்பாடுகளின் தொடரியல் பற்றிய கூடுதல் விவரங்களுக்கு `பைதான் ஆவணங்கள் <https://docs.python.org/3/library/string.html#formatstrings>` _.

en: Using templates to define custom columns
ta: தனிப்பயன் நெடுவரிசைகளை வரையறுக்க வார்ப்புருக்களைப் பயன்படுத்துதல்

en: Templates can be used to display information that isn't in calibre metadata, or to display metadata differently from calibre's normal format. For example, you might want to show the ``ISBN``, a field that calibre does not display. You can accomplish this creating a custom column with the type `Column built from other columns` (hereafter called `composite columns`) and providing a template to generate the displayed text. The column will display the result of evaluating the template. For example, to display the ISBN, create the column and enter ``{identifiers:select(isbn)}`` in the template box. To display a column containing the values of two series custom columns, separated by a comma, use ``{#series1:||,}{#series2}``.
ta: காலிபர் மெட்டாடேட்டாவில் இல்லாத தகவல்களைக் காண்பிக்க அல்லது காலிபரின் இயல்பான வடிவமைப்பிலிருந்து வித்தியாசமாகக் காண்பிக்க வார்ப்புருக்கள் பயன்படுத்தப்படலாம். எடுத்துக்காட்டாக, நீங்கள் காண்பிக்காத `` isbn`` என்பதைக் காட்ட விரும்பலாம். மற்ற நெடுவரிசைகளிலிருந்து கட்டப்பட்ட `நெடுவரிசை (இனிமேல்` கலப்பு நெடுவரிசைகள்` என அழைக்கப்படுகிறது) மற்றும் காண்பிக்கப்படும் உரையை உருவாக்க ஒரு வார்ப்புருவை வழங்கும் வகை `நெடுவரிசையுடன் தனிப்பயன் நெடுவரிசையை உருவாக்குவதை நீங்கள் நிறைவேற்றலாம். வார்ப்புருவை மதிப்பிடுவதன் முடிவை நெடுவரிசை காண்பிக்கும். எடுத்துக்காட்டாக, isbn ஐக் காண்பிக்க, நெடுவரிசையை உருவாக்கி `` {அடையாளங்காட்டிகள்: வார்ப்புரு பெட்டியில் (isbn)} `` தேர்ந்தெடுக்கவும். கமாவால் பிரிக்கப்பட்ட இரண்டு தொடர் தனிப்பயன் நெடுவரிசைகளின் மதிப்புகளைக் கொண்ட ஒரு நெடுவரிசையைக் காட்ட, `{#தொடர் 1: ||,} {#series2}` `ஐப் பயன்படுத்தவும்.

en: Composite columns can use any template option, including formatting.
ta: கலப்பு நெடுவரிசைகள் வடிவமைப்பு உட்பட எந்த வார்ப்புரு விருப்பத்தையும் பயன்படுத்தலாம்.

en: Note: You cannot edit the data displayed in a composite column. Instead you edit the source columns. If you edit a composite column, for example by double-clicking it, calibre will open the template for editing, not the underlying data.
ta: குறிப்பு: கலப்பு நெடுவரிசையில் காட்டப்படும் தரவை நீங்கள் திருத்த முடியாது. அதற்கு பதிலாக மூல நெடுவரிசைகளைத் திருத்துகிறீர்கள். நீங்கள் ஒரு கலப்பு நெடுவரிசையைத் திருத்தினால், எடுத்துக்காட்டாக, அதை இருமுறை சொடுக்கு செய்வதன் மூலம், காலிபர் திருத்துதல் வார்ப்புருவைத் திறக்கும், அடிப்படை தரவு அல்ல.

en: Templates and plugboards
ta: வார்ப்புருக்கள் மற்றும் செருகுநிரல்கள்

en: Plugboards are used for changing the metadata written into books during send-to-device and save-to-disk operations. A plugboard permits you to specify a template to provide the data to write into the book's metadata. You can use plugboards to modify the following fields: authors, author_sort, language, publisher, tags, title, title_sort. This feature helps people who want to use different metadata in books on devices to solve sorting or display issues.
ta: அனுப்பு-சாதனத்தின் போது புத்தகங்களில் எழுதப்பட்ட மெட்டாடேட்டாவை மாற்றுவதற்கும், விலக்கப்பட்ட செயல்பாடுகளைச் சேமிப்பதற்கும் பிளேக் போர்டுகள் பயன்படுத்தப்படுகின்றன. புத்தகத்தின் மெட்டாடேட்டாவில் எழுத தரவை வழங்க ஒரு வார்ப்புருவைக் குறிப்பிட ஒரு செருகுநிரல் உங்களை அனுமதிக்கிறது. பின்வரும் புலங்களை மாற்ற நீங்கள் செருகுநிரல்களைப் பயன்படுத்தலாம்: ஆசிரியர்கள், ஆசிரியர்_சார்ட், மொழி, வெளியீட்டாளர், குறிச்சொற்கள், தலைப்பு, தலைப்பு_சார்ட். வரிசையாக்கத்தை தீர்க்க அல்லது சிக்கல்களைக் காண்பிக்க சாதனங்களில் புத்தகங்களில் வெவ்வேறு மெட்டாடேட்டாவைப் பயன்படுத்த விரும்பும் நபர்களுக்கு இந்த நற்பொருத்தம் உதவுகிறது.

en: When you create a plugboard, you specify the format and device for which the plugboard is to be used. A special device is provided, ``save_to_disk``, that is used when saving formats (as opposed to sending them to a device). Once you have chosen the format and device, you choose the metadata fields to change, providing templates to supply the new values. These templates are `connected` to their destination fields, hence the name `plugboards`. You can of course use composite columns in these templates.
ta: நீங்கள் ஒரு செருகுநிரலை உருவாக்கும்போது, செருகுநிரல் பயன்படுத்த வேண்டிய வடிவம் மற்றும் சாதனத்தை நீங்கள் குறிப்பிடுகிறீர்கள். ஒரு சிறப்பு சாதனம் வழங்கப்படுகிறது, `` save_to_disk``, இது வடிவங்களைச் சேமிக்கும்போது பயன்படுத்தப்படுகிறது (அவற்றை ஒரு சாதனத்திற்கு அனுப்புவதற்கு மாறாக). நீங்கள் வடிவமைப்பு மற்றும் சாதனத்தைத் தேர்ந்தெடுத்ததும், மாற்றுவதற்கு மேனிலை தரவு புலங்களை தேர்வு செய்கிறீர்கள், புதிய மதிப்புகளை வழங்க வார்ப்புருக்களை வழங்குகிறீர்கள். இந்த வார்ப்புருக்கள் அவற்றின் இலக்கு புலங்களுடன் `இணைக்கப்பட்டுள்ளன, எனவே` பிளேப் போர்டுகள்` என்ற பெயர். இந்த வார்ப்புருக்களில் நீங்கள் நிச்சயமாக கலப்பு நெடுவரிசைகளைப் பயன்படுத்தலாம்.

en: Plugboards are quite flexible and can be written in Single Function Mode, Template Program Mode, General Program Mode, or Python Template mode.
ta: செருகுநிரல்கள் மிகவும் நெகிழ்வானவை, மேலும் அவை ஒற்றை செயல்பாட்டு பயன்முறை, வார்ப்புரு நிரல் பயன்முறை, பொது நிரல் பயன்முறை அல்லது பைதான் வார்ப்புரு பயன்முறையில் எழுதப்படலாம்.

en: When a plugboard might apply (Content server, save to disk, or send to device), calibre searches the defined plugboards to choose the correct one for the given format and device. For example, to find the appropriate plugboard for an EPUB book being sent to an ANDROID device, calibre searches the plugboards using the following search order:
ta: ஒரு செருகுநிரல் பொருந்தும் போது (உள்ளடக்க சேவையகம், வட்டில் சேமிக்கவும் அல்லது சாதனத்திற்கு அனுப்பவும்), கொடுக்கப்பட்ட வடிவம் மற்றும் சாதனத்திற்கு சரியான ஒன்றைத் தேர்வுசெய்ய காலிபர் வரையறுக்கப்பட்ட பிளேக் போர்டுகளைத் தேடுகிறது. எடுத்துக்காட்டாக, ஆண்ட்ராய்டு சாதனத்திற்கு அனுப்பப்படும் எபப் புத்தகத்திற்கு பொருத்தமான செருகுநிரலைக் கண்டுபிடிக்க, பின்வரும் தேடல் வரிசையைப் பயன்படுத்தி காலிபர் பிளேக் போர்டுகளைத் தேடுகிறார்:

en: a plugboard with an exact match on format and device, e.g., ``EPUB`` and ``ANDROID``
ta: வடிவமைப்பு மற்றும் சாதனத்தில் சரியான பொருத்தத்துடன் கூடிய செருகுநிரல், எ.கா., `` எபப்`` மற்றும் `` android``

en: a plugboard with an exact match on format and the special ``any device`` choice, e.g., ``EPUB`` and ``any device``
ta: வடிவமைப்பில் சரியான பொருத்தம் மற்றும் சிறப்பு `` எந்த சாதனமும்` தேர்வு, எ.கா., `` எபப்`` மற்றும் `` எந்த சாதனமும்` `

en: a plugboard with the special ``any format`` choice and an exact match on device, e.g., ``any format`` and ``ANDROID``
ta: சிறப்பு `` எந்த வடிவமும்` `தேர்வு மற்றும் சாதனத்தில் சரியான பொருத்தம், எ.கா.,` `எந்த வடிவமும்`` மற்றும்` `android``

en: a plugboard with ``any format`` and ``any device``
ta: `` எந்த வடிவமும் `` `எந்த சாதனமும்`` `` `` `

en: The tags and authors fields have special treatment, because both of these fields can hold more than one item. A book can have many tags and many authors. When you specify that one of these two fields is to be changed, the template's result is examined to see if more than one item is there. For tags, the result is cut apart wherever calibre finds a comma. For example, if the template produces the value ``Thriller, Horror``, then the result will be two tags, ``Thriller`` and ``Horror``. There is no way to put a comma in the middle of a tag.
ta: குறிச்சொற்கள் மற்றும் ஆசிரியர்கள் துறைகள் சிறப்பு சிகிச்சையைக் கொண்டுள்ளன, ஏனெனில் இந்த இரண்டு துறைகளும் ஒன்றுக்கு மேற்பட்ட உருப்படிகளை வைத்திருக்க முடியும். ஒரு புத்தகத்தில் பல குறிச்சொற்கள் மற்றும் பல ஆசிரியர்கள் இருக்கலாம். இந்த இரண்டு புலங்களில் ஒன்று மாற்றப்பட வேண்டும் என்று நீங்கள் குறிப்பிடும்போது, ஒன்றுக்கு மேற்பட்ட உருப்படிகள் இருக்கிறதா என்று வார்ப்புருவின் முடிவு ஆராயப்படுகிறது. குறிச்சொற்களைப் பொறுத்தவரை, காலிபர் ஒரு கமாவைக் கண்டறிந்த இடங்களில் இதன் விளைவாக துண்டிக்கப்படுகிறது. எடுத்துக்காட்டாக, வார்ப்புரு `` த்ரில்லர், திகில்`` மதிப்பை உருவாக்கினால், இதன் விளைவாக இரண்டு குறிச்சொற்கள், `` த்ரில்லர்`` மற்றும் `` திகில்``. ஒரு குறிச்சொல்லின் நடுவில் கமாவை வைக்க வழி இல்லை.

en: The same thing happens for authors, but using a different character for the cut, a `&` (ampersand) instead of a comma. For example, if the template produces the value ``Blogs, Joe&Posts, Susan``, then the book will end up with two authors, ``Blogs, Joe`` and ``Posts, Susan``. If the template produces the value ``Blogs, Joe;Posts, Susan``, then the book will have one author with a rather strange name.
ta: ஆசிரியர்களுக்கும் இதே சேதி நிகழ்கிறது, ஆனால் வெட்டுக்கு வேறுபட்ட பாத்திரத்தைப் பயன்படுத்துதல், கமாவிற்கு பதிலாக ஒரு `&` (ஆம்பர்சண்ட்). எடுத்துக்காட்டாக, வார்ப்புரு `` வலைப்பதிவுகள், சோ & பதிவுகள், சூசன்`` மதிப்பை உருவாக்கினால், நூல் இரண்டு ஆசிரியர்களுடன் முடிவடையும், `` வலைப்பதிவுகள், சோ`` மற்றும் `இடுகைகள், சூசன்``. வார்ப்புரு `` வலைப்பதிவுகள், சோ; இடுகைகள், சூசன்`` மதிப்பை உருவாக்கினால், புத்தகத்தில் ஒரு எழுத்தாளர் ஒரு விசித்திரமான பெயரைக் கொண்டிருப்பார்.

en: Plugboards affect the metadata written into the book when it is saved to disk or written to the device. Plugboards do not affect the metadata used by ``save to disk`` and ``send to device`` to create the file names. Instead, file names are constructed using the templates entered on the appropriate preferences window.
ta: பிளேப் போர்டுகள் புத்தகத்தில் எழுதப்பட்ட மெட்டாடேட்டாவை வட்டில் சேமிக்கும்போது அல்லது சாதனத்தில் எழுதும்போது பாதிக்கின்றன. கோப்பு பெயர்களை உருவாக்க `` வட்டில் சேமி `` வட்டுக்கு அனுப்பவும் `` `சாதனத்திற்கு அனுப்பவும். அதற்கு பதிலாக, பொருத்தமான விருப்பத்தேர்வுகள் சாளரத்தில் உள்ளிடப்பட்ட வார்ப்புருக்களைப் பயன்படுத்தி கோப்பு பெயர்கள் கட்டமைக்கப்படுகின்றன.

en: Using functions in templates - Single Function Mode
ta: வார்ப்புருக்களில் செயல்பாடுகளைப் பயன்படுத்துதல் - ஒற்றை செயல்பாட்டு முறை

en: Suppose you want to display the value of a field in upper case when that field is normally in title case. You can do this using `template functions`. For example, to display the title in upper case use the ``uppercase`` function, as in ``{title:uppercase()}``. To display it in title case, use ``{title:titlecase()}``.
ta: அந்த புலம் பொதுவாக தலைப்பு வழக்கில் இருக்கும்போது ஒரு புலத்தின் மதிப்பை மேல் விசயத்தில் காண்பிக்க விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். `வார்ப்புரு செயல்பாடுகளை` பயன்படுத்தி இதைச் செய்யலாம். எடுத்துக்காட்டாக, மேல் வழக்கில் தலைப்பைக் காண்பிக்க `` {தலைப்பு: பெரிய எழுத்து ()} `` போன்ற `` பெரிய எழுத்து`` செயல்பாட்டைப் பயன்படுத்தவும். தலைப்பு வழக்கில் இதைக் காட்ட, `` {தலைப்பு: டிட்லெகேச் ()} `` ஐப் பயன்படுத்தவும்.

en: Functions go into the format part of the template, after the ``:`` and before the first ``|`` or the closing ``}`` if no prefix/suffix is used. If you have both a format and a function reference, the function comes after a second ``:``.  Functions return the value of the column specified in the template, suitably modified.
ta: ``: `` க்குப் பிறகு, முதல் `` | `` அல்லது முன்னொட்டு/பின்னொட்டு எதுவும் பயன்படுத்தப்படாவிட்டால் ``} `` மூடுவதற்கு முன், செயல்பாடுகள் வார்ப்புருவின் வடிவமைப்பு பகுதிக்குச் செல்கின்றன. உங்களிடம் ஒரு வடிவம் மற்றும் செயல்பாட்டு குறிப்பு இரண்டும் இருந்தால், செயல்பாடு இரண்டாவது ``: `` க்குப் பிறகு வருகிறது. செயல்பாடுகள் வார்ப்புருவில் குறிப்பிடப்பட்டுள்ள நெடுவரிசையின் மதிப்பை மாற்றியமைக்கின்றன, பொருத்தமாக மாற்றியமைக்கப்படுகின்றன.

en: The syntax for using functions is one of::
ta: செயல்பாடுகளைப் பயன்படுத்துவதற்கான தொடரியல் ஒன்றாகும் ::

en: Function names must always be followed by opening and closing parentheses. Some functions require extra values (arguments), and these go inside the parentheses. Arguments are separated by commas. Literal commas (commas as text, not argument separators) must be preceded by a backslash (``\``) . The last (or only) argument cannot contain a textual closing parenthesis.
ta: அடைப்புக்குறிகளைத் திறப்பதன் மூலமும் மூடுவதன் மூலமும் செயல்பாட்டு பெயர்கள் எப்போதும் பின்பற்றப்பட வேண்டும். சில செயல்பாடுகளுக்கு கூடுதல் மதிப்புகள் (வாதங்கள்) தேவைப்படுகின்றன, மேலும் இவை அடைப்புக்குறிக்குள் செல்கின்றன. வாதங்கள் காற்புள்ளிகளால் பிரிக்கப்படுகின்றன. நேரடி காற்புள்ளிகள் (உரையாக கமாக்கள், வாத பிரிப்பான்கள் அல்ல) ஒரு பின்சாய்வுப்பால் (`` \ ``) முன்னதாக இருக்க வேண்டும். கடைசி (அல்லது மட்டும்) வாதத்தில் உரை நிறைவு அடைப்புக்குறிப்பு இருக்க முடியாது.

en: Functions are evaluated before format specifications and the prefix/suffix. See further down for an example of using both a format and a function.
ta: வடிவமைப்பு விவரக்குறிப்புகள் மற்றும் முன்னொட்டு/பின்னொட்டுக்கு முன் செயல்பாடுகள் மதிப்பீடு செய்யப்படுகின்றன. ஒரு வடிவம் மற்றும் செயல்பாடு இரண்டையும் பயன்படுத்துவதற்கான எடுத்துக்காட்டுக்கு மேலும் கீழே காண்க.

en: **Important**: If you have programming experience, please note that the syntax in `Single Function Mode` is not what you expect. Strings are not quoted and spaces are significant. All arguments are considered to be constants; there are no expressions.
ta: ** முக்கியமானது **: உங்களுக்கு நிரலாக்க பட்டறிவு இருந்தால், `ஒற்றை செயல்பாட்டு பயன்முறையில் 'தொடரியல் நீங்கள் எதிர்பார்ப்பது அல்ல என்பதை நினைவில் கொள்க. சரங்கள் மேற்கோள் காட்டப்படவில்லை மற்றும் இடைவெளிகள் குறிப்பிடத்தக்கவை. அனைத்து வாதங்களும் மாறிலிகளாக கருதப்படுகின்றன; வெளிப்பாடுகள் எதுவும் இல்லை.

en: **Do not use subtemplates (`{ ... }`) as function arguments.** Instead, use :ref:`Template Program Mode <template_mode>` and :ref:`General Program Mode <general_mode>`.
ta: .

en: Notes on calling functions in Single Function Mode:
ta: ஒற்றை செயல்பாட்டு பயன்முறையில் செயல்பாடுகளை அழைக்கும் குறிப்புகள்:

en: When functions are used in Single Function Mode, the first parameter, ``value``, is automatically replaced by the content of the field specified in the template. For example, when the template ``{title:capitalize()}`` is processed, the content of the ``title`` field is passed as the parameter ``value`` to the capitalize function.
ta: செயல்பாடுகள் ஒற்றை செயல்பாட்டு பயன்முறையில் பயன்படுத்தப்படும்போது, ​​முதல் அளவுரு, `` மதிப்பு``, வார்ப்புருவில் குறிப்பிடப்பட்டுள்ள புலத்தின் உள்ளடக்கத்தால் தானாகவே மாற்றப்படும். எடுத்துக்காட்டாக, `` {தலைப்பு: மூலதனமாக்குதல் () `` செயல்படுத்தப்படும் போது, ​​`` தலைப்பு`` புலத்தின் உள்ளடக்கம் மூலதன செயல்பாட்டிற்கு `` மதிப்பு`` அளவுருவாக நிறைவேற்றப்படுகிறது.

en: In the function documentation, the notation ``[something]*`` means that ``something`` can be repeated zero or more times. The notation ``[something]+`` means that the ``something`` is repeated one or more times (must exist at least one time).
ta: செயல்பாட்டு ஆவணத்தில், `` [ஏதாவது]*`` என்ற குறியீடு `` ஏதாவது`` பூச்சியமாக அல்லது அதற்கு மேற்பட்ட முறை மீண்டும் மீண்டும் செய்யப்படலாம் என்பதாகும். குறியீட்டு `` [ஏதாவது]+`` என்பது `` ஏதாவது`` ஒன்று அல்லது அதற்கு மேற்பட்ட முறை மீண்டும் மீண்டும் செய்யப்படுகிறது (குறைந்தது ஒரு முறையாவது இருக்க வேண்டும்).

en: Some functions use regular expressions. In the template language regular expression matching is case-insensitive.
ta: சில செயல்பாடுகள் வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்துகின்றன. வார்ப்புரு மொழியில் வழக்கமான வெளிப்பாடு பொருத்தம் வழக்கு-உணர்வற்றது.

en: Functions are documented in :ref:`template_functions_reference`. The documentation tells you what arguments the functions require and what the functions do. For example, here is the documentation of the :ref:`ff_ifempty` function.
ta: செயல்பாடுகள் இங்கு ஆவணப்படுத்தப்பட்டுள்ளன: ref: `வார்ப்புரு_ செயல்பாடுகள்_ரென்ச்`. செயல்பாடுகளுக்கு என்ன வாதங்கள் தேவை, செயல்பாடுகள் என்ன செய்கின்றன என்பதை ஆவணங்கள் உங்களுக்குக் கூறுகின்றன. எடுத்துக்காட்டாக, இங்கே ஆவணங்கள்: ref: `ff_ifempty` செயல்பாடு.

en: You see that the function requires two arguments, ``value`` and ``text_if_empty``. However, because we are using Single Function Mode, we omit the ``value`` argument, passing only ``text_if_empty``. For example, this template::
ta: செயல்பாட்டிற்கு இரண்டு வாதங்கள் தேவை என்பதை நீங்கள் காண்கிறீர்கள், `` மதிப்பு`` மற்றும் `` text_if_empty``. எவ்வாறாயினும், நாங்கள் ஒற்றை செயல்பாட்டு பயன்முறையைப் பயன்படுத்துவதால், `` மதிப்பு` 'வாதத்தை தவிர்த்து, `` Text_if_empty`` ஐ மட்டுமே அனுப்புகிறோம். எடுத்துக்காட்டாக, இந்த வார்ப்புரு ::

en: shows the tags for a book, if any. If it has no tags then it show `No tags on this book`.
ta: ஏதேனும் இருந்தால், ஒரு புத்தகத்திற்கான குறிச்சொற்களைக் காட்டுகிறது. அதில் குறிச்சொற்கள் இல்லை என்றால், அது `இந்த புத்தகத்தில் குறிச்சொற்கள் இல்லை 'என்பதைக் காட்டுகிறது.

en: The following functions are usable in Single Function Mode because their first parameter is ``value``.
ta: பின்வரும் செயல்பாடுகள் ஒற்றை செயல்பாட்டு பயன்முறையில் பயன்படுத்தக்கூடியவை, ஏனெனில் அவற்றின் முதல் அளவுரு `` மதிப்பு``.

en: **Using functions and formatting in the same template**
ta: ** அதே வார்ப்புருவில் செயல்பாடுகளையும் வடிவமைப்பையும் பயன்படுத்துதல் **

en: Suppose you have an integer custom column ``#myint`` that you want displayed with leading zeros, as in ``003``. One way to do this is to use a format of ``0>3s``. However, by default if a number (integer or float) equals zero then the value is displayed as the empty string so zero values will produce the empty string, not ``000``. If you want to see ``000`` values then you use both the format string and the ``ifempty`` function to change the empty value back to a zero. The template would be::
ta: `003`` இல் உள்ளதைப் போல, முன்னணி பூச்சியங்களுடன் நீங்கள் காட்ட விரும்பும் ஒரு முழு எண்ணும் தனிப்பயன் நெடுவரிசை` `#myint`` உங்களிடம் உள்ளது என்று வைத்துக்கொள்வோம். இதைச் செய்வதற்கான ஒரு வழி `0> 3s`` வடிவத்தைப் பயன்படுத்துவது. இருப்பினும், இயல்பாக ஒரு எண் (முழு எண் அல்லது மிதவை) பூச்சியத்திற்கு சமமாக இருந்தால், மதிப்பு வெற்று சரமாக காட்டப்படும், எனவே சுழிய மதிப்புகள் வெற்று சரத்தை உருவாக்கும், `000`` அல்ல. நீங்கள் `` 000`` மதிப்புகளைக் காண விரும்பினால், வெற்று மதிப்பை மீண்டும் பூச்சியமாக மாற்ற வடிவமைப்பு சரம் மற்றும் `` ifempty`` செயல்பாடு இரண்டையும் பயன்படுத்துகிறீர்கள். வார்ப்புரு ::

en: Note that you can use the prefix and suffix as well. If you want the number to appear as ``[003]`` or ``[000]``, then use the template::
ta: நீங்கள் முன்னொட்டு மற்றும் பின்னொட்டையும் பயன்படுத்தலாம் என்பதை நினைவில் கொள்க. எண் `` [003] `` அல்லது `` [000] `` என தோன்ற விரும்பினால், வார்ப்புருவைப் பயன்படுத்தவும் ::

en: General Program Mode
ta: பொது நிரல் பயன்முறை

en: `General Program Mode` (`GPM`) replaces `template expressions` with a program written in the `template language`. The syntax of the language is defined by the following grammar::
ta: `பொது நிரல் பயன்முறை` (` சிபிஎம்`) `வார்ப்புரு வெளிப்பாடுகளை`` வார்ப்புரு மொழியில்` இல் எழுதப்பட்ட ஒரு நிரலுடன் மாற்றுகிறது. மொழியின் தொடரியல் பின்வரும் இலக்கணத்தால் வரையறுக்கப்படுகிறது ::

en: a ``top_expression`` always has a value. The value of an ``expression_list`` is the value of the last ``top_expression`` in the list. For example, the value of the expression list ``1;2;'foobar';3`` is ``3``.
ta: ஒரு `` top_expression`` எப்போதும் ஒரு மதிப்பைக் கொண்டுள்ளது. `` எக்ச்பிரசன்_லிச்ட்`` இன் மதிப்பு என்பது பட்டியலில் உள்ள கடைசி `` டாப்_எக்ச்பிரசன்`` மதிப்பு. எடுத்துக்காட்டாக, வெளிப்பாடு பட்டியலின் மதிப்பு `` 1; 2; 'foobar'; 3`` என்பது `` 3``.

en: In a logical context, any non-empty value is ``True``
ta: ஒரு தர்க்கரீதியான சூழலில், எந்தவொரு காலியாக இல்லாத மதிப்பும் `` உண்மை``

en: In a logical context, the empty value is ``False``
ta: ஒரு தர்க்கரீதியான சூழலில், வெற்று மதிப்பு `` பொய்``

en: Strings and numbers can be used interchangeably. For example, ``10`` and ``'10'`` are the same thing.
ta: சரங்கள் மற்றும் எண்களை ஒன்றுக்கொன்று மாற்றாகப் பயன்படுத்தலாம். எடுத்துக்காட்டாக, `` 10`` மற்றும் `` '10'` ஒரே சேதி.

en: Comments are lines starting with a '#' character. Comments beginning later in a line are not supported.
ta: கருத்துகள் '#' எழுத்துடன் தொடங்கும் வரிகள். பின்னர் ஒரு வரியில் தொடங்கும் கருத்துகள் ஆதரிக்கப்படவில்லை.

en: **Operator precedence**
ta: ** ஆபரேட்டர் முன்னுரிமை **

en: The operator precedence (order of evaluation) from highest (evaluated first) to lowest (evaluated last) is:
ta: ஆபரேட்டர் முன்னுரிமை (மதிப்பீட்டின் வரிசை) மிக உயர்ந்த (முதலில் மதிப்பீடு செய்யப்பட்டது) முதல் மிகக் குறைந்த (கடைசியாக மதிப்பீடு செய்யப்பட்டது):

en: Function calls, constants, parenthesized expressions, statement expressions, assignment expressions, field references.
ta: செயல்பாட்டு அழைப்புகள், மாறிலிகள், அடைப்புக்குறிப்பு வெளிப்பாடுகள், அறிக்கை வெளிப்பாடுகள், ஒதுக்கீட்டு வெளிப்பாடுகள், புல குறிப்புகள்.

en: Unary plus (``+``) and minus (``-``). These operators evaluate right to left.
ta: யுனரி பிளச் (``+``) மற்றும் கழித்தல் (`` -``). இந்த ஆபரேட்டர்கள் வலமிருந்து இடமாக மதிப்பீடு செய்கிறார்கள்.

en: These and all the other arithmetic operators return integers if the expression results in a fractional part equal to zero. For example, if an expression returns ``3.0`` it is changed to ``3``.
ta: வெளிப்பாடு பூச்சியத்திற்கு சமமான ஒரு பகுதியளவு காரணமாக இருந்தால் இந்த மற்றும் பிற எண்கணித ஆபரேட்டர்கள் முழு எண்களைத் தருகின்றன. எடுத்துக்காட்டாக, ஒரு வெளிப்பாடு `` 3.0`` திரும்பினால் அது `` 3`` என மாற்றப்படுகிறது.

en: Multiply (``*``) and divide (``/``). These operators are associative and evaluate left to right. Use parentheses if you want to change the order of evaluation.
ta: பெருக்கி (``*``) பிரிக்கவும் (``/``). இந்த ஆபரேட்டர்கள் துணை மற்றும் இடமிருந்து வலமாக மதிப்பீடு செய்கிறார்கள். மதிப்பீட்டின் வரிசையை மாற்ற விரும்பினால் அடைப்புக்குறிப்புகள் பயன்படுத்தவும்.

en: Add (``+``) and subtract (``-``). These operators are associative and evaluate left to right.
ta: (``+``) சேர்த்து கழிக்கவும் (`` -``). இந்த ஆபரேட்டர்கள் துணை மற்றும் இடமிருந்து வலமாக மதிப்பீடு செய்கிறார்கள்.

en: Numeric and string comparisons. These operators return ``'1'`` if the comparison succeeds, otherwise the empty string (``''``). Comparisons are not associative: ``a < b < c`` is a syntax error.
ta: எண் மற்றும் சரம் ஒப்பீடுகள். இந்த ஆபரேட்டர்கள் ஒப்பீடு வெற்றி பெற்றால் `` '1'`` திருப்பித் தருகின்றன, இல்லையெனில் வெற்று சரம் (``' '``). ஒப்பீடுகள் துணை அல்ல: `` a <b <c`` என்பது ஒரு தொடரியல் பிழை.

en: String concatenation (``&``). The ``&`` operator returns a string formed by concatenating the left-hand and right-hand expressions. Example: ``'aaa' & 'bbb'`` returns ``'aaabbb'``. The operator is associative and evaluates left to right.
ta: சரம் ஒருங்கிணைப்பு (`` & ``). `` & `` ஆபரேட்டர் இடது கை மற்றும் வலது கை வெளிப்பாடுகளை ஒருங்கிணைப்பதன் மூலம் உருவாக்கப்பட்ட ஒரு சரத்தை வழங்குகிறது. எடுத்துக்காட்டு: `` 'aaa' & 'bbb'``` `' 'aaabbb'``. ஆபரேட்டர் துணை மற்றும் இடமிருந்து வலமாக மதிப்பீடு செய்கிறார்.

en: Unary logical not (``!``). This operator returns ``'1'`` if the expression is False (evaluates to the empty string), otherwise ``''``.
ta: unary logalor not (``! ``). இந்த ஆபரேட்டர் வெளிப்பாடு தவறானது என்றால் `` '1'`` திருப்பித் தருகிறது (வெற்று சரத்தை மதிப்பிடுகிறது), இல்லையெனில் ``' '``.

en: Logical and (``&&``). This operator returns '1' if both the left-hand and right-hand expressions are True, or the empty string ``''`` if either is False. It is associative, evaluates left to right, and does `short-circuiting <https://chortle.ccsu.edu/java5/Notes/chap40/ch40_2.html>`_.
ta: தர்க்கரீதியான மற்றும் (`` && ``). இடது கை மற்றும் வலது கை வெளிப்பாடுகள் இரண்டும் உண்மையாக இருந்தால், அல்லது வெற்று சரம் `''` `ஆகியவை பொய்யானதாக இருந்தால் இந்த ஆபரேட்டர் '1' ஐ வழங்குகிறது. இது துணை, இடமிருந்து வலமாக மதிப்பீடு செய்கிறது, மேலும் `குறுகிய சுற்று <https://chortle.ccsu.edu/java5/notes/chap40/ch40_2.html>` _.

en: Logical or (``||``). This operator returns ``'1'`` if either the left-hand or right-hand expression is True, or ``''`` if both are False. It is associative, evaluates left to right, and does `short-circuiting <https://chortle.ccsu.edu/java5/Notes/chap40/ch40_2.html>`_. It is an `inclusive or`, returning ``'1'`` if both the left- and right-hand expressions are True.
ta: தர்க்கரீதியான அல்லது (`` || ``). இந்த ஆபரேட்டர் `` '1'`` இடது கை அல்லது வலது கை வெளிப்பாடு உண்மையாக இருந்தால், அல்லது இரண்டும் பொய்யானதாக இருந்தால் ``' '`` `` `` `` `` `. இது துணை, இடமிருந்து வலமாக மதிப்பீடு செய்கிறது, மேலும் `குறுகிய சுற்று <https://chortle.ccsu.edu/java5/notes/chap40/ch40_2.html>` _. இது ஒரு `உள்ளடக்கிய அல்லது`, இடது மற்றும் வலது கை வெளிப்பாடுகள் இரண்டும் உண்மையாக இருந்தால்` `'1'` திரும்பும்.

en: **Field references**
ta: ** புல குறிப்புகள் **

en: A ``field_reference`` evaluates to the value of the metadata field named by lookup name that follows the ``$`` or ``$$``. Using ``$`` is equivalent to using the :ref:`ff_field` function. Using ``$$`` is equivalent to using the :ref:`ff_raw_field` function. Examples::
ta: `` `` `அல்லது` `$$` `` `` `ஆகியவற்றைப் பின்தொடரும் தேடல் பெயரால் பெயரிடப்பட்ட மேனிலை தரவு புலத்தின் மதிப்பை ஒரு` `புலம்_பிறப்புக்கு` மதிப்பீடு செய்கிறது. `` $ `` பயன்படுத்துவது: ref: `ff_field` செயல்பாட்டைப் பயன்படுத்துவதற்கு சமம். `` $$ `` `பயன்படுத்துவது: ref:` ff_raw_field` செயல்பாட்டைப் பயன்படுத்துவதற்கு சமம். எடுத்துக்காட்டுகள் ::

en: **If expressions**
ta: ** வெளிப்பாடுகள் என்றால் **

en: ``If`` expressions first evaluate the ``condition``. If the ``condition`` is True (a non-empty value) then the ``expression_list`` in the ``then`` clause is evaluated. If it is False then if present the ``expression_list`` in the ``elif`` or ``else`` clause is evaluated. The ``elif`` and ``else`` parts are optional. The words ``if``, ``then``, ``elif``, ``else``, and ``fi`` are reserved; you cannot use them as identifier names. You can put newlines and white space wherever they make sense. The ``condition`` is a ``top_expression`` not an ``expression_list``; semicolons are not allowed. The ``expression_lists`` are semicolon-separated sequences of ``top_expressions``. An ``if`` expression returns the result of the last ``top_expression`` in the evaluated ``expression_list``, or the empty string if no expression list was evaluated.
ta: `` if` `வெளிப்பாடுகள் முதலில்` `நிபந்தனையை`` மதிப்பீடு செய்கின்றன. `` நிபந்தனை`` உண்மையாக இருந்தால் (காலியாக இல்லாத மதிப்பு) பின்னர் `` பின்னர்`` பிரிவில் உள்ள `` வெளிப்பாடு_லிச்ட்`` மதிப்பீடு செய்யப்படுகிறது. அது தவறானது என்றால், `` எலிஃப்`` அல்லது `` வேறு`` பிரிவு மதிப்பீடு செய்யப்பட்டால் `` எக்ச்பிரசன்_லிச்ட்` வழங்கினால். `` elif`` மற்றும் `` வேறு`` பாகங்கள் விருப்பமானவை. `` if``, `` பின்னர்``, `` elif``, `` வேறு``, மற்றும் `` fi`` ஆகிய சொற்கள் ஒதுக்கப்பட்டுள்ளன; நீங்கள் அவற்றை அடையாளங்காட்டி பெயர்களாகப் பயன்படுத்த முடியாது. புதிய லைன்களையும் வெள்ளை இடத்தையும் அவர்கள் எங்கு அர்த்தப்படுத்தினாலும் நீங்கள் வைக்கலாம். `` நிபந்தனை`` என்பது ஒரு `` டாப்_எக்ச்பிரசன்`` ஒரு `` வெளிப்பாடு_லிச்ட்``; அரைக்காற்புள்ளிகள் அனுமதிக்கப்படவில்லை. `` எக்ச்பிரசன்_லிச்ட்கள்`` என்பது `` டாப்_எக்ச்பிரச்சன்கள்`` இன் அரைக்காற்புள்ளியால் பிரிக்கப்பட்ட காட்சிகள். ஒரு `` if`` வெளிப்பாடு மதிப்பிடப்பட்ட `` எக்ச்பிரசன்_லிச்ட்`` அல்லது வெளிப்பாடு பட்டியல் மதிப்பீடு செய்யப்படாவிட்டால் வெற்று சரம் ஆகியவற்றில் கடைசி `` டாப்_எக்ச்பிரசன்`` இன் முடிவை வழங்குகிறது.

en: Examples::
ta: எடுத்துக்காட்டுகள் ::

en: Nested ``if`` example::
ta: உள்ளமை `` if`` எடுத்துக்காட்டு ::

en: As said above, an ``if`` produces a value. This means that all the following are equivalent::
ta: மேலே கூறியது போல், ஒரு `` if`` ஒரு மதிப்பை உருவாக்குகிறது. இதன் பொருள் பின்வருபவை அனைத்தும் சமமானவை ::

en: For example, this program returns the value of the ``series`` column if the book has a series, otherwise the value of the ``title`` column::
ta: எடுத்துக்காட்டாக, இந்த நிரல் புத்தகத்தில் ஒரு தொடர் இருந்தால் `` தொடர்` நெடுவரிசையின் மதிப்பை வழங்குகிறது, இல்லையெனில் `` தலைப்பு`` நெடுவரிசையின் மதிப்பு ::

en: **For expressions**
ta: ** வெளிப்பாடுகளுக்கு **

en: The ``for`` expression iterates over a list of values, processing them one at a time. The ``list_expression`` must evaluate either to a metadata field ``lookup name`` e.g., ``tags`` or ``#genre``, or to a list of values. The :ref:`ff_range` generates a list of numbers. If the result is a valid ``lookup name`` then the field's value is fetched and the separator specified for that field type is used. If the result isn't a valid lookup name then it is assumed to be a list of values. The list is assumed to be separated by commas unless the optional keyword ``separator`` is supplied, in which case the list values must be separated by the result of evaluating the ``separator_expr``. A separator cannot be used if the list is generated by ``range()``. Each value in the list is assigned to the specified variable then the ``expression_list`` is evaluated. You can use ``break`` to jump out of the loop, and ``continue`` to jump to the beginning of the loop for the next iteration.
ta: `` `வெளிப்பாடு மதிப்புகளின் பட்டியலை மீண்டும் செயல்படுத்துகிறது, அவற்றை ஒரு நேரத்தில் செயலாக்குகிறது. `` பட்டியல்_எக்ச்பிரசன்`` ஒரு மேனிலை தரவு புலம் `` தேடல் பெயர்`` எ.கா., `` குறிச்சொற்கள்``` அல்லது `#வகை`` அல்லது மதிப்புகளின் பட்டியலுக்கு மதிப்பீடு செய்ய வேண்டும். தி: ref: `ff_range` எண்களின் பட்டியலை உருவாக்குகிறது. இதன் விளைவாக செல்லுபடியாகும் `` தேடல் பெயர்`` என்றால், புலத்தின் மதிப்பு பெறப்பட்டு, அந்த புல வகைக்கு குறிப்பிடப்பட்ட பிரிப்பான் பயன்படுத்தப்படுகிறது. முடிவு சரியான தேடல் பெயர் இல்லையென்றால், அது மதிப்புகளின் பட்டியல் என்று கருதப்படுகிறது. விருப்பமான முக்கிய சொல் `` பிரிப்பான்`` வழங்கப்படாவிட்டால், பட்டியல் காற்புள்ளிகளால் பிரிக்கப்படுவதாக கருதப்படுகிறது, இந்த விசயத்தில் `` பிரிப்பான்_எக்ச்ப்ரே`` மதிப்பிட்டதன் விளைவாக பட்டியல் மதிப்புகள் பிரிக்கப்பட வேண்டும். பட்டியல் `` வரம்பு () `` ஆல் உருவாக்கப்பட்டால் ஒரு பிரிப்பான் பயன்படுத்த முடியாது. பட்டியலில் உள்ள ஒவ்வொரு மதிப்பும் குறிப்பிட்ட மாறிக்கு ஒதுக்கப்படுகிறது, பின்னர் `` எக்ச்பிரசன்_லிச்ட்`` மதிப்பீடு செய்யப்படுகிறது. வளையத்திலிருந்து வெளியேற நீங்கள் `` பிரேக்`` ஐப் பயன்படுத்தலாம், மேலும் அடுத்த மறு செய்கைக்காக வளையத்தின் தொடக்கத்திற்கு செல்ல `` தொடரவும்.

en: Example: This template removes the first hierarchical name for each value in Genre (``#genre``), constructing a list with the new names::
ta: எடுத்துக்காட்டு: இந்த வார்ப்புரு வகையின் ஒவ்வொரு மதிப்புக்கும் முதல் படிநிலை பெயரை நீக்குகிறது (``#வகை``), புதிய பெயர்களுடன் ஒரு பட்டியலை உருவாக்குகிறது ::

en: If the original Genre is `History.Military, Science Fiction.Alternate History, ReadMe` then the template returns `Military, Alternate History, ReadMe`. You could use this template in calibre's :guilabel:`Edit metadata in bulk -> Search & replace` with :guilabel:`Search for` set to ``template`` to strip off the first level of the hierarchy and assign the resulting value to Genre.
ta: அசல் வகை `வரலாறு. தரைப்படை, அறிவியல் புனைகதை. மாற்றியமைத்தல் வரலாறு என்றால், ரீட்மே` பின்னர் வார்ப்புரு` தரைப்படை, மாற்று வரலாறு, ரீட்மே` ஐ வழங்குகிறது. இந்த வார்ப்புருவை நீங்கள் காலிபர்: கிலாபெல்: `மெட்டாடேட்டாவை மொத்தமாகத் திருத்து -> தேடல் & மாற்றவும்` உடன்: கிலாபெல்:` தேடலைத் தேடுங்கள் `` வார்ப்புரு`` ஐத் தேடுங்கள் வரிசைக்கு முதல் மட்டத்தை அகற்றவும், அதன் விளைவாக மதிப்பை ஒதுக்கவும் வகைக்கு.

en: Note: the last line in the template, ``new_tags``, isn't strictly necessary in this case because ``for`` returns the value of the last top_expression in the expression list. The value of an assignment is the value of its expression, so the value of the ``for`` statement is what was assigned to ``new_tags``.
ta: குறிப்பு: வார்ப்புருவின் கடைசி வரி, `` புதிய_டாக்ச்``, இந்த விசயத்தில் கண்டிப்பாக அவசியமில்லை, ஏனெனில் `` `` `` `வெளிப்பாடு பட்டியலில் கடைசி டாப்_எக்ச்பிரசனின் மதிப்பை வழங்குகிறது. ஒரு வேலையின் மதிப்பு அதன் வெளிப்பாட்டின் மதிப்பு, எனவே `` `` அறிக்கையின் மதிப்பு `` புதிய_டேக்ச்`` க்கு ஒதுக்கப்பட்டது.

en: **Function definition**
ta: ** செயல்பாட்டு வரையறை **

en: If you have repeated code in a template then you can put that code into a local function. The ``def`` keyword starts the definition. It is followed by the function name, the argument list, then the code in the function. The function definition ends with the ``fed`` keyword.
ta: நீங்கள் ஒரு வார்ப்புருவில் மீண்டும் குறியீட்டை வைத்திருந்தால், அந்த குறியீட்டை உள்ளக செயல்பாட்டில் வைக்கலாம். `` Def`` முக்கிய சொல் வரையறையைத் தொடங்குகிறது. அதைத் தொடர்ந்து செயல்பாட்டு பெயர், வாத பட்டியல், பின்னர் செயல்பாட்டில் உள்ள குறியீடு. செயல்பாட்டு வரையறை `` ஃபெட்`` முக்கிய சொல்லுடன் முடிகிறது.

en: Arguments are positional. When a function is called the supplied arguments are matched left to right against the defined parameters, with the value of the argument assigned to the parameter. It is an error to provide more arguments than defined parameters. Parameters can have default values, such as ``a = 25``. If an argument is not supplied for that parameter then the default value is used, otherwise the parameter is set to the empty string.
ta: வாதங்கள் நிலை. ஒரு செயல்பாடு என அழைக்கப்படும் போது, வழங்கப்பட்ட வாதங்கள் வரையறுக்கப்பட்ட அளவுருக்களுக்கு எதிராக இடமிருந்து வலமாக பொருந்துகின்றன, அளவுருவுக்கு ஒதுக்கப்பட்ட வாதத்தின் மதிப்பு. வரையறுக்கப்பட்ட அளவுருக்களைக் காட்டிலும் அதிகமான வாதங்களை வழங்குவது பிழை. அளவுருக்கள் `` a = 25`` போன்ற இயல்புநிலை மதிப்புகளைக் கொண்டிருக்கலாம். அந்த அளவுருவுக்கு ஒரு உரையாடல் வழங்கப்படாவிட்டால், இயல்புநிலை மதிப்பு பயன்படுத்தப்படுகிறது, இல்லையெனில் அளவுரு வெற்று சரத்திற்கு அமைக்கப்படுகிறது.

en: The ``return`` statement can be used in a local function.
ta: `` திரும்ப`` அறிக்கையை உள்ளக செயல்பாட்டில் பயன்படுத்தலாம்.

en: A function must be defined before it can be used.
ta: ஒரு செயல்பாடு பயன்படுத்தப்படுவதற்கு முன்பு வரையறுக்கப்பட வேண்டும்.

en: Example: This template computes an approximate duration in years, months, and days from a number of days. The function ``to_plural()`` formats the computed values. Note that the example also uses the ``&`` operator::
ta: எடுத்துக்காட்டு: இந்த வார்ப்புரு பல நாட்களிலிருந்து ஆண்டுகள், மாதங்கள் மற்றும் நாட்களில் தோராயமான காலத்தைக் கணக்கிடுகிறது. `` to_plural () `` கணக்கிடப்பட்ட மதிப்புகளை வடிவமைக்கிறது. எடுத்துக்காட்டு `` & `` ஆபரேட்டர் ::

en: **Relational operators**
ta: ** தொடர்புடைய ஆபரேட்டர்கள் **

en: Relational operators return ``'1'`` if the comparison is true, otherwise the empty string (``''``).
ta: தொடர்புடைய ஆபரேட்டர்கள் `` '1'`` ஒப்பீடு உண்மையாக இருந்தால், இல்லையெனில் வெற்று சரம் (``' '``) திரும்பும்.

en: There are two forms of relational operators: string comparisons and numeric comparisons.
ta: தொடர்புடைய ஆபரேட்டர்களின் இரண்டு வடிவங்கள் உள்ளன: சரம் ஒப்பீடுகள் மற்றும் எண் ஒப்பீடுகள்.

en: The numeric comparison operators are ``==#``, ``!=#``, ``<#``, ``<=#``, ``>#``, ``>=#``. The left and right expressions must evaluate to numeric values with two exceptions: both the string value "None" (undefined field) and the empty string evaluate to the value zero.
ta: எண் ஒப்பீட்டு ஆபரேட்டர்கள் `` ==#``, ``! . இடது மற்றும் வலது வெளிப்பாடுகள் இரண்டு விதிவிலக்குகளுடன் எண் மதிப்புகளுக்கு மதிப்பீடு செய்ய வேண்டும்: சரம் மதிப்பு "எதுவுமில்லை" (வரையறுக்கப்படாத புலம்) மற்றும் வெற்று சரம் ஆகிய இரண்டும் மதிப்பு பூச்சியத்திற்கு மதிப்பீடு செய்கின்றன.

en: Examples:
ta: எடுத்துக்காட்டுகள்:

en: ``program: field('series') == 'foo'`` returns ``'1'`` if the book's series is `foo`, otherwise ``''``.
ta: `` நிரல்: புலம் ('தொடர்') == 'foo'`` புத்தகத்தின் தொடர் `foo` ஆக இருந்தால், இல்லையெனில்` `' ''` `` `.

en: ``program: 'f.o' in field('series')`` returns ``'1'`` if the book's series matches the regular expression ``f.o`` (e.g., `foo`, `Off Onyx`, etc.), otherwise ``''``.
ta: `` நிரல்: 'f.o.r' புலத்தில் ('தொடர்') `` புத்தகத் தொடர் வழக்கமான வெளிப்பாட்டுடன் பொருந்தினால் `` f.o`` (எ.கா., `ஃபூ`,` ஆஃப் ஓனிக்ச்`, போன்றவை .), இல்லையெனில் `` '' ``.

en: ``program: 'science' inlist $#genre`` returns ``'1'`` if any of the values retrieved from the book's genres match the regular expression ``science``, e.g., `Science`, `History of Science`, `Science Fiction` etc., otherwise ``''``.
ta: `` நிரல்: 'அறிவியல்' இன் பட்டியல் $#வகை`` புத்தகத்தின் வகைகளிலிருந்து பெறப்பட்ட மதிப்புகள் ஏதேனும் வழக்கமான வெளிப்பாட்டுடன் பொருந்தினால் `` 1'``, எ.கா., `அறிவியல்`,` வரலாறு அறிவியல்`, `அறிவியல் புனைகதை` போன்றவை, இல்லையெனில்` `''` `.

en: ``program: '^science$' inlist $#genre`` returns ``'1'`` if any of the book's genres exactly match the regular expression ``^science$``, e.g., `Science`, otherwise ``''``. The genres `History of Science` and `Science Fiction` don't match.
ta: `` நிரல்: '^அறிவியல் $' inlist $#gene`` புத்தகத்தின் எந்தவொரு வகைகளும் வழக்கமான வெளிப்பாட்டுடன் சரியாக பொருந்தினால் `` 1'`` திரும்பும் `''` `. `அறிவியலின் வரலாறு` மற்றும்` அறிவியல் புனைகதை` வகைகள் பொருந்தவில்லை.

en: ``program: 'asimov' inlist $authors`` returns ``'1'`` if any author matches the regular expression ``asimov``, e.g., `Asimov, Isaac` or `Isaac Asimov`, otherwise ``''``.
ta: `நிரல்: 'அச்மானோவ்' பட்டியலிடப்பட்ட $ ஆசிரியர்கள்` '1'1' '' ''` `.

en: ``program: 'asimov' inlist_field 'authors'`` returns ``'1'`` if any author matches the regular expression ``asimov``, e.g., `Asimov, Isaac` or `Isaac Asimov`, otherwise ``''``.
ta: `நிரல்: 'அச்மோவ்' inlist_field 'ஆசிரியர்கள்'` `` '1'1'1' '' '' '' `'

en: ``program: 'asimov$' inlist_field 'authors'`` returns ``'1'`` if any author matches the regular expression ``asimov$``, e.g., `Isaac Asimov`, otherwise ``''``. It doesn't match `Asimov, Isaac` because of the ``$`` anchor in the regular expression.
ta: `` நிரல்: 'asimov $' inlist_field 'ஆசிரியர்கள்' `` `` 1'` எந்தவொரு எழுத்தாளரும் வழக்கமான வெளிப்பாட்டுடன் பொருந்தினால் `` அசிமோவ் $ ``, எ.கா., `ஐசக் அசிமோவ்`, இல்லையெனில்` `'' . வழக்கமான வெளிப்பாட்டில் `` $ `` நங்கூரத்தின் காரணமாக இது `அசிமோவ், ஐசக்` உடன் பொருந்தவில்லை.

en: ``program: if field('series') != 'foo' then 'bar' else 'mumble' fi`` returns ``'bar'`` if the book's series is not `foo`. Otherwise it returns ``'mumble'``.
ta: `` திட்டம்: புலம் ('தொடர்')! இல்லையெனில் அது `` 'முணுமுணுப்பு'`` தருகிறது.

en: ``program: if field('series') == 'foo' || field('series') == '1632' then 'yes' else 'no' fi`` returns ``'yes'`` if series is either `foo` or `1632`, otherwise ``'no'``.
ta: `` நிரல்: புலம் ('தொடர்') == 'ஃபூ' || புலம் ('தொடர்') == '1632' பின்னர் 'ஆம்' வேறு 'இல்லை' fi`` தொடர் `` 'ஆம்'`` திரும்புகிறது `foo` அல்லது` 1632`, இல்லையெனில் `` இல்லை'`` .

en: ``program: if '^(foo|1632)$' in field('series') then 'yes' else 'no' fi`` returns ``'yes'`` if series is either `foo` or `1632`, otherwise ``'no'``.
ta: `` நிரல்: '^(ஃபூ | `, இல்லையெனில்` `'இல்லை'`.

en: ``program: if 11 > 2 then 'yes' else 'no' fi`` returns ``'no'`` because the ``>`` operator does a lexical comparison.
ta: `` நிரல்: 11> 2 என்றால் 'ஆம்' வேறு 'இல்லை' fi`` `` 'இல்லை'` திரும்பி வருவதால் ``> `` ஆபரேட்டர் ஒரு சொற்பொழிவு ஒப்பீட்டைச் செய்கிறார்.

en: ``program: if 11 ># 2 then 'yes' else 'no' fi`` returns ``'yes'`` because the ``>#`` operator does a numeric comparison.
ta: `` நிரல்: 11># 2 என்றால் 'ஆம்' வேறு 'இல்லை' fi`` `` 'ஆம்'`` திரும்பி வருகிறார், ஏனெனில் ``># `` ஆபரேட்டர் ஒரு எண் ஒப்பீட்டைச் செய்கிறார்.

en: **Functions in General Program Mode**
ta: ** பொது நிரல் பயன்முறையில் செயல்பாடுகள் **

en: See :ref:`template_functions_reference` for the list of functions built into the template language.
ta: காண்க: Ref: வார்ப்புரு மொழியில் கட்டமைக்கப்பட்ட செயல்பாடுகளின் பட்டியலுக்கு `வார்ப்புரு_ செயல்பாடுகள்_ரென்ச்`.

en: As opposed to :ref:`Single Function Mode <single_mode>`, in General Program Mode you must specify the first parameter ``value``.
ta: எதிர்க்கும்: ref: `ஒற்றை செயல்பாட்டு முறை <ingin_mode>`, பொது நிரல் பயன்முறையில் நீங்கள் முதல் அளவுருவை `` மதிப்பு`` குறிப்பிட வேண்டும்.

en: All parameters are expression_lists (see the grammar above).
ta: அனைத்து அளவுருக்கள் வெளிப்பாடு_ பட்டியல்கள் (மேலே உள்ள இலக்கணத்தைக் காண்க).

en: More complex programs in template expressions - Template Program Mode
ta: வார்ப்புரு வெளிப்பாடுகளில் மிகவும் சிக்கலான நிரல்கள் - வார்ப்புரு நிரல் பயன்முறை

en: `Template Program Mode` (`TPM`) is a blend of :ref:`General Program Mode <general_mode>` and :ref:`Single Function Mode <single_mode>`. `TPM` differs from Single Function Mode in that it permits writing template expressions that refer to other metadata fields, use nested functions, modify variables, and do arithmetic. It differs from `General Program Mode` in that the template is contained between ``{`` and ``}`` characters and doesn't begin with the word ``program:``. The program portion of the template is a General Program Mode expression list.
ta: `வார்ப்புரு நிரல் பயன்முறை` (` tpm`) என்பது ஒரு கலவையாகும்: குறிப்பு: `பொது நிரல் பயன்முறை <பொது_மோட்>` மற்றும்: குறிப்பு: `ஒற்றை செயல்பாட்டு பயன்முறை <ஒற்றை_மோட்>`. `tpm` ஒற்றை செயல்பாட்டு பயன்முறையிலிருந்து வேறுபடுகிறது, இது பிற மேனிலை தரவு புலங்களைக் குறிக்கும் வார்ப்புரு வெளிப்பாடுகளை எழுத அனுமதிக்கிறது, உள்ளமைக்கப்பட்ட செயல்பாடுகளைப் பயன்படுத்துகிறது, மாறிகளை மாற்றியமைத்தல் மற்றும் எண்கணிதத்தை செய்கிறது. இது `பொது நிரல் பயன்முறையிலிருந்து` வேறுபடுகிறது, இதில் வார்ப்புரு` `{` `மற்றும்` `}` `` `` நிரல்: `` என்ற வார்த்தையுடன் தொடங்குவதில்லை. வார்ப்புருவின் நிரல் பகுதி ஒரு பொதுவான நிரல் பயன்முறை வெளிப்பாடு பட்டியல்.

en: Example: assume you want a template to show the series for a book if it has one, otherwise show the value of a custom field #genre. You cannot do this in the :ref:`Single Function Mode <single_mode>` because you cannot make reference to another metadata field within a template expression. In `TPM` you can, as the following expression demonstrates::
ta: எடுத்துக்காட்டு: ஒரு புத்தகத்திற்கான தொடரை ஒன்று இருந்தால் ஒரு வார்ப்புரு காட்ட வேண்டும் என்று வைத்துக் கொள்ளுங்கள், இல்லையெனில் தனிப்பயன் புலத்தின் மதிப்பைக் காட்டுங்கள். இதை நீங்கள் செய்ய முடியாது: ref: `ஒற்றை செயல்பாட்டு பயன்முறை <ஒற்றை_மோட்>` ஏனெனில் ஒரு வார்ப்புரு வெளிப்பாட்டிற்குள் மற்றொரு மேனிலை தரவு புலத்தைக் குறிப்பிட முடியாது. `tpm` இல், பின்வரும் வெளிப்பாடு நிரூபிக்கிறபடி ::

en: The example shows several things:
ta: எடுத்துக்காட்டு பல விசயங்களைக் காட்டுகிறது:

en: `TPM` is used if the expression begins with ``:'`` and ends with ``'}``. Anything else is assumed to be in :ref:`Single Function Mode <single_mode>`.
ta: வெளிப்பாடு ``: '`` உடன் தொடங்கி ``'} `` உடன் முடிவடைந்தால் `டிபிஎம்` பயன்படுத்தப்படுகிறது. வேறு எதுவும் இருக்க வேண்டும் என்று கருதப்படுகிறது: குறிப்பு: `ஒற்றை செயல்பாட்டு பயன்முறை <ஒற்றை_மோட்>`.

en: If the template contains a prefix and suffix, the expression ends with ``'|`` where the ``|`` is the delimiter for the prefix. Example::
ta: வார்ப்புருவில் ஒரு முன்னொட்டு மற்றும் பின்னொட்டு இருந்தால், வெளிப்பாடு `` '| `` உடன் முடிவடைகிறது, அங்கு `` | `` முன்னொட்டுக்கான டிலிமிட்டர். எடுத்துக்காட்டு ::

en: Functions must be given all their arguments. For example, the standard built-in functions must be given the initial parameter ``value``.
ta: செயல்பாடுகளுக்கு அவற்றின் அனைத்து வாதங்களும் வழங்கப்பட வேண்டும். எடுத்துக்காட்டாக, நிலையான உள்ளமைக்கப்பட்ட செயல்பாடுகளுக்கு ஆரம்ப அளவுரு `` மதிப்பு`` கொடுக்கப்பட வேண்டும்.

en: white space is ignored and can be used anywhere within the expression.
ta: வெள்ளை இடம் புறக்கணிக்கப்படுகிறது மற்றும் வெளிப்பாட்டிற்குள் எங்கும் பயன்படுத்தலாம்.

en: constant strings are enclosed in matching quotes, either ``'`` or ``"``.
ta: பொருந்தக்கூடிய மேற்கோள்களில் நிலையான சரங்கள் இணைக்கப்பட்டுள்ளன, `` '`` அல்லது `` "` `.

en: Python Template Mode
ta: பைதான் வார்ப்புரு பயன்முறை

en: Python Template Mode (PTM) lets you write templates using native Python and the `calibre API <https://manual.calibre-ebook.com/develop.html#api-documentation-for-various-parts-of-calibre>`_. The database API will be of most use; further discussion is beyond the scope of this manual. PTM templates are faster and can do more complicated operations but you must know how to write code in Python using the calibre API.
ta: பைதான் வார்ப்புரு பயன்முறை (பி.டி.எம்) சொந்த பைதான் மற்றும் `காலிபர் பநிஇ <https://manual.calibre-ebook.com/develop.html#api- ஆவணப்படுத்தல்-ஃபார்-வெரிட்டச்-பார்ட்ச்-கலிபிரே>` _. தரவுத்தள பநிஇ மிகவும் பயன்பாட்டில் இருக்கும்; மேலும் விவாதம் இந்த கையேட்டின் எல்லைக்கு அப்பாற்பட்டது. பி.டி.எம் வார்ப்புருக்கள் வேகமானவை, மேலும் சிக்கலான செயல்பாடுகளைச் செய்ய முடியும், ஆனால் காலிபர் பநிஇ பயன்படுத்தி பைத்தானில் குறியீட்டை எவ்வாறு எழுதுவது என்பது உங்களுக்குத் தெரிந்திருக்க வேண்டும்.

en: A PTM template begins with:
ta: ஒரு பி.டி.எம் வார்ப்புரு தொடங்குகிறது:

en: You can add the above text to your template using the context menu, usually accessed with a right click. The comments are not significant and can be removed. You must use python indenting.
ta: சூழல் மெனுவைப் பயன்படுத்தி மேலே உள்ள உரையை உங்கள் வார்ப்புருவில் சேர்க்கலாம், வழக்கமாக வலது சொடுக்கு மூலம் அணுகலாம். கருத்துகள் குறிப்பிடத்தக்கவை அல்ல மற்றும் அகற்றப்படலாம். நீங்கள் பைத்தானை உள்தள்ளலைப் பயன்படுத்த வேண்டும்.

en: The context object supports ``str(context)`` that returns a string of the context's contents, and ``context.attributes`` that returns a list of the attribute names in the context.
ta: சூழல் பொருள் `` str (சூழல்) `` ஆகியவற்றை ஆதரிக்கிறது, இது சூழலின் உள்ளடக்கங்களின் ஒரு சரத்தை வழங்குகிறது, மற்றும் `` சூழல்.

en: The ``context.funcs`` attribute allows calling Built-in and User template functions, and Stored GPM/Python templates, so that you can execute them directly in your code. The functions are retrieved using their names. If the name conflicts with a Python keyword, add an underscore to the end of the name. Examples:
ta: `` context.funcs`` பண்புக்கூறு உள்ளமைக்கப்பட்ட மற்றும் பயனர் வார்ப்புரு செயல்பாடுகளை அழைக்க அனுமதிக்கிறது, மேலும் சிபிஎம்/பைதான் வார்ப்புருக்கள் சேமித்து வைக்கப்பட்டுள்ளது, இதன் மூலம் அவற்றை உங்கள் குறியீட்டில் நேரடியாக இயக்க முடியும். செயல்பாடுகள் அவற்றின் பெயர்களைப் பயன்படுத்தி மீட்டெடுக்கப்படுகின்றன. பெயர் பைதான் முக்கிய சொல்லுடன் முரண்பட்டால், பெயரின் முடிவில் அடிக்கோடிட்டு சேர்க்கவும். எடுத்துக்காட்டுகள்:

en: Here is an example of a PTM template that produces a list of all the authors for a series. The list is stored in a `Column built from other columns, behaves like tags`. It shows in :guilabel:`Book details` and has the :guilabel:`on separate lines` checked (in :guilabel:`Preferences->Look & feel->Book details`). That option requires the list to be comma-separated. To satisfy that requirement the template converts commas in author names to semicolons then builds a comma-separated list of authors. The authors are then sorted, which is why the template uses author_sort.
ta: ஒரு தொடருக்கான அனைத்து ஆசிரியர்களின் பட்டியலையும் உருவாக்கும் ptm வார்ப்புருவின் எடுத்துக்காட்டு இங்கே. பட்டியல் மற்ற நெடுவரிசைகளிலிருந்து கட்டப்பட்ட `நெடுவரிசையில் சேமிக்கப்படுகிறது, குறிச்சொற்கள் போன்ற செயல்படுகிறது. இது காட்டுகிறது: கிலாபெல்: `புத்தக விவரங்கள்` மற்றும் தி: கிலாபெல்:` தனி வரிகளில்` சரிபார்க்கப்பட்டது (இல்: கிலாபெல்: `விருப்பத்தேர்வுகள்-> தோற்றம் & உணர்வு-> புத்தக விவரங்கள்`). அந்த விருப்பத்திற்கு பட்டியல் கமாவால் பிரிக்கப்பட வேண்டும். அந்த தேவையை நிறைவு செய்ய வார்ப்புரு கம்மாக்களை ஆசிரியர் பெயர்களில் அரைக்காற்புள்ளிகளாக மாற்றுகிறது, பின்னர் கமாவால் பிரிக்கப்பட்ட ஆசிரியர்களின் பட்டியலை உருவாக்குகிறது. பின்னர் ஆசிரியர்கள் வரிசைப்படுத்தப்படுகிறார்கள், அதனால்தான் வார்ப்புரு எழுத்தாளர்_சார்ட்டைப் பயன்படுத்துகிறது.

en: The output in :guilabel:`Book details` looks like this:
ta: வெளியீடு: கிலாபெல்: `புத்தக விவரங்கள்` இது போல் தெரிகிறது:

en: E-book conversion dialog
ta: மின் புத்தக மாற்று உரையாடல்

en: Stored templates
ta: சேமிக்கப்பட்ட வார்ப்புருக்கள்

en: Both :ref:`General Program Mode <general_mode>` and :ref:`Python Template Mode <python_mode>` support saving templates and calling those templates from another template, much like calling stored functions. You save templates using :guilabel:`Preferences->Advanced->Template functions`. More information is provided in that dialog. You call a template the same way you call a function, passing positional arguments if desired. An argument can be any expression. Examples of calling a template, assuming the stored template is named ``foo``:
ta: இரண்டும்: குறிப்பு: `பொது நிரல் பயன்முறை <பொது_மோட்>` மற்றும்: குறிப்பு: `பைதான் வார்ப்புரு பயன்முறை <பைதான்_மோட்>` சேமிப்பு வார்ப்புருக்கள் மற்றும் அந்த வார்ப்புருக்களை மற்றொரு வார்ப்புருவில் இருந்து அழைப்பதை ஆதரிக்கவும், சேமிக்கப்பட்ட செயல்பாடுகளை அழைப்பது போன்றது. பயன்படுத்தி வார்ப்புருக்களைச் சேமிக்கிறீர்கள்: கிலாபெல்: `விருப்பத்தேர்வுகள்-> மேம்பட்ட-> வார்ப்புரு செயல்பாடுகள்`. அந்த உரையாடலில் மேலும் தகவல்கள் வழங்கப்பட்டுள்ளன. நீங்கள் ஒரு செயல்பாட்டை அழைப்பது போலவே ஒரு வார்ப்புருவை அழைக்கிறீர்கள், விரும்பினால் நிலை வாதங்களை கடந்து செல்கிறீர்கள். ஒரு உரையாடல் எந்த வெளிப்பாடாகவும் இருக்கலாம். ஒரு வார்ப்புருவை அழைப்பதற்கான எடுத்துக்காட்டுகள், சேமிக்கப்பட்ட வார்ப்புருவுக்கு `` foo`` என்று பெயரிடப்பட்டுள்ளது என்று கருதுகிறது:

en: ``foo()`` -- call the template passing no arguments.
ta: `` foo () `` - எந்த வாதங்களையும் கடந்து செல்லும் வார்ப்புருவை அழைக்கவும்.

en: ``foo(a, b)`` call the template passing the values of the two variables ``a`` and ``b``.
ta: `` foo (a, b) `` இரண்டு மாறிகளின் மதிப்புகளை கடந்து செல்லும் வார்ப்புருவை அழைக்கவும் `` a`` மற்றும் `` b``.

en: ``foo(if field('series') then field('series_index') else 0 fi)`` -- if the book has a ``series`` then pass the ``series_index``, otherwise pass the value ``0``.
ta: `` ஃபூ (புலம் ('தொடர்') பின்னர் புலம் ('சீரிச்_இண்டெக்ச்') வேறு 0 fi) `` - புத்தகத்தில் `` தொடர்`` இருந்தால் `` sitery_index`` ஐ கடந்து செல்லுங்கள், இல்லையெனில் மதிப்பை அனுப்பவும் ` `0``.

en: In GPM you retrieve the arguments passed in the call to the stored template using the ``arguments`` function. It both declares and initializes local variables, effectively parameters. The variables are positional; they get the value of the parameter given in the call in the same position. If the corresponding parameter is not provided in the call then ``arguments`` assigns that variable the provided default value. If there is no default value then the variable is set to the empty string. For example, the following ``arguments`` function declares 2 variables, ``key``, ``alternate``::
ta: சி.பி.எம்மில் நீங்கள் `` வாதங்கள்`` செயல்பாட்டைப் பயன்படுத்தி சேமிக்கப்பட்ட வார்ப்புருவுக்கான அழைப்பில் அனுப்பப்பட்ட வாதங்களை மீட்டெடுக்கிறீர்கள். இது உள்ளக மாறிகள், திறம்பட அளவுருக்களை அறிவித்து துவக்குகிறது. மாறிகள் நிலை; அழைப்பில் கொடுக்கப்பட்ட அளவுருவின் மதிப்பை அவர்கள் அதே நிலையில் பெறுகிறார்கள். தொடர்புடைய அளவுரு அழைப்பில் வழங்கப்படாவிட்டால், `` வாதங்கள்`` அந்த மாறியை வழங்கிய இயல்புநிலை மதிப்பை ஒதுக்குகிறது. இயல்புநிலை மதிப்பு இல்லை என்றால், மாறி வெற்று சரத்திற்கு அமைக்கப்படுகிறது. எடுத்துக்காட்டாக, பின்வரும் `` வாதங்கள்`` செயல்பாடு 2 மாறிகள், `` விசை``, `` மாற்று`` ::

en: Examples, again assuming the stored template is named ``foo``:
ta: எடுத்துக்காட்டுகள், மீண்டும் சேமிக்கப்பட்ட வார்ப்புருவை `` foo`` என்று பெயரிட்டதாகக் கருதினால்:

en: ``foo('#myseries')`` -- argument ``key`` is assigned the value ``'myseries'`` and the argument ``alternate`` is assigned the default value ``'series'``.
ta: `` foo ('#myseries') `` - உரையாடல் `` key`` மதிப்பு `` 'myseries'`` மற்றும் `` மாற்று`` இயல்புநிலை மதிப்பு ``' தொடர்'````````` ' .

en: ``foo('series', '#genre')`` the variable ``key`` is assigned the value ``'series'`` and the variable ``alternate`` is assigned the value ``'#genre'``.
ta: `` foo ('தொடர்', '#genre') `` `மாறி` `key`` மதிப்பை` `'தொடர்'`` மற்றும்` `மாற்று`` என்ற மதிப்பை ஒதுக்கப்படுகிறது` `#genre '``.

en: ``foo()`` -- the variable ``key`` is assigned the empty string and the variable ``alternate`` is assigned the value ``'series'``.
ta: `` foo () `` - மாறி `` key`` வெற்று சரம் ஒதுக்கப்படுகிறது மற்றும் `` மாற்று`` என்ற மாறி `` 'தொடர்'`` என்ற மதிப்பை ஒதுக்குகிறது.

en: In PTM the arguments are passed in the ``arguments`` parameter, which is a list of strings. There isn't any way to specify default values. You must check the length of the ``arguments`` list to be sure that the number of arguments is what you expect.
ta: ptm இல் வாதங்கள் `` வாதங்கள்` `அளவுருவில் அனுப்பப்படுகின்றன, இது சரங்களின் பட்டியல். இயல்புநிலை மதிப்புகளைக் குறிப்பிட எந்த வழியும் இல்லை. வாதங்களின் எண்ணிக்கை நீங்கள் எதிர்பார்ப்பது என்பதை உறுதிப்படுத்த `` வாதங்கள்` பட்டியலின் நீளத்தை நீங்கள் சரிபார்க்க வேண்டும்.

en: An easy way to test stored templates is using the ``Template tester`` dialog. For ease of access give it a keyboard shortcut in :guilabel:`Preferences->Advanced->Keyboard shortcuts->Template tester`. Giving the ``Stored templates`` dialog a shortcut will help switching more rapidly between the tester and editing the stored template's source code.
ta: சேமிக்கப்பட்ட வார்ப்புருக்களை சோதிக்க ஒரு எளிதான வழி `` வார்ப்புரு சோதனையாளர்` உரையாடலைப் பயன்படுத்துகிறது. அணுகலின் எளிமைக்கு இதற்கு ஒரு விசைப்பலகை குறுக்குவழியைக் கொடுங்கள்: கிலாபெல்: `விருப்பத்தேர்வுகள்-> மேம்பட்ட-> விசைப்பலகை குறுக்குவழிகள்-> வார்ப்புரு சோதனையாளர்`. `` சேமிக்கப்பட்ட வார்ப்புருக்கள்` `உரையாடலை ஒரு குறுக்குவழியைக் கொடுப்பது சோதனையாளருக்கு இடையில் விரைவாக மாறவும், சேமிக்கப்பட்ட வார்ப்புருவின் மூலக் குறியீட்டைத் திருத்தவும் உதவும்.

en: Providing additional information to templates
ta: வார்ப்புருக்களுக்கு கூடுதல் தகவல்களை வழங்குதல்

en: A developer can choose to pass additional information to the template processor, such as application-specific book metadata or information about what the processor is being asked to do. A template can access this information and use it during the evaluation.
ta: பயன்பாட்டு-குறிப்பிட்ட புத்தக மேனிலை தரவு போன்ற வார்ப்புரு செயலிக்கு கூடுதல் தகவல்களை அனுப்ப ஒரு உருவாக்குபவர் தேர்வு செய்யலாம் அல்லது செயலி என்ன செய்யக் கேட்கப்படுகிறது என்பது பற்றிய தகவல்கள். ஒரு வார்ப்புரு இந்த தகவலை அணுகலாம் மற்றும் மதிப்பீட்டின் போது அதைப் பயன்படுத்தலாம்.

en: **Developer: how to pass additional information**
ta: ** டெவலப்பர்: கூடுதல் தகவல்களை எவ்வாறு அனுப்புவது **

en: The additional information is a Python dictionary containing pairs ``variable_name: variable_value`` where the values must be strings. The template can access the dictionary, creating template local variables named ``variable_name`` containing the value ``variable_value``. The user cannot change the name so it is best to use names that won't collide with other template local variables, for example by prefixing the name with an underscore.
ta: கூடுதல் தகவல்கள் `` மாறி_பெயர்: மாறி_ மதிப்புள்ள சோடிகளைக் கொண்ட பைதான் அகராதி ஆகும், அங்கு மதிப்புகள் சரங்களாக இருக்க வேண்டும். வார்ப்புரு அகராதியை அணுகலாம், `` variang_value`` மதிப்பைக் கொண்ட `` varian_name`` என்ற பெயரிடப்பட்ட வார்ப்புரு உள்ளக மாறிகள் உருவாக்கலாம். பயனரால் பெயரை மாற்ற முடியாது, எனவே பிற வார்ப்புரு உள்ளக மாறிகளுடன் மோதாத பெயர்களைப் பயன்படுத்துவது சிறந்தது, எடுத்துக்காட்டாக பெயரை அடிக்கோடிட்டுக் காட்டுவதன் மூலம்.

en: This dictionary is passed to the template processor (the ``formatter``) using the named parameter ``global_vars=your_dict``. The full method signature is::
ta: இந்த அகராதி பெயரிடப்பட்ட அளவுருவைப் பயன்படுத்தி `` உலகளாவிய_வார்ச் = உங்கள்_டிக்ட்`` ஐப் பயன்படுத்தி வார்ப்புரு செயலிக்கு (`` ஃபார்மேட்டர்``) அனுப்பப்படுகிறது. முழு முறை கையொப்பம் ::

en: **Template writer: how to access the additional information**
ta: ** வார்ப்புரு எழுத்தாளர்: கூடுதல் தகவல்களை எவ்வாறு அணுகுவது **

en: You access the additional information (the ``globals`` dictionary) in a template using the template function::
ta: வார்ப்புரு செயல்பாட்டைப் பயன்படுத்தி ஒரு வார்ப்புருவில் கூடுதல் தகவலை (`` குளோபல்ச்` அகராதி) அணுகலாம் ::

en: where ``id`` is any legal variable name. This function checks whether the additional information provided by the developer contains the name. If it does then the function assigns the provided value to a template local variable with that name. If the name is not in the additional information and if an ``expression`` is provided, the ``expression`` is evaluated and the result is assigned to the local variable. If neither a value nor an expression is provided, the function assigns the empty string (``''``) to the local variable.
ta: `` ஐடி`` என்பது ஏதேனும் சட்டப்பூர்வ மாறி பெயர். உருவாக்குபவர் வழங்கிய கூடுதல் தகவல்களில் பெயர் உள்ளதா என்பதை இந்த செயல்பாடு சரிபார்க்கிறது. அவ்வாறு செய்தால், செயல்பாடு அந்த பெயருடன் ஒரு வார்ப்புரு உள்ளக மாறிக்கு வழங்கப்பட்ட மதிப்பை ஒதுக்குகிறது. பெயர் கூடுதல் தகவலில் இல்லை என்றால், `` வெளிப்பாடு`` வழங்கப்பட்டால், `` வெளிப்பாடு`` மதிப்பீடு செய்யப்பட்டு, இதன் விளைவாக உள்ளக மாறிக்கு ஒதுக்கப்படுகிறது. ஒரு மதிப்பு அல்லது வெளிப்பாடு வழங்கப்படாவிட்டால், செயல்பாடு உள்ளக மாறிக்கு வெற்று சரத்தை (`` '' ``) ஒதுக்குகிறது.

en: A template can set a value in the ``globals`` dictionary using the template function::
ta: ஒரு வார்ப்புரு வார்ப்புரு செயல்பாட்டைப் பயன்படுத்தி `` குளோபல்ச்` `அகராதியில் ஒரு மதிப்பை அமைக்க முடியும் ::

en: This function sets the ``globals`` dictionary key:value pair ``id:value`` where ``value`` is the value of the template local variable ``id``. If that local variable doesn't exist then ``value`` is set to the result of evaluating ``expression``.
ta: இந்த செயல்பாடு `` குளோபல்ச்` அகராதி விசையை அமைக்கிறது: மதிப்பு இணை `` ஐடி: மதிப்பு`` அங்கு `` மதிப்பு`` என்பது வார்ப்புரு உள்ளக மாறியின் மதிப்பு `` ஐடி``. அந்த உள்ளக மாறி இல்லை என்றால், `` வெளிப்பாடு`` மதிப்பிடுவதன் விளைவாக `` மதிப்பு`.

en: Notes on the difference between modes
ta: முறைகளுக்கு இடையிலான வேறுபாடு குறித்த குறிப்புகள்

en: The three program modes, :ref:`Single Function Mode <single_mode>` (SFM), :ref:`Template Program Mode <template_mode>` (`TPM`), and :ref:`General Program Mode <general_mode>` (`GPM`), work differently. SFM is intended to be 'simple' so it hides a lot of programming language bits.
ta: மூன்று நிரல் முறைகள்,: குறிப்பு: `ஒற்றை செயல்பாட்டு பயன்முறை <ஒற்றை_மோட்>` (எச்.எஃப்.எம்),: குறிப்பு: `வார்ப்புரு நிரல் பயன்முறை <டெம்ப்ளேட்_மோட்>` (`டிபிஎம்`), மற்றும்: குறிப்பு:` பொது நிரல் பயன்முறை <பொது_மோட்> `( `சிபிஎம்`), வித்தியாசமாக வேலை செய்யுங்கள். எச்.எஃப்.எம் 'எளிமையானது' என்று கருதப்படுகிறது, எனவே இது நிறைய நிரலாக்க மொழி பிட்களை மறைக்கிறது.

en: Differences:
ta: வேறுபாடுகள்:

en: In SFM the value of the column is always passed as an 'invisible' first argument to a function included in the template.
ta: sfm இல், நெடுவரிசையின் மதிப்பு எப்போதும் வார்ப்புருவில் சேர்க்கப்பட்டுள்ள ஒரு செயல்பாட்டிற்கு 'கண்ணுக்கு தெரியாத' முதல் வாதமாக அனுப்பப்படுகிறது.

en: SFM doesn't support the difference between variables and strings; all values are strings.
ta: sfm மாறிகள் மற்றும் சரங்களுக்கு இடையிலான வேறுபாட்டை ஆதரிக்காது; அனைத்து மதிப்புகளும் சரங்கள்.

en: The following SFM template returns either the series name or the string "no series"::
ta: பின்வரும் sfm வார்ப்புரு தொடர் பெயர் அல்லது "தொடர் இல்லை" என்ற சரத்தை வழங்குகிறது ::

en: The equivalent template in `TPM` is ::
ta: `tpm` இல் சமமான வார்ப்புரு ::

en: The equivalent template in `GPM` is::
ta: `சி.பி.எம்` இல் சமமான வார்ப்புரு ::

en: The first argument to ``ifempty`` is the value of the field ``series``. The second argument is the string ``no series``. In SFM the first argument, the value of the field, is automatically passed (the invisible argument).
ta: `` ifempty`` க்கான முதல் உரையாடல் புலத்தின் மதிப்பு `` தொடர்``. இரண்டாவது உரையாடல் சரம் `` இல்லை தொடர்``. sfm இல் முதல் உரையாடல், புலத்தின் மதிப்பு தானாகவே அனுப்பப்படுகிறது (கண்ணுக்கு தெரியாத வாதம்).

en: Several template functions, for example ``booksize()`` and ``current_library_name()``, take no arguments. Because of the 'invisible argument' you cannot use these functions in SFM.
ta: பல வார்ப்புரு செயல்பாடுகள், எடுத்துக்காட்டாக `` புத்தகங்களை () `` மற்றும் `` நடப்பு_லிபரி_பேம் () ``, எந்த வாதங்களும் எடுக்கவில்லை. 'கண்ணுக்கு தெரியாத உரையாடல்' காரணமாக இந்த செயல்பாடுகளை sfm இல் பயன்படுத்த முடியாது.

en: Nested functions, where a function calls another function to compute an argument, cannot be used in SFM. For example this template, intended to return the first 5 characters of the series value uppercased, won't work in SFM::
ta: ஒரு வாதத்தை கணக்கிட மற்றொரு செயல்பாட்டை ஒரு செயல்பாடு அழைக்கும் உள்ளமைக்கப்பட்ட செயல்பாடுகள், sfm இல் பயன்படுத்த முடியாது. எடுத்துக்காட்டாக, இந்த வார்ப்புரு, தொடர் மதிப்பின் முதல் 5 எழுத்துக்களைத் திருப்பித் தரும் நோக்கம் கொண்டது, sfm இல் வேலை செய்யாது ::

en: `TPM` and `GPM` support nested functions. The above template in `TPM` would be::
ta: `tpm` மற்றும்` gpm` ஆகியவை உள்ளமைக்கப்பட்ட செயல்பாடுகளை ஆதரிக்கின்றன. `tpm` இல் உள்ள வார்ப்புரு ::

en: In `GPM` it would be::
ta: `சிபிஎம்` இல் ::

en: As noted in the above :ref:`Template Program Mode <template_mode>` section, using ``{`` and ``}`` characters in `TPM` string literals can lead to errors or unexpected results because they confuse the template processor. It tries to treat them as template boundaries, not characters. In some but not all cases you can replace a ``{`` with ``[[`` and a ``}`` with `]]`. Generally, if your program contains ``{`` and ``}`` characters then you should use `General Program Mode`.
ta: மேலே குறிப்பிட்டுள்ளபடி: ref: `வார்ப்புரு நிரல் பயன்முறை <template_mode>` பிரிவு, `` {`` மற்றும் ``} `` `டிபிஎம்` சரம் இலக்கிய எழுத்துக்கள் பிழைகள் அல்லது எதிர்பாராத முடிவுகளுக்கு வழிவகுக்கும், ஏனெனில் அவை வார்ப்புரு செயலி குழப்பத்தை ஏற்படுத்துகின்றன . இது அவர்களை வார்ப்புரு எல்லைகளாக கருத முயற்சிக்கிறது, எழுத்துக்கள் அல்ல. சில ஆனால் எல்லா நிகழ்வுகளிலும் நீங்கள் ஒரு `` `` `[` `மற்றும் ஒரு` `}` ``] `உடன் மாற்றலாம். பொதுவாக, உங்கள் நிரலில் `` {`` மற்றும் ``} `` எழுத்துக்கள் இருந்தால், நீங்கள் `பொது நிரல் பயன்முறையை` பயன்படுத்த வேண்டும்.

en: User-defined Python template functions
ta: பயனர் வரையறுக்கப்பட்ட பைதான் வார்ப்புரு செயல்பாடுகள்

en: You can add your own Python functions to the template processor. Such functions can be used in any of the three template programming modes. The functions are added by going to :guilabel:`Preferences -> Advanced -> Template functions`. Instructions are shown in that dialog. Note that you can use `Python Templates` for a similar purpose. As calling user-defined functions is faster than calling a Python template, user-defined functions might be more efficient depending on the complexity of what the function or template does.
ta: உங்கள் சொந்த பைதான் செயல்பாடுகளை வார்ப்புரு செயலியில் சேர்க்கலாம். இத்தகைய செயல்பாடுகளை மூன்று வார்ப்புரு நிரலாக்க முறைகளில் பயன்படுத்தலாம். செல்வதன் மூலம் செயல்பாடுகள் சேர்க்கப்படுகின்றன: கிலாபெல்: `விருப்பத்தேர்வுகள் -> மேம்பட்ட -> வார்ப்புரு செயல்பாடுகள்`. அந்த உரையாடலில் வழிமுறைகள் காட்டப்பட்டுள்ளன. இதேபோன்ற நோக்கத்திற்காக நீங்கள் `பைதான் வார்ப்புருக்கள்` பயன்படுத்தலாம் என்பதை நினைவில் கொள்க. பைதான் வார்ப்புருவை அழைப்பதை விட பயனர் வரையறுக்கப்பட்ட செயல்பாடுகளை அழைப்பது வேகமானது என்பதால், செயல்பாடு அல்லது வார்ப்புரு என்ன செய்கிறது என்பதன் சிக்கலைப் பொறுத்து பயனர் வரையறுக்கப்பட்ட செயல்பாடுகள் மிகவும் திறமையானதாக இருக்கலாம்.

en: Special notes for save/send templates
ta: வார்ப்புருக்கள் சேமிக்க/அனுப்ப சிறப்பு குறிப்புகள்

en: For example, assume we want the folder structure `series/series_index - title`, with the caveat that if series does not exist, then the title should be in the top folder. The template to do this is::
ta: எடுத்துக்காட்டாக, `தொடர்/தொடர்_இண்டெக்ச் - தலைப்பு` என்ற கோப்புறை அமைப்பு வேண்டும் என்று வைத்துக் கொள்ளுங்கள், தொடர் இல்லை என்றால், தலைப்பு சிறந்த கோப்புறையில் இருக்க வேண்டும். இதைச் செய்வதற்கான வார்ப்புரு ::

en: The slash and the hyphen appear only if series is not empty.
ta: தொடர் காலியாக இல்லாவிட்டால் மட்டுமே ச்லாச் மற்றும் ஐபன் தோன்றும்.

en: The lookup function lets us do even fancier processing. For example, assume that if a book has a series, then we want the folder structure `series/series index - title.fmt`. If the book does not have a series then we want the folder structure `genre/author_sort/title.fmt`. If the book has no genre then we want to use 'Unknown'. We want two completely different paths, depending on the value of series.
ta: தேடல் செயல்பாடு ஆர்வமுள்ள செயலாக்கத்தை கூட செய்ய அனுமதிக்கிறது. எடுத்துக்காட்டாக, ஒரு புத்தகத்தில் ஒரு தொடர் இருந்தால், கோப்புறை கட்டமைப்பை `தொடர்/தொடர் குறியீட்டு - title.fmt` வேண்டும் என்று வைத்துக் கொள்ளுங்கள். புத்தகத்தில் ஒரு தொடர் இல்லையென்றால், `வகை/எழுத்தாளர்_சார்ட்/தலைப்பு. fmt` என்ற கோப்புறை கட்டமைப்பை நாங்கள் விரும்புகிறோம். புத்தகத்தில் எந்த வகையும் இல்லை என்றால், நாம் 'தெரியாத' பயன்படுத்த விரும்புகிறோம். தொடரின் மதிப்பைப் பொறுத்து இரண்டு முற்றிலும் மாறுபட்ட பாதைகளை நாங்கள் விரும்புகிறோம்.

en: To accomplish this, we:
ta: இதை நிறைவேற்ற, நாங்கள்:

en: Create a composite field (give it lookup name #aa) containing ``{series}/{series_index} - {title}``. If the series is not empty, then this template will produce `series/series_index - title`.
ta: `` {series}/{series_index} - {title} `` ஆகியவற்றைக் கொண்ட ஒரு கலப்பு புலத்தை உருவாக்கவும் (#aa க்கு #aa ஐ கொடுங்கள்). தொடர் காலியாக இல்லாவிட்டால், இந்த வார்ப்புரு `தொடர்/தொடர்_இண்டெக்ச் - தலைப்பு` ஐ உருவாக்கும்.

en: Create a composite field (give it lookup name #bb) containing ``{#genre:ifempty(Unknown)}/{author_sort}/{title}``. This template produces `genre/author_sort/title`, where an empty genre is replaced with `Unknown`.
ta: `` {#genre: ifempty (அறியப்படாத)}/{author_sort}/{title} `` கொண்ட ஒரு கலப்பு புலத்தை உருவாக்கவும் (#bb க்கு #bb ஐ கொடுங்கள்) உருவாக்கவும். இந்த வார்ப்புரு `வகை/ஆசிரியர்_சார்ட்/தலைப்பு` ஐ உருவாக்குகிறது, அங்கு வெற்று வகை` தெரியாத` உடன் மாற்றப்படுகிறது.

en: Set the save template to ``{series:lookup(.,#aa,#bb)}``. This template chooses composite field ``#aa`` if series is not empty and composite field ``#bb`` if series is empty. We therefore have two completely different save paths, depending on whether or not `series` is empty.
ta: சேமி வார்ப்புருவை `` {தொடர்: தேடல் (.,#aa,#bb)} `` என அமைக்கவும். தொடர் காலியாக இல்லாவிட்டால் கலப்பு புலம் ``#aa`` ஐ தேர்வு செய்கிறது ``#பிபி`` தொடர் காலியாக இருந்தால். ஆகவே, `தொடர்` காலியாக உள்ளதா இல்லையா என்பதைப் பொறுத்து எங்களிடம் இரண்டு முற்றிலும் மாறுபட்ட சேமிப்பு பாதைகள் உள்ளன.

en: Tips
ta: உதவிக்குறிப்புகள்

en: Use the Template Tester to test templates. Add the tester to the context menu for books in the library and/or give it a keyboard shortcut.
ta: வார்ப்புருக்களை சோதிக்க வார்ப்புரு சோதனையாளரைப் பயன்படுத்தவும். நூலகத்தில் உள்ள புத்தகங்களுக்கான சூழல் பட்டியலில் சோதனையாளரைச் சேர்த்து/அல்லது விசைப்பலகை குறுக்குவழியைக் கொடுங்கள்.

en: Templates can use other templates by referencing composite columns built with the desired template. Alternatively, you can use Stored Templates.
ta: விரும்பிய வார்ப்புருவுடன் கட்டமைக்கப்பட்ட கலப்பு நெடுவரிசைகளைக் குறிப்பிடுவதன் மூலம் வார்ப்புருக்கள் பிற வார்ப்புருக்களைப் பயன்படுத்தலாம். மாற்றாக, நீங்கள் சேமிக்கப்பட்ட வார்ப்புருக்களைப் பயன்படுத்தலாம்.

en: In a plugboard, you can set a field to empty (or whatever is equivalent to empty) by using the special template ``{}``. This template will always evaluate to an empty string.
ta: ஒரு பிளக் போர்டில், சிறப்பு வார்ப்புருவைப் பயன்படுத்தி `{}` `` பயன்படுத்துவதன் மூலம் ஒரு புலத்தை காலியாக (அல்லது காலியாக எதுவுமில்லை) அமைக்கலாம். இந்த வார்ப்புரு எப்போதும் வெற்று சரத்திற்கு மதிப்பீடு செய்யும்.

en: The technique described above to show numbers even if they have a zero value works with the standard field series_index.
ta: எண்களைக் காட்ட மேலே விவரிக்கப்பட்ட நுட்பம் சுழிய மதிப்பு இருந்தாலும் அவை நிலையான புலம் தொடர்_இண்டெக்சுடன் வேலை செய்கின்றன.

en: Template function reference
ta: வார்ப்புரு செயல்பாடு குறிப்பு
