calibre - en to nl translation catalogue (77 entries)

en: Writing your own plugins to extend calibre's functionality
nl: Uw eigen plugins schrijven om de functionaliteit van calibre uit te breiden

en: calibre has a very modular design. Almost all functionality in calibre comes in the form of plugins. Plugins are used for conversion, for downloading news (though these are called recipes), for various components of the user interface, to connect to different devices, to process files when adding them to calibre and so on. You can get a complete list of all the built-in plugins in calibre by going to :guilabel:`Preferences->Advanced->Plugins`.
nl: calibre heeft een zeer modulair ontwerp. Bijna alle functionaliteit in calibre komt als plug-ins. Plug-ins voor conversie, downloaden van nieuws (recepten genaamd), verschillende componenten van de gebruikersinterface, verbinding maken met verschillende toestellen, bestanden verwerken bij toevoegen aan calibre enz. U vidnt een volledige lijst van ingebouwde plug-ins in calibre op: guilabel: `Voorkeuren-> Geavanceerd-> Plug-ins 'te gaan.

en: Here, we will teach you how to create your own plugins to add new features to calibre.
nl: Hier laten we zien hoe u uw eigen plugins kunt maken om nieuwe functies toe te voegen aan calibre.

en: Contents
nl: Inhoud

en: This only applies to calibre releases >= 0.8.60
nl: Dit is enkel van toepassing op calibre releases >= 0.8.60

en: Anatomy of a calibre plugin
nl: Opbouw van een calibre plugin

en: A calibre plugin is very simple, it's just a ZIP file that contains some Python code and any other resources like image files needed by the plugin. Without further ado, let's see a basic example.
nl: Een calibre plug-in is heel eenvoudig, gewoon een ZIP-bestand dat wat Python code bevat en andere bronnen zoals afbeelding die de plug-in nodig heeft. Genoeg, laten we een eenvoudig voorbeeld bekijken.

en: Suppose you have an installation of calibre that you are using to self publish various e-documents in EPUB and MOBI formats. You would like all files generated by calibre to have their publisher set as "Hello world", here's how to do it. Create a file named :file:`__init__.py` (this is a special name and must always be used for the main file of your plugin) and enter the following Python code into it:
nl: Stel, u heeft calibre geïnstalleerd om diverse e-documenten zelf te publiceren in EPUB en MOBI-formaten. U wilt dat alle bestanden gegenereerd door calibre als uitgever "Hello world" hebben, hier volgt hoe dit te doen. Maak een bestand genaamd :file:`__init__.py` (dit is een speciale naam en moet altijd gebruikt worden voor het hoofdbestand van uw plugin) en geef de volgende Python code in:

en: That's all. To add this code to calibre as a plugin, simply run the following in the folder in which you created :file:`__init__.py`::
nl: Dat is alles. Om deze code als plug-in aan calibre toe te voegen, voer het volgende uit in de map waar u :file:`__init__.py`:: creëerde

en: On macOS, the command line tools are inside the calibre bundle, for example, if you installed calibre in :file:`/Applications` the command line tools are in :file:`/Applications/calibre.app/Contents/MacOS/`.
nl: Op macOS bevinden de commandoregelprogramma's zich in de calibre-bundel, bijvoorbeeld, als u calibre hebt geïnstalleerd in :file:`/Applications` bevinden de commandoregelprogramma's zich in :file:`/Applications/calibre.app/Contents/MacOS/`.

en: You can download the Hello World plugin from :download_file:`helloworld_plugin.zip`.
nl: U kan de Hello World plugin downloaden van :download_file:`helloworld_plugin.zip`.

en: Every time you use calibre to convert a book, the plugin's :meth:`run` method will be called and the converted book will have its publisher set to "Hello World". This is a trivial plugin, lets move on to a more complex example that actually adds a component to the user interface.
nl: Elke keer u calibre gebruikt om een boek te converteren, wordt de plugin's :meth:`run` methode geroepen en het geconverteerde boek heeft als uitgever "Hello World". Dit is een banale plugin, op naar een ingewikkelder voorbeeld dat daadwerkelijk een component toevoegt aan de gebruikersinterface.

en: A User Interface plugin
nl: Een Gebruikersinterface plugin

en: This plugin will be spread over a few files (to keep the code clean). It will show you how to get resources (images or data files) from the plugin ZIP file, allow users to configure your plugin, how to create elements in the calibre user interface and how to access and query the books database in calibre.
nl: Deze plug-in zal bestaan uit een paar bestanden (om de code schoon te houden). Het toont u hoe bronnen (afbeeldingen of databestanden) op te halen uit de plug-in's ZIP , gebruikers toe te staan uw plug-in in te stellen, elementen in de gebruikersinterface voor calibre te maken en de database voor boeken te raadplegen en doorzoeken.

en: You can download this plugin from :download_file:`interface_demo_plugin.zip`
nl: U kan deze plugin downloaden van :download_file:`interface_demo_plugin.zip`

en: The first thing to note is that this ZIP file has a lot more files in it, explained below, pay particular attention to ``plugin-import-name-interface_demo.txt``.
nl: Het eerste ding om op te merken is dat dit ZIP bestand veel meer bestanden bevat, onder uitgelegd, let extra op ``plugin-import-name-interface_demo.txt``.

en: An empty text file used to enable the multi-file plugin magic. This file must be present in all plugins that use more than one .py file. It should be empty and its filename must be of the form: ``plugin-import-name-**some_name**.txt``. The presence of this file allows you to import code from the .py files present inside the ZIP file, using a statement like::
nl: Een leeg tekstbestand om de multi-file plugin magie in te schakelen. Dit bestand moet aanwezig zijn in alle plug-ins die meer dan één .py bestand gebruiken. Het moet leeg zijn en de bestandsnaam moet volgende vorm hebben: `` plugin-import-name-**een_naam **.txt``. Met dit bestand kunt u code importeren uit de .py bestanden in het ZIP-bestand , met behulp van een statement als::

en: The prefix ``calibre_plugins`` must always be present. ``some_name`` comes from the filename of the empty text file. ``some_module`` refers to  :file:`some_module.py` file inside the ZIP file. Note that this importing is just as powerful as regular Python imports. You can create packages and subpackages of .py modules inside the ZIP file, just like you would normally (by defining __init__.py in each sub-folder), and everything should "just work".
nl: De prefix ``calibre_plugins`` moet altijd aanwezig zijn. ``some_name`` komt van de naam van het lege tekst bestand. ``some_module`` verwijst naar :file:`some_module.py` in het ZIP bestand. Merk op dat deze import even machtig is als gewone Python imports. U kan packages en subpackages van .py modules creëren in het ZIP bestand, net zoals u normaal zou doen (door __init__.py te definiëren in elke submap) en alles zou "moeten werken".

en: The name you use for ``some_name`` enters a global namespace shared by all plugins, **so make it as unique as possible**. But remember that it must be a valid Python identifier (only alphabets, numbers and the underscore).
nl: De naam die u gebruikt voor ``some_name`` gaat in een algemene naamruimte, gedeeld door alle plug-ins, **dus maak deze zo uniek mogelijk**. Maar vergeet niet dat het een geldig Python-id moet zijn (alleen alfabetten, cijfers en het onderliggend streepje).

en: As before, the file that defines the plugin class
nl: Zoals hiervoor, het bestand dat de plugin's klasse definieert

en: This file contains the actual code that does something useful
nl: Dit bestand bevat de daadwerkelijke code die iets nuttigs doet

en: This file defines the interface part of the plugin
nl: Dit bestand definieert de interface van de plugin

en: The icon for this plugin
nl: Het icoon voor deze plugin

en: A text file with information about the plugin
nl: Een tekstbestand met informatie over de plugin

en: **translations**
nl: **vertalingen**

en: A folder containing .mo files with the translations of the user interface of your plugin into different languages. See below for details.
nl: Een map die .mo-bestanden bevat met vertalingen van de gebruikersinterface van uw plug-in in verschillende talen. Zie onder voor details.

en: Now let's look at the code.
nl: Laten we naar de code kijken.

en: First, the obligatory ``__init__.py`` to define the plugin metadata:
nl: Eerst de verplichte ``__init__.py`` om de plug-in's metadata te definiëren:

en: The only noteworthy feature is the field :attr:`actual_plugin`. Since calibre has both command line and GUI interfaces, GUI plugins like this one should not load any GUI libraries in __init__.py. The actual_plugin field does this for you, by telling calibre that the actual plugin is to be found in another file inside your ZIP archive, which will only be loaded in a GUI context.
nl: De enige noemenswaardige eigenschap is het veld: attr:`actual_plugin`. Omdat calibre zowel opdrachtregel als GUI interfaces heeft, mogen GUI plug-ins zoals deze geen enkele GUI-bibliotheek laden in __init__.py . Het veld actual_plugin doet dit voor u, door calibre te zeggen dat de daadwerkelijke plugin in een ander bestand in uw ZIP archief te vinden is, dat alleen in een GUI context wordt geladen.

en: Remember that for this to work, you must have a plugin-import-name-some_name.txt file in your plugin ZIP file, as discussed above.
nl: Vergeet niet dat om dit te laten werken, u een plugin-import-name-een_naam.txt bestand nodig hebt in uw ZIP plug-in, zoals boven besproken.

en: Also there are a couple of methods for enabling user configuration of the plugin. These are discussed below.
nl: Er zijn meerdere methoden om gebruikersconfiguratie van de plug-in mogelijk te maken. Deze worden onder besproken.

en: Now let's look at ui.py which defines the actual GUI plugin. The source code is heavily commented and should be self explanatory:
nl: Laten we nu ui.py bekijken dat de eigenlijke GUI plug-in definieert. De broncode is voorzien van commentaar en zou zichzelf moeten verklaren:

en: The actual logic to implement the Interface Plugin Demo dialog.
nl: De eigenlijke logica om de Interface Plugin Demo dialoog te implementeren.

en: Getting resources from the plugin ZIP file
nl: Ophalen bronnen uit het plug-in ZIP bestand

en: calibre's plugin loading system defines a couple of built-in functions that allow you to conveniently get files from the plugin ZIP file.
nl: calibres plug-in laadsysteem definieert een aantal ingebouwde functies waarmee u gemakkelijk bestanden kunt ophalen uit het plug-in ZIP bestand.

en: A wrapper for get_resources() that creates QIcon objects from the raw bytes returned by get_resources. If a name is not found in the ZIP file the corresponding QIcon will be null. In order to support icon theme-ing, pass in the human friendly name of your plugin as ``plugin_name``. If the user is using an icon theme with icons for your plugin, they will be loaded preferentially.
nl: Een wrapper voor get_resources() die QIcon objecten creëert van de rauwe bytes vanuit get_resources. Werd een naam niet gevonden in het ZIP bestand, zal de overeenkomende QIcon null zijn. Om icoon theme-ing te ondersteunen, geef de mensvriendelijke naam van uw plug-in in als ``plugin_name``. Als de gebruiker een icoonthema gebruikt met iconen voor uw plug-in, worden deze bij voorkeur geladen .

en: Enabling user configuration of your plugin
nl: Gebruikers-configuratie van uw plugin inschakelen

en: To allow users to configure your plugin, you must define three methods in your base plugin class, **is_customizable**, **config_widget** and **save_settings** as shown below:
nl: Om gebruikers uw plug-in te laten configureren, moet u drie methoden in uw basis plug-inklasse definiëren, ** is_customizable **, ** config_widget ** en ** save_settings ** zoals onder weergegeven:

en: calibre has many different ways to store configuration data (a legacy of its long history). The recommended way is to use the **JSONConfig** class, which stores your configuration information in a .json file.
nl: calibre heeft vele manieren om configuratiegegevens te bewaren (een erfenis van lange geschiedenis). De aanbevolen manier is het gebruik van de **JSONConfig** klasse, die de informatie bewaart in een .json bestand.

en: The code to manage configuration data in the demo plugin is in config.py:
nl: De code om configuratiegegevens te beheren in de demoplug-in is in config.py:

en: The ``prefs`` object is now available throughout the plugin code by a simple::
nl: Het ``prefs`` object is nu beschikbaar in de plug-incode met een simpele::

en: You can see the ``prefs`` object being used in main.py:
nl: U kunt het gebruik van ``prefs``-object zien in main.py:

en: Edit book plugins
nl: Boek plug-ins bewerken

en: Now let's change gears for a bit and look at creating a plugin to add tools to the calibre book editor. The plugin is available here: :download_file:`editor_demo_plugin.zip`.
nl: Laten we wat hoger schakelen en een plug-in creëren om tools toe te voegen aan de calibre boekeditor. De plug-in is hier beschikbaar: :download_file:`editor_demo_plugin.zip`.

en: The first step, as for all plugins is to create the import name empty txt file, as described :ref:`above <import_name_txt>`. We shall name the file ``plugin-import-name-editor_plugin_demo.txt``.
nl: De eerste stap, zoals voor alle plug-ins, is het maken van het lege import name .txt bestand zoals :ref:`above <import_name_txt>` beschreven. We noemen het bestand ``plugin-import-name-editor_plugin_demo.txt``.

en: Now we create the mandatory ``__init__.py`` file that contains metadata about the plugin -- its name, author, version, etc.
nl: Nu maken we het verplichte bestand ``__init__.py`` waarin de metadata over de plug-in staan -- zijn naam, maker, versie enz.

en: A single editor plugin can provide multiple tools each tool corresponds to a single button in the toolbar and entry in the :guilabel:`Plugins` menu in the editor. These can have sub-menus in case the tool has multiple related actions.
nl: Een enkel editorplug-in kan meerdere tools leveren, iedere tool correspondeert met een knop in de werkbalk en trefwoord in het :guilabel:`Plug-ins` menu in de editor. Deze kunnen sub-menu's hebben indien de tool meerdere acties heeft.

en: The tools must all be defined in the file ``main.py`` in your plugin. Every tool is a class that inherits from the :class:`calibre.gui2.tweak_book.plugin.Tool` class. Let's look at ``main.py`` from the demo plugin, the source code is heavily commented and should be self-explanatory. Read the API documents of the :class:`calibre.gui2.tweak_book.plugin.Tool` class for more details.
nl: De tools moeten allemaal gedefinieerd zijn in het bestand ``main.py`` in uw plugin. Iedere tool is een class, die erft van de :class:`calibre.gui2.tweak_book.plugin.Tool` class. Laten we een kijkje nemen in ``main.py`` van de demoplug-in, de broncode is voorzien van commentaar en zou zichzelf moeten verklaren. Lees de API-documenten van de :class:`calibre.gui2.tweak_book.plugin.Tool` class voor meer details.

en: Here we will see the definition of a single tool that will multiply all font sizes in the book by a number provided by the user. This tool demonstrates various important concepts that you will need in developing your own plugins, so you should read the (heavily commented) source code carefully.
nl: Hier zien we de definitie van een enkele tool dat alle lettergroottes in het boek vermenigvuldigt met een getal ingesteld door de gebruiker. Deze tool demonstreert meerdere belangrijke concepten die u nodig heeft om uw eigen plug-in te ontwikkelen. Lees daarom de (goed van commentaar voorziene) broncode grondig.

en: Let's break down ``main.py``. We see that it defines a single tool, named *Magnify fonts*. This tool will ask the user for a number and multiply all font sizes in the book by that number.
nl: Laten we ``main.py`` bekijken. We zien dat een enkele tool wordt gedefinieerd, *Magnify fonts*. Hij vraagt de gebruiker een getal en vermenigvuldigt alle lettergroottes in het boek met dit getal.

en: The first important thing is the tool name which you must set to some relatively unique string as it will be used as the key for this tool.
nl: Het eerste belangrijke ding is de naam van de tool die een redelijk unieke tekenreeks moet zijn, deze wordt gebruikt als sleutel voor dit gereedschap.

en: The next important entry point is the :meth:`calibre.gui2.tweak_book.plugin.Tool.create_action`. This method creates the QAction objects that appear in the plugins toolbar and plugin menu. It also, optionally, assigns a keyboard shortcut that the user can customize. The triggered signal from the QAction is connected to the ask_user() method that asks the user for the font size multiplier, and then runs the magnification code.
nl: Het volgende belangrijke punt is :meth:`calibre.gui2.tweak_book.plugin.Tool.create_action`. Deze methode maakt de QAction objecten die op de plug-inwerkbalk en het plug-inmenu verschijnen. Optioneel wordt ook een sneltoets toegewezen die de gebruiker kan aanpassen. Het getriggerde signaal van de QAction is verbonden met de ask_user() methode die de gebruiker vraagt naar de lettergrootte vergrotingsfactor en vervolgens de vergrotingscode uitvoert.

en: The magnification code is well commented and fairly simple. The main things to note are that you get a reference to the editor window as ``self.gui`` and the editor *Boss* as ``self.boss``. The *Boss* is the object that controls the editor user interface. It has many useful methods, that are documented in the :class:`calibre.gui2.tweak_book.boss.Boss` class.
nl: De vergrotingscode is goed becommentarieerd en vrij eenvoudig. De belangrijkste dingen om op te merken zijn dat u een verwijzing naar het editorvenster krijgt als ``self.gui`` en de editor *Boss* als ``self.boss``. De *Boss* is het object dat de gebruikersinterface van de editor bestuurt. Het heeft veel nuttige methoden, die zijn gedocumenteerd in de klasse :class:`calibre.gui2.tweak_book.boss.Boss`.

en: Finally, there is ``self.current_container`` which is a reference to the book being edited as a :class:`calibre.ebooks.oeb.polish.container.Container` object. This represents the book as a collection of its constituent HTML/CSS/image files and has convenience methods for doing many useful things. The container object and various useful utility functions that can be reused in your plugin code are documented in :ref:`polish_api`.
nl: Tenslotte is er ``self.current_container'', een verwijzing naar het boek dat wordt bewerkt als :class:`calibre.ebooks.oeb.polish.container.Container` object. Dit stelt het boek voor als een verzameling van z'n samenstellende HTML/CSS/afbeeldingsbestanden en heeft handige methoden om veel nuttige dingen te doen. Het containerobject en verschillende handige hulpprogramma's die kunnen worden herbruikt in uw plug-incode zijn gedocumenteerd in :ref: `polish_api`.

en: Adding translations to your plugin
nl: Vertalingen toevoegen aan uw plugin

en: You can have all the user interface strings in your plugin translated and displayed in whatever language is set for the main calibre user interface.
nl: U kunt de teksten in het gebruikersinterface in uw plugin laten vertalen in elke taal die is ingesteld voor de calibre gebruikersinterface.

en: The first step is to go through your plugin's source code and mark all user visible strings as translatable, by surrounding them in _(). For example::
nl: De eerste stap is door uw plug-in's broncodes te gaan en alle voor gebruikers zichtbare teksten te markeren als vertaalbaar door ze te omgeven met _(). Bijvoorbeeld::

en: Then use some program to generate .po files from your plugin source code. There should be one .po file for every language you want to translate into. For example: de.po for German, fr.po for French and so on. You can use the `Poedit <https://poedit.net/>`_ program for this.
nl: Gebruik dan een programma om .po bestanden te genereren uit uw plug-in's broncode . Er moet één .po-bestand zijn voor elke taal waarin u wilt vertalen. Bijvoorbeeld: nl.po voor Nederlands, fr.po voor Frans enzovoort. U kunt hiervoor het `Poedit <https://poedit.net/>`_program gebruiken.

