# translation of nl.po to Dutch
# translation of fontconfig_2.2.1-16_nl.po to Dutch
#
#    Translators, if you are not familiar with the PO format, gettext
#    documentation is worth reading, especially sections dedicated to
#    this format, e.g. by running:
#         info -n '(gettext)PO Files'
#         info -n '(gettext)Header Entry'
#    Some information specific to po-debconf are available at
#            /usr/share/doc/po-debconf/README-trans
#         or http://www.debian.org/intl/l10n/po-debconf/README-trans#
#    Developers do not need to manually edit POT or PO files.
# Frans Pop <aragorn@tiscali.nl>, 2004.
#
msgid ""
msgstr ""
"Project-Id-Version: nl\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2005-03-29 13:33-0800\n"
"PO-Revision-Date: 2004-11-03 22:00+0100\n"
"Last-Translator: Frans Pop <aragorn@tiscali.nl>\n"
"Language-Team: Dutch <debian-l10n-dutch@lists.debian.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.3.1\n"

#. Type: select
#. Choices
#: ../fontconfig.templates:3
msgid "Native, Autohinter, None"
msgstr ""

#. Type: select
#. Description
#: ../fontconfig.templates:5
msgid "How should fonts be tuned for the screen?"
msgstr ""

#. Type: select
#. Description
#: ../fontconfig.templates:5
msgid ""
"Select Native if you mostly use Bitstream Vera (the default in Debian) or "
"any of the Microsoft fonts.  Select Autohinter if you mostly use other "
"TrueType fonts.  Select None if you want blurry text."
msgstr ""

#. Type: select
#. Choices
#: ../fontconfig.templates:12
msgid "Automatic, Always, Never"
msgstr ""

#. Type: select
#. Description
#: ../fontconfig.templates:14
msgid "Enable subpixel rendering of text?"
msgstr ""

#. Type: select
#. Description
#: ../fontconfig.templates:14
msgid ""
"Rendering text at a subpixel level generally makes it look a bit better on "
"flat (LCD) screens, but can show color artifacts on CRT screens. The "
"\"Automatic\" choice will enable it only if a LCD screen is detected."
msgstr ""

#. Type: boolean
#. Description
#: ../fontconfig.templates:22
msgid "Enable bitmapped fonts by default?"
msgstr "Bitmap-lettertypen standaard activeren?"

#. Type: boolean
#. Description
#: ../fontconfig.templates:22
msgid ""
"By default, only outline fonts are used by applications which support "
"fontconfig.  Outline fonts are fonts which scale well to various sizes.  In "
"contrast, bitmapped fonts are often lower quality. Enabling this option will "
"affect the systemwide default; this and many other fontconfig options may be "
"enabled or disabled on a per-user basis."
msgstr ""
"Standaard worden alleen 'outline' lettertypen gebruikt door applicaties die "
"fontconfig ondersteunen. 'Outline' lettertypen zijn lettertypen die goed "
"geschaald kunnen worden naar verschillende lettergroottes. Daarentegen zijn "
"'bitmapped' lettertypen vaak van een lagere kwaliteit; deze, en vele andere, "
"opties van fontconfig kunnen voor elke gebruiker afzonderlijk ingesteld "
"worden."

#, fuzzy
#~ msgid "With what method should fonts be hinted?"
#~ msgstr "Volgens welke methode moet tekst worden weergegeven?"

#~ msgid ""
#~ "Bytecode interpreter (CRT screens), Autohinter, Subpixel rendering (LCD "
#~ "screens)"
#~ msgstr ""
#~ "Bytecode interpreter (CRT-monitoren), Autohinter, Subpixel weergave (LCD-"
#~ "monitoren)"

#~ msgid ""
#~ "The Freetype font library is able to render fonts with different methods. "
#~ "Depending on your hardware and the fonts you generally use, some will "
#~ "give better results."
#~ msgstr ""
#~ "De Freetype lettertype-bibliotheek kan lettertypen weergeven volgens "
#~ "verschillende methoden. Afhankelijk van uw apparatuur en de lettertypen "
#~ "die u gewoonlijk gebruikt, kan de ene methode betere resultaten geven dan "
#~ "de andere."

#~ msgid ""
#~ "The autohinter module is the default; it gives correct results on most "
#~ "configurations. The bytecode interpreter renders fonts very sharply, and "
#~ "is often a better choice if you are using a cathode-ray screen. On the "
#~ "other hand, the subpixel rendering method is optimized for high-quality "
#~ "rendering on most liquid crystal displays."
#~ msgstr ""
#~ "De module 'autohinter' is de standaardwaarde; het geeft op de meeste "
#~ "configuraties een goed resultaat. De 'bytecode interpreter' geeft "
#~ "lettertypen zeer scherp weer en is vaak een betere keus als u een CRT-"
#~ "monitor heeft. De methode 'subpixel weergave' daarentegen is "
#~ "geoptimaliseerd voor weergave met hoge kwaliteit op LCD-monitor."