en: Send these .po files to your translators. Once you get them back, compile them into .mo files. You can again use Poedit for that, or just do::
nl: Stuur deze .po-bestanden naar uw vertalers. Zodra u ze terug krijgt, compileer ze in .mo-bestanden. U kunt opnieuw Poedit daarvoor gebruiken, of doe gewoon:

en: Put the .mo files into the ``translations`` folder in your plugin.
nl: Plaats de .mo-bestanden in de ``vertalingen``-map in uw plug-in.

en: The last step is to simply call the function `load_translations()` at the top of your plugin's .py files. For performance reasons you should only call this function in those .py files that actually have translatable strings. So in a typical User Interface plugin you would call it at the top of ``ui.py`` but not ``__init__.py``.
nl: De laatste stap is om gewoon de functie `load_translations()` te roepen bovenaan uw plugin's .py bestanden. Voor prestatie redenen deze functie alleen aanroepen in die .py-bestanden die echt vertaalbare teksten bevatten. Dus in een normale Gebruikersinterfaceplug-in roept u deze functie aan bovenin ``ui.py`` maar niet in ``__init__.py``.

en: You can test the translations of your plugins by changing the user interface language in calibre under :guilabel:`Preferences->Interface->Look & feel` or by running calibre with the ``CALIBRE_OVERRIDE_LANG`` environment variable set. For example::
nl: U kunt de vertalingen van uw plug-ins testen door de taal van de gebruikersinterface in calibre te wijzigen onder :guilabel:`Voorkeuren->Interface->Uitstraling & gevoel` of door calibre uit te voeren met de ``CALIBRE_OVERRIDE_LANG`` omgevingsvariabele ingesteld. Voorbeeld::

en: Replace ``de`` with the language code of the language you want to test.
nl: Vervang ``de`` met de taalcode van de taal die u wilt testen.

en: The plugin API
nl: De plug-in API

en: As you may have noticed above, a plugin in calibre is a class. There are different classes for the different types of plugins in calibre. Details on each class, including the base class of all plugins can be found in :ref:`plugins`.
nl: Zoals u misschien heeft opgemerkt is een plug-in in calibre een class. Er zijn verschillende classes voor verschillende types plug-ins. Details van iedere class, inclusief de basis class van alle plugins zijn te vinden in :ref:`plugins`.

en: Your plugin is almost certainly going to use code from calibre. To learn how to find various bits of functionality in the calibre code base, read the section on the calibre :ref:`code_layout`.
nl: Uw plugin zal bijna zeker code gebruiken van calibre. Om te leren hoe u diverse stukjes functionaliteit vindt in de calibre code basis, lees de sectie over calibre's :ref:`code_layout`.

en: Debugging plugins
nl: Plug-ins foutopsporing

en: The first, most important step is to run calibre in debug mode. You can do this from the command line with::
nl: De eerste, belangrijkste stap is calibre draaien in foutenopsporingsmodus. U kunt dit doen in de opdrachtregel met::

en: Or from within calibre by right-clicking the :guilabel:`Preferences` button or using the :kbd:`Ctrl+Shift+R` keyboard shortcut.
nl: Of vanuit calibre door met de rechts te klikken op de :guilabel:`Preferences` knop of gebruik te maken van de :kbd:`Ctrl+Shift+R` sneltoets .

en: When running from the command line, debug output will be printed to the console, when running from within calibre the output will go to a txt file.
nl: Wanneer u werkt met de opdrachtregel verschijnt de foutoplossing op de console, wanneer u werkt in calibre zal dit naar een .txt-bestand worden geschreven.

en: You can insert print statements anywhere in your plugin code, they will be output in debug mode. Remember, this is Python, you really shouldn't need anything more than print statements to debug ;) I developed all of calibre using just this debugging technique.
nl: U kunt overal printinstructies invoegen in uw plug-incode, deze worden uitgevoerd in de foutopsporingsmodus. Vergeet niet, dit is Python, uzou echt niets meer nodig moeten hebben dan print commando's om te debuggen ;) Ik heb heel calibre ontwikkeld met alleen deze foutopsporingstechniek.

en: You can quickly test changes to your plugin by using the following command line::
nl: U kunt snel wijzigingen aan uw plugin testen met behulp van de volgende opdrachtregel::

en: This will shutdown a running calibre, wait for the shutdown to complete, then update your plugin in calibre and relaunch calibre.
nl: Dit sluit een lopende calibre af, wacht totdat het programma geheel afgesloten is, dan uw plugin updaten in calibre en calibre herstarten.

en: More plugin examples
nl: Meer voorbeelden van plugins

en: You can find a list of many sophisticated calibre plugins `here <https://www.mobileread.com/forums/showthread.php?t=118764>`_.
nl: U kan een lijst met gesofisticeerde calibre plug-ins vinden `hier <https://www.mobileread.com/forums/showthread.php?t=118764>`_.

en: Sharing your plugins with others
nl: Uw plugins delen met anderen

en: If you would like to share the plugins you have created with other users of calibre, post your plugin in a new thread in the `calibre plugins forum <https://www.mobileread.com/forums/forumdisplay.php?f=237>`_.
nl: Als u de plugins die u gemaakt hebt wilt delen met andere gebruikers van calibre, post ze onder een nieuw onderwerp in  `calibre plugins forum <https://www.mobileread.com/forums/forumdisplay.php?f=237>`_.
