# vimhelp: user manual: ch40:Make new commands
# Copyright (C) 1988-2006 Bram Moolenaar.
# This file is distributed under the same license as the vim documentation.
# Florian 'eix' Rehnisch <eixman@gmx.de>, 2009.
#
msgid ""
msgstr ""
"Project-Id-Version: vimhelp 7.2\n"
"POT-Creation-Date: 2010-11-21 17:54+0100\n"
"PO-Revision-Date: 2010-11-21 17:55+0100\n"
"Last-Translator: Florian 'eix' Rehnisch <eixman@gmx.de>\n"
"Language-Team: German <debian-l10n-german@lists.debian.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf8\n"
"Content-Transfer-Encoding: 8bit\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:2
#, no-wrap
msgid "*usr_40.txt*\tFor Vim version 7.3.  Last change: 2006 Jun 21\n"
msgstr "*usr_40.txt*\tFür Vim version 7.3.  Letzte Änderung: 2006-Jun-21\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:4
#, no-wrap
msgid "\t\t     VIM USER MANUAL - by Bram Moolenaar\n"
msgstr "\t\t     VIM-BENUTZERHANDBUCH - von Bram Moolenaar\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:6
#, no-wrap
msgid "\t\t\t      Make new commands\n"
msgstr "\t\t\t      Neue Befehle machen\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:11
msgid ""
"Vim is an extensible editor.  You can take a sequence of commands you use "
"often and turn it into a new command.  Or redefine an existing command.  "
"Autocommands make it possible to execute commands automatically."
msgstr ""
"Vim ist ein erweiterbarer Editor.  Sie können eine Folge von Befehlen "
"nehmen, die Sie oft benutzen, und aus ihnen einen neuen Befehl machen.  "
"Oder einen bestehenden Befehl neu definieren.  Automatische Befehle machen "
"es möglich, Befehle automatisch auszuführen."

# type: Plain text
#. type: Plain text
#: usr_40.txt:15
msgid ""
"|40.1|\tKey mapping |40.2|\tDefining command-line commands |40.3|"
"\tAutocommands"
msgstr ""
"|40.1|\tTasten belegen\n"
"|40.2|\tBefehlszeilen-Befehle definieren\n"
"|40.3|\tAutomatische Befehle"

# type: Plain text
#. type: Plain text
#: usr_40.txt:19
#, no-wrap
msgid ""
"     Next chapter: |usr_41.txt|  Write a Vim script\n"
" Previous chapter: |usr_32.txt|  The undo tree\n"
"Table of contents: |usr_toc.txt|\n"
msgstr ""
"Nächstes Kapitel: |usr_41.txt|  Ein Vim-Skript schreiben\n"
" Voriges Kapitel: |usr_32.txt|  Der Undo-Baum\n"
"Inhaltsübersicht: |usr_toc.txt|\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:20 usr_40.txt:279 usr_40.txt:424 usr_40.txt:653
#, no-wrap
msgid ""
"==============================================================================\n"
msgstr ""
"==============================================================================\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:22
#, no-wrap
msgid "*40.1*\tKey mapping\n"
msgstr "*40.1*\tTasten belegen\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:29
#, no-wrap
msgid ""
"A simple mapping was explained in section |05.3|.  The principle is that "
"one\n"
"sequence of key strokes is translated into another sequence of key "
"strokes.\n"
"This is a simple, yet powerful mechanism.\n"
"   The simplest form is that one key is mapped to a sequence of keys.  "
"Since\n"
"the function keys, except <F1>, have no predefined meaning in Vim, these "
"are\n"
"good choices to map.  Example: >\n"
msgstr ""
"Eine einfache Belegung wurde in Abschnitt |05.3| erklärt.  Das Prinzip "
"ist,\n"
"dass eine Folge von Tastendrücken in eine andere Folge von Tastendrücken\n"
"übersetzt wird.  Dies ist ein einfacher, jedoch mächtiger Mechanismus.\n"
"   Die einfachste Form ist, dass eine Taste mit einer Folge von Tasten "
"belegt\n"
"wird.  Weil die Funktionstasten, außer <F1>, keine vordefinierte Bedeutung "
"in\n"
"Vim haben, sind diese eine gute Wahl zur Belegung.  Beispiel: >\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:31
#, no-wrap
msgid "\t:map <F2> GoDate: <Esc>:read !date<CR>kJ\n"
msgstr "\t:map <F2> GoDate: <Esc>:read !date<CR>kJ\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:43
#, no-wrap
msgid ""
"This shows how three modes are used.  After going to the last line with "
"\"G\",\n"
"the \"o\" command opens a new line and starts Insert mode.  The text "
"\"Date: \" is\n"
"inserted and <Esc> takes you out of insert mode.\n"
"   Notice the use of special keys inside <>.  This is called angle bracket\n"
"notation.  You type these as separate characters, not by pressing the key\n"
"itself.  This makes the mappings better readable and you can copy and "
"paste\n"
"the text without problems.\n"
"   The \":\" character takes Vim to the command line.  The \":read !date\" "
"command\n"
"reads the output from the \"date\" command and appends it below the "
"current\n"
"line.  The <CR> is required to execute the \":read\" command.\n"
"   At this point of execution the text looks like this:\n"
msgstr ""
"Dies zeigt, wie drei Modi benutzt werden.  Nachdem mit »G« in die letzte "
"Zeile\n"
"gegangen wird, öffnet der Befehl »o« eine neue Zeile und geht in den\n"
"Einfügemodus.  Der Text »Date: « wird eingefügt und <Esc> bringt uns "
"aus dem\n"
"Einfügemodus.\n"
"   Beachten Sie den Gebrauch von Sondertasten in <>.  Dies nennt sich "
"Notation\n"
"mit spitzen Klammern.  Sie tippen diese als getrennte Zeichen, nicht, "
"indem\n"
"Sie die Taste selbst drücken.  Dadurch wird die Belegung besser lesbar, "
"und\n"
"Sie können den Text ohne Probleme kopieren und einfügen.\n"
"   Das Zeichen »:« bringt Vim in die Befehlszeile.  Der Befehl »:read "
"!date«\n"
"liest die Ausgabe des Befehls »date« und hängt sie unter der aktuellen "
"Zeile\n"
"an.  Das <CR> wird benötigt, um den Befehl »:read« auszuführen.\n"
"   An dieser Stelle der Ausführung sieht der Text so aus:\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:46
#, no-wrap
msgid ""
"\tDate:  ~\n"
"\tFri Jun 15 12:54:34 CEST 2001 ~\n"
msgstr ""
"\tDate:  ~\n"
"\tFri Jun 15 12:54:34 CEST 2001 ~\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:49
#, no-wrap
msgid ""
"Now \"kJ\" moves the cursor up and joins the lines together.\n"
"   To decide which key or keys you use for mapping, see |map-which-keys|.\n"
msgstr ""
"Jetzt bewegt »kJ« den Cursor nach oben und fügt die Zeilen zusammen.\n"
"   Um zu entscheiden, welche Taste oder Tasten Sie zum Belegen verwenden,\n"
"siehe |map-which-keys|.\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:52
msgid "MAPPING AND MODES"
msgstr "BELEGUNGEN UND MODI"

# type: Plain text
#. type: Plain text
#: usr_40.txt:56
msgid ""
"The \":map\" command defines remapping for keys in Normal mode.  You can "
"also define mappings for other modes.  For example, \":imap\" applies to "
"Insert mode.  You can use it to insert a date below the cursor: >"
msgstr ""
"Der Befehl »:map« definiert Neubelegungen für Tasten im normalen Modus.  "
"Sie können auch Belegungen für andere Modi definieren.  »:imap« zum "
"Beispiel ist für den Einfügemodus zuständig.  Sie können ihn benutzen, "
"um ein Datum unter dem Cursor einzufügen: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:58
#, no-wrap
msgid "\t:imap <F2> <CR>Date: <Esc>:read !date<CR>kJ\n"
msgstr "\t:imap <F2> <CR>Date: <Esc>:read !date<CR>kJ\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:65
#, no-wrap
msgid ""
"It looks a lot like the mapping for <F2> in Normal mode, only the start is\n"
"different.  The <F2> mapping for Normal mode is still there.  Thus you can "
"map\n"
"the same key differently for each mode.\n"
"   Notice that, although this mapping starts in Insert mode, it ends in "
"Normal\n"
"mode.  If you want it to continue in Insert mode, append an \"a\" to the\n"
"mapping.\n"
msgstr ""
"Sie sieht sehr wie die Belegung für <F2> im normalen Modus aus, nur der "
"Beginn\n"
"ist verschieden.  Die Belegung von <F2> im normalen Modus ist noch da.  "
"Also\n"
"können Sie dieselbe Taste für jeden Modus unterschiedlich belegen.\n"
"   Beachten Sie, dass, obwohl diese Belegung im Einfügemodus beginnt, sie "
"im\n"
"normalen Modus endet.  Falls Sie im Einfügemodus fortfahren wollen, "
"hängen Sie\n"
"der Belegung ein »a« an.\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:67
msgid "Here is an overview of map commands and in which mode they work:"
msgstr ""
"Hier ist eine Übersicht der Belegungsbefehle und in welchem Modus sie "
"arbeiten:"

# type: Plain text
#. type: Plain text
#: usr_40.txt:75
#, no-wrap
msgid ""
"\t:map\t\tNormal, Visual and Operator-pending\n"
"\t:vmap\t\tVisual\n"
"\t:nmap\t\tNormal\n"
"\t:omap\t\tOperator-pending\n"
"\t:map!\t\tInsert and Command-line\n"
"\t:imap\t\tInsert\n"
"\t:cmap\t\tCommand-line\n"
msgstr ""
"\t:map\t\tnormal, visuell und Operator-hängend\n"
"\t:vmap\t\tvisuell\n"
"\t:nmap\t\tnormal\n"
"\t:omap\t\tOperator-hängend\n"
"\t:map!\t\tEinfügen und Befehlszeile\n"
"\t:imap\t\tEinfügen\n"
"\t:cmap\t\tBefehlszeile\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:79
msgid ""
"Operator-pending mode is when you typed an operator character, such as "
"\"d\" "
"or \"y\", and you are expected to type the motion command or a text object. "
" "
"Thus when you type \"dw\", the \"w\" is entered in operator-pending mode."
msgstr ""
"Der Operator-hängende Modus ist, wenn Sie ein Operator-Zeichen, so wie "
"»d« oder »y«, getippt haben, und Vim auf einen Bewegungsbefehl oder ein "
"Textobjekt wartet.  Wenn Sie also »dw« tippen, wird das »w« im "
"Operator-hängenden Modus eingegeben."

# type: Plain text
#. type: Plain text
#: usr_40.txt:85
msgid ""
"Suppose that you want to define <F7> so that the command d<F7> deletes a C "
"program block (text enclosed in curly braces, {}).  Similarly y<F7> would "
"yank the program block into the unnamed register.  Therefore, what you need "
"to do is to define <F7> to select the current program block.  You can do "
"this with the following command: >"
msgstr ""
"Angenommen, Sie wollen <F7> so definieren, dass der Befehl »d<F7>« einen "
"C-Programm-Block löscht (in geschwungene Klammern, {}, eingeschlossener "
"Text).  Analog würde »y<F7>« den Programm-Block in das unbenannte "
"Register kopieren.  Was Sie demnach tun müssen, ist es, <F7> so zu "
"definieren, dass sie den aktuellen Programm-Block auswählt.  Sie können "
"dies mit dem folgenden Befehl tun: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:87
#, no-wrap
msgid "\t:omap <F7> a{\n"
msgstr "\t:omap <F7> a{\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:91
msgid ""
"This causes <F7> to perform a select block \"a{\" in operator-pending mode, "
"just like you typed it.  This mapping is useful if typing a { on your "
"keyboard is a bit difficult."
msgstr ""
"Dies lässt <F7> eine Blockauswahl »a{« im Operator-hängenden Modus "
"ausführen, genau als hätten Sie es getippt.  Diese Belegung ist "
"nützlich, falls das Tippen von { auf Ihrer Tastatur schwierig ist."

# type: Plain text
#. type: Plain text
#: usr_40.txt:94
msgid "LISTING MAPPINGS"
msgstr "BELEGUNGEN AUFLISTEN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:98
msgid ""
"To see the currently defined mappings, use \":map\" without arguments.  Or "
"one of the variants that include the mode in which they work.  The output "
"could look like this:"
msgstr ""
"Um die aktuell definierten Belegungen zu sehen, benutzen Sie »:map« ohne "
"Argumente.  Oder eine der Varianten, die den Modus beinhalten, in dem sie "
"arbeiten.  Die Ausgabe könnte so aussehen:"

# type: Plain text
#. type: Plain text
#: usr_40.txt:104
#, no-wrap
msgid ""
"\t   _g\t\t :call MyGrep(1)<CR> ~\n"
"\tv  <F2>\t\t :s/^/> /<CR>:noh<CR>`` ~\n"
"\tn  <F2>\t\t :.,$s/^/> /<CR>:noh<CR>`` ~\n"
"\t   <xHome>\t <Home>\n"
"\t   <xEnd>\t <End>\n"
msgstr ""
"\t   _g\t\t :call MyGrep(1)<CR> ~\n"
"\tv  <F2>\t\t :s/^/> /<CR>:noh<CR>`` ~\n"
"\tn  <F2>\t\t :.,$s/^/> /<CR>:noh<CR>`` ~\n"
"\t   <xHome>\t <Home>\n"
"\t   <xEnd>\t <End>\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:113
#, no-wrap
msgid ""
"The first column of the list shows in which mode the mapping is effective.\n"
"This is \"n\" for Normal mode, \"i\" for Insert mode, etc.  A blank is used "
"for a\n"
"mapping defined with \":map\", thus effective in both Normal and Visual "
"mode.\n"
"   One useful purpose of listing the mapping is to check if special keys in "
"<>\n"
"form have been recognized (this only works when color is supported).  For\n"
"example, when <Esc> is displayed in color, it stands for the escape "
"character.\n"
"When it has the same color as the other text, it is five characters.\n"
msgstr ""
"Die erste Spalte der Liste gibt an, in welchem Modus die Belegung\n"
"funktioniert.  Dies ist »n« für den normalen Modus, »i« für den "
"Einfügemodus\n"
"usw.  Ein Leerzeichen wird für eine mit »:map« definierte Belegung "
"verwandt,\n"
"also effektiv im normalen und visuellen Modus.\n"
"   Ein nützlicher Aspekt, die Belegungen zu listen, ist zu prüfen, ob\n"
"Sondertasten in <>-Form erkannt wurden (dies funktioniert nur, wenn Farbe\n"
"unterstützt wird).  Wenn zum Beispiel <Esc> farbig dargestellt wird, steht "
"es\n"
"für die Escape-Taste.  Wenn es dieselbe Farbe wie der andere Text hat, "
"sind es\n"
"nur fünf Zeichen.\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:116
msgid "REMAPPING"
msgstr "NEUBELEGEN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:119
msgid ""
"The result of a mapping is inspected for other mappings in it.  For "
"example, "
"the mappings for <F2> above could be shortened to: >"
msgstr ""
"Das Ergebnis einer Belegung wird nach anderen Belegungen in ihr inspiziert. "
" Zum Beispiel könnten die Belegungen für <F2> oben folgendermaßen "
"abgekürzt werden: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:123
#, no-wrap
msgid ""
"\t:map <F2> G<F3>\n"
"\t:imap <F2> <Esc><F3>\n"
"\t:map <F3>  oDate: <Esc>:read !date<CR>kJ\n"
msgstr ""
"\t:map <F2> G<F3>\n"
"\t:imap <F2> <Esc><F3>\n"
"\t:map <F3>  oDate: <Esc>:read !date<CR>kJ\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:127
msgid ""
"For Normal mode <F2> is mapped to go to the last line, and then behave like "
"<F3> was pressed.  In Insert mode <F2> stops Insert mode with <Esc> and "
"then "
"also uses <F3>.  Then <F3> is mapped to do the actual work."
msgstr ""
"Für den normalen Modus wird <F2> so belegt, dass in die letzte Zeile "
"gegangen wird, und dann so getan wird, als ob <F3> gedrückt wurde.  Im "
"Einfügemodus beendet <F2> den Einfügemodus mit <Esc> und benutzt dann "
"ebenfalls <F3>.  Dann wird <F3> so belegt, dass sie die tatsächliche "
"Arbeit macht."

# type: Plain text
#. type: Plain text
#: usr_40.txt:130
msgid ""
"Suppose you hardly ever use Ex mode, and want to use the \"Q\" command to "
"format text (this was so in old versions of Vim).  This mapping will do it: "
">"
msgstr ""
"Angenommen, Sie benutzen kaum den Ex-Modus, und wollen den Befehl »Q« "
"dazu verwenden, Text zu formatieren (so war es in alten Vim-Versionen).  "
"Die folgende Belegung macht es: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:132
#, no-wrap
msgid "\t:map Q gq\n"
msgstr "\t:map Q gq\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:135
msgid ""
"But, in rare cases you need to use Ex mode anyway.  Let's map \"gQ\" to Q, "
"so that you can still go to Ex mode: >"
msgstr ""
"Aber in seltenen Fällen brauchen Sie dennoch den Ex-Modus.  Lassen Sie uns "
"»gQ« mit Q belegen, so dass Sie immer noch in den Ex-Modus gehen können: "
">"

# type: Plain text
#. type: Plain text
#: usr_40.txt:137
#, no-wrap
msgid "\t:map gQ Q\n"
msgstr "\t:map gQ Q\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:142
#, no-wrap
msgid ""
"What happens now is that when you type \"gQ\" it is mapped to \"Q\".  So "
"far so\n"
"good.  But then \"Q\" is mapped to \"gq\", thus typing \"gQ\" results in "
"\"gq\", and\n"
"you don't get to Ex mode at all.\n"
"   To avoid keys to be mapped again, use the \":noremap\" command: >\n"
msgstr ""
"Was nun geschieht: Sie tippen »gQ« und es ist mit »Q« belegt.  So weit, "
"so\n"
"gut.  Aber dann ist »Q« mit »gq« belegt, also resultiert das Tippen von "
"»gQ«\n"
"in »gq«, und Sie kommen gar nicht in den Ex-Modus.\n"
"   Um zu vermeiden, dass Tasten wieder belegt werden, benutzen Sie den "
"Befehl\n"
"»:noremap«: >\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:144
#, no-wrap
msgid "\t:noremap gQ Q\n"
msgstr "\t:noremap gQ Q\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:147
msgid ""
"Now Vim knows that the \"Q\" is not to be inspected for mappings that apply "
"to it.  There is a similar command for every mode:"
msgstr ""
"Nun weiß Vim, dass »Q« nicht nach weiteren Belegungen, die für es "
"gelten, inspiziert werden soll.  Analoge Befehle gibt es für jeden Modus:"

# type: Plain text
#. type: Plain text
#: usr_40.txt:155
#, no-wrap
msgid ""
"\t:noremap\tNormal, Visual and Operator-pending\n"
"\t:vnoremap\tVisual\n"
"\t:nnoremap\tNormal\n"
"\t:onoremap\tOperator-pending\n"
"\t:noremap!\tInsert and Command-line\n"
"\t:inoremap\tInsert\n"
"\t:cnoremap\tCommand-line\n"
msgstr ""
"\t:noremap\tnormal, visuell und Operator-hängend\n"
"\t:vnoremap\tvisuell\n"
"\t:nnoremap\tnormal\n"
"\t:onoremap\tOperator-hängend\n"
"\t:noremap!\tEinfügen und Befehlszeile\n"
"\t:inoremap\tEinfügen\n"
"\t:cnoremap\tBefehlszeile\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:158
msgid "RECURSIVE MAPPING"
msgstr "DIE REKURSIVE BELEGUNG"

# type: Plain text
#. type: Plain text
#: usr_40.txt:164
#, no-wrap
msgid ""
"When a mapping triggers itself, it will run forever.  This can be used to\n"
"repeat an action an unlimited number of times.\n"
"   For example, you have a list of files that contain a version number in "
"the\n"
"first line.  You edit these files with \"vim *.txt\".  You are now editing "
"the\n"
"first file.  Define this mapping: >\n"
msgstr ""
"Wenn eine Belegung sich selbst auslöst, läuft sie für immer.  Dies kann\n"
"benutzt werden, um eine Aktion eine unbegrenzte Anzahl von Malen zu\n"
"wiederholen.\n"
"   Sie haben zum Beispiel eine Liste von Dateien, die eine Versionsnummer "
"in\n"
"der ersten Zeile enthalten.  Sie editieren diese mit »vim *.txt«.  Sie\n"
"editieren nun die erste Datei.  Definieren Sie diese Belegung: >\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:166
#, no-wrap
msgid "\t:map ,, :s/5.1/5.2/<CR>:wnext<CR>,,\n"
msgstr "\t:map ,, :s/5.1/5.2/<CR>:wnext<CR>,,\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:177
#, no-wrap
msgid ""
"Now you type \",,\".  This triggers the mapping.  It replaces \"5.1\" with "
"\"5.2\"\n"
"in the first line.  Then it does a \":wnext\" to write the file and edit "
"the\n"
"next one.  The mapping ends in \",,\".  This triggers the same mapping "
"again,\n"
"thus doing the substitution, etc.\n"
"   This continues until there is an error.  In this case it could be a "
"file\n"
"where the substitute command doesn't find a match for \"5.1\".  You can "
"then\n"
"make a change to insert \"5.1\" and continue by typing \",,\" again.  Or "
"the\n"
"\":wnext\" fails, because you are in the last file in the list.\n"
"   When a mapping runs into an error halfway, the rest of the mapping is\n"
"discarded.  CTRL-C interrupts the mapping (CTRL-Break on MS-Windows).\n"
msgstr ""
"Nun tippen Sie »,,«.  Dies löst die Belegung aus.  Sie ersetzt in der "
"ersten\n"
"Zeile »5.1« durch »5.2«.  Dann macht sie »:wnext« um die Datei zu "
"sichern und\n"
"die nächste zu editieren.  Die Belegung endet mit »,,«.  Die löst "
"dieselbe\n"
"Belegung wieder aus, also die Ersetzung machen usw.\n"
"   Dies geht so weiter bis es einen Fehler gibt.  In diesem Falle könnte "
"es\n"
"eine Datei sein, wo der Befehl »:substitute« keine Übereinstimmung für "
"»5.1«\n"
"findet.  Sie können dann »5.1« einfügen und fortfahren, indem Sie "
"»,,« erneut\n"
"tippen.  Oder »:wnext« scheitert, weil Sie in der letzten Datei der "
"Liste\n"
"sind.\n"
"   Wenn eine Belegung auf halben Wege in einen Fehler läuft, wird der Rest "
"der\n"
"Belegung nicht mehr beachtet.  CTRL-C unterbricht die Belegung (unter\n"
"MS-Windows CTRL-Untbr).\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:180
msgid "DELETE A MAPPING"
msgstr "EINE BELEGUNG LÖSCHEN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:183
msgid ""
"To remove a mapping use the \":unmap\" command.  Again, the mode the "
"unmapping applies to depends on the command used:"
msgstr ""
"Um eine Belegung zu entfernen, benutzen Sie den Befehl »:unmap«.  Und "
"wieder entspricht der Modus, für den die Belegung entfernt wird, dem "
"benutzten Befehl:"

# type: Plain text
#. type: Plain text
#: usr_40.txt:191
#, no-wrap
msgid ""
"\t:unmap\t\tNormal, Visual and Operator-pending\n"
"\t:vunmap\t\tVisual\n"
"\t:nunmap\t\tNormal\n"
"\t:ounmap\t\tOperator-pending\n"
"\t:unmap!\t\tInsert and Command-line\n"
"\t:iunmap\t\tInsert\n"
"\t:cunmap\t\tCommand-line\n"
msgstr ""
"\t:unmap\t\tnormal, visuell und Operator-hängend\n"
"\t:vunmap\t\tvisuell\n"
"\t:nunmap\t\tnormal\n"
"\t:ounmap\t\tOperator-hängend\n"
"\t:unmap!\t\tEinfügen und Befehlszeile\n"
"\t:iunmap\t\tEinfügen\n"
"\t:cunmap\t\tBefehlszeile\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:195
msgid ""
"There is a trick to define a mapping that works in Normal and Operator-"
"pending mode, but not in Visual mode.  First define it for all three modes, "
"then delete it for Visual mode: >"
msgstr ""
"Es gibt einen Trick, eine Belegung zu definieren, die im normalen und "
"Operator-hängenden Modus funktioniert, aber nicht im visuellen.  Zuerst "
"definiere man sie für alle drei Modi, dann lösche man sie im visuellen "
"Modus: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:198
#, no-wrap
msgid ""
"\t:map <C-A> /---><CR>\n"
"\t:vunmap <C-A>\n"
msgstr ""
"\t:map <C-A> /---><CR>\n"
"\t:vunmap <C-A>\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:200
msgid ""
"Notice that the five characters \"<C-A>\" stand for the single key CTRL-A."
msgstr ""
"Beachten Sie, dass die fünf Zeichen »<C-A>« für die Tastenkombination "
"CTRL-A stehen."

# type: Plain text
#. type: Plain text
#: usr_40.txt:204
msgid ""
"To remove all mappings use the |:mapclear| command.  You can guess the "
"variations for different modes by now.  Be careful with this command, it "
"can't be undone."
msgstr ""
"Um alle Belegungen zu entfernen, benutzen Sie den Befehl |:mapclear|.  Sie "
"können die Variationen für verschiedene Modi nun raten.  Seien Sie "
"vorsichtig mit diesem Befehl, er kann nicht rückgängig gemacht werden."

# type: Plain text
#. type: Plain text
#: usr_40.txt:207
msgid "SPECIAL CHARACTERS"
msgstr "SONDERZEICHEN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:213
#, no-wrap
msgid ""
"The \":map\" command can be followed by another command.  A | character\n"
"separates the two commands.  This also means that a | character can't be "
"used\n"
"inside a map command.  To include one, use <Bar> (five characters).  "
"Example:\n"
">\n"
"\t:map <F8> :write <Bar> !checkin %<CR>\n"
msgstr ""
"Dem Befehl »:map« kann ein weiterer Befehl folgen.  Das Zeichen »|« "
"trennt die\n"
"beiden Befehle.  Dies bedeutet auch, dass das Zeichen »|« nicht in einem\n"
"Belegungsbefehl verwandt werden kann.  Um eins einzubeziehen, benutzen Sie\n"
"<Bar> (fünf Zeichen).  Beispiel:\n"
">\n"
"\t:map <F8> :write <Bar> !checkin %<CR>\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:219
#, no-wrap
msgid ""
"The same problem applies to the \":unmap\" command, with the addition that "
"you\n"
"have to watch out for trailing white space.  These two commands are "
"different:\n"
">\n"
"\t:unmap a | unmap b\n"
"\t:unmap a| unmap b\n"
msgstr ""
"Dasselbe Problem trifft auf den Befehl »:unmap« zu, und zusätzlich "
"müssen Sie\n"
"auf nachfolgende Leerzeichen achten.  Diese zwei Befehle sind verschieden:\n"
">\n"
"\t:unmap a | unmap b\n"
"\t:unmap a| unmap b\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:221
msgid "The first command tries to unmap \"a \", with a trailing space."
msgstr ""
"Der erste Befehl versucht »a « freizugeben, mit einem nachfolgen "
"Leerzeichen."

# type: Plain text
#. type: Plain text
#: usr_40.txt:223
msgid "When using a space inside a mapping, use <Space> (seven characters): >"
msgstr ""
"Wenn Sie ein Leerzeichen in einer Belegung verwenden, benutzen Sie <Space> "
"(sieben Zeichen): >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:225
#, no-wrap
msgid "\t:map <Space> W\n"
msgstr "\t:map <Space> W\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:227
msgid "This makes the spacebar move a blank-separated word forward."
msgstr ""
"Dies lässt die Leertaste ein Leerzeichen-getrenntes Wort vorwärts bewegen."

# type: Plain text
#. type: Plain text
#: usr_40.txt:231
msgid ""
"It is not possible to put a comment directly after a mapping, because the "
"\" "
"character is considered to be part of the mapping.  You can use |\", this "
"starts a new, empty command with a comment.  Example: >"
msgstr ""
"Es ist nicht möglich, einen Kommentar direkt nach eine Belegung zu setzen, "
"weil das Zeichen »\"« als Teil der Belegung angenommen wird.  Sie können "
"»|\"« verwenden, dies beginnt einen neuen, leeren Befehl mit einem "
"Kommentar.  Beispiel: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:233
#, no-wrap
msgid "\t:map <Space> W|     \" Use spacebar to move forward a word\n"
msgstr ""
"\t:map <Space> W|     \" Benutze Leertaste, um ein Wort vorwärts zu gehen\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:236
msgid "MAPPINGS AND ABBREVIATIONS"
msgstr "BELEGUNGEN UND ABKÜRZUNGEN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:249
#, no-wrap
msgid ""
"Abbreviations are a lot like Insert mode mappings.  The arguments are "
"handled\n"
"in the same way.  The main difference is the way they are triggered.  An\n"
"abbreviation is triggered by typing a non-word character after the word.  "
"A\n"
"mapping is triggered when typing the last character.\n"
"   Another difference is that the characters you type for an abbreviation "
"are\n"
"inserted in the text while you type them.  When the abbreviation is "
"triggered\n"
"these characters are deleted and replaced by what the abbreviation "
"produces.\n"
"When typing the characters for a mapping, nothing is inserted until you "
"type\n"
"the last character that triggers it.  If the 'showcmd' option is set, the\n"
"typed characters are displayed in the last line of the Vim window.\n"
"   An exception is when a mapping is ambiguous.  Suppose you have done two\n"
"mappings: >\n"
msgstr ""
"Abkürzungen verhalten sich sehr wie Belegungen für den Einfügemodus.  "
"Die\n"
"Argumente werden auf dieselbe Art behandelt.  Der Hauptunterschied ist die\n"
"Art, wie sie ausgelöst werden.  Eine Abkürzung wird ausgelöst, indem man "
"ein\n"
"nicht-Wort-Zeichen nach dem Wort tippt.  Eine Belegung wird ausgelöst, "
"wenn\n"
"das letzte Zeichen getippt wird.\n"
"   Ein weiterer Unterschied ist, dass die Zeichen, die Sie für eine "
"Abkürzung\n"
"tippen, in den Text eingefügt werden, während Sie sie tippen.  Wenn die\n"
"Abkürzung ausgelöst wird, werden diese Zeichen gelöscht und durch das "
"ersetzt,\n"
"was die Abkürzung produziert.  Beim Tippen der Zeichen für eine Belegung\n"
"wird nichts eingefügt, bis Sie das letzte Zeichen tippen, das sie "
"auslöst.\n"
"Falls die Option 'showcmd' gesetzt ist, werden die getippten Zeichen in "
"der\n"
"letzten Zeile des Vim-Fensters angezeigt.\n"
"   Eine Ausnahme ist, wenn eine Belegung mehrdeutig ist.  Angenommen, Sie\n"
"haben zwei Belegungen gemacht: >\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:252
#, no-wrap
msgid ""
"\t:imap aa foo\n"
"\t:imap aaa bar\n"
msgstr ""
"\t:imap aa foo\n"
"\t:imap aaa bar\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:258
msgid ""
"Now, when you type \"aa\", Vim doesn't know if it should apply the first or "
"the second mapping.  It waits for another character to be typed.  If it is "
"an \"a\", the second mapping is applied and results in \"bar\".  If it is a "
"space, for example, the first mapping is applied, resulting in \"foo\", and "
"then the space is inserted."
msgstr ""
"Wenn Sie nun »aa« tippen, weiß Vim nicht, ob er die erste oder das "
"zweite Belegung anwenden soll.  Er wartet, ob ein weiteres Zeichen getippt "
"wird.  Falls es ein »a« ist, wird die zwete Belegung angewandt und "
"resultiert in »bar«.  Falls es zum Beispiel ein Leerzeichen ist, wird die "
"erste Belegung angewandt, resultierend in »foo«, und dann wird das "
"Leerzeichen einfügt."

# type: Plain text
#. type: Plain text
#: usr_40.txt:261
msgid "ADDITIONALLY..."
msgstr "DARÜBERHINAUS..."

# type: Plain text
#. type: Plain text
#: usr_40.txt:264
msgid ""
"The <script> keyword can be used to make a mapping local to a script.  See "
"|:"
"map-<script>|."
msgstr ""
"Das Schlüsselwort <script> kann benutzt werden, um ein Belegung lokal zu "
"einem Skript zu machen.  Siehe |:map-<script>|."

# type: Plain text
#. type: Plain text
#: usr_40.txt:267
msgid ""
"The <buffer> keyword can be used to make a mapping local to a specific "
"buffer.  See |:map-<buffer>|"
msgstr ""
"Das Schlüsselwort <buffer> kann verwandt werden, um eine Belegung lokal zu "
"einem bestimmten Puffer zu machen.  Siehe |:map-<buffer>|."

# type: Plain text
#. type: Plain text
#: usr_40.txt:271
msgid ""
"The <unique> keyword can be used to make defining a new mapping fail when "
"it "
"already exists.  Otherwise a new mapping simply overwrites the old one.  "
"See "
"|:map-<unique>|."
msgstr ""
"Das Schlüsselwort <unique> kann benutzt werden, um das Definieren einer "
"Belegung scheitern zu lassen, wenn sie bereits existiert.  Ansonsten "
"überschreibt eine neue Belegung einfach die alte.  Siehe |:map-<unique>|."

# type: Plain text
#. type: Plain text
#: usr_40.txt:274
msgid ""
"To make a key do nothing, map it to <Nop> (five characters).  This will "
"make "
"the <F7> key do nothing at all: >"
msgstr ""
"Um eine Taste nichts machen zu lassen, belegen Sie sie mit <Nop> (fünf "
"Zeichen).  Dies lässt die Taste <F7> überhaupt nichts machen: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:276
#, no-wrap
msgid "\t:map <F7> <Nop>| map! <F7> <Nop>\n"
msgstr "\t:map <F7> <Nop>| map! <F7> <Nop>\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:278
msgid "There must be no space after <Nop>."
msgstr "Es darf kein Zeichen nach <Nop> sein."

# type: Plain text
#. type: Plain text
#: usr_40.txt:281
#, no-wrap
msgid "*40.2*\tDefining command-line commands\n"
msgstr "*40.2*\tBefehlszeilen-Befehle definieren\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:285
#, no-wrap
msgid ""
"The Vim editor enables you to define your own commands.  You execute these\n"
"commands just like any other Command-line mode command.\n"
"   To define a command, use the \":command\" command, as follows: >\n"
msgstr ""
"Der Editor Vim ermöglicht Ihnen, Ihre eigenen Befehle zu definieren.  Sie\n"
"führen diese ganz wie jeden anderen Befehl im Befehlszeilen-Modus aus.\n"
"   Um einen Befehl zu definieren, benutzen Sie den Befehl »:command«, "
"wie\n"
"folgt: >\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:287
#, no-wrap
msgid "\t:command DeleteFirst 1delete\n"
msgstr "\t:command DeleteFirst 1delete\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:290
msgid ""
"Now when you execute the command \":DeleteFirst\" Vim executes "
"\":1delete\", "
"which deletes the first line."
msgstr ""
"Wenn Sie nun den Befehl »:DeleteFirst« ausführen, führt Vim "
"»:1delete« aus, was die erste Zeile löscht."

# type: Plain text
#. type: Plain text
#: usr_40.txt:295
#, no-wrap
msgid ""
"\tNote:\n"
"\tUser-defined commands must start with a capital letter.  You cannot\n"
"\tuse \":X\", \":Next\" and \":Print\".  The underscore cannot be used!  "
"You\n"
"\tcan use digits, but this is discouraged.\n"
msgstr ""
"\tAnmerkung:\n"
"\tBenutzer-definierte Befehle müssen mit einem Großbuchstaben beginnen.\n"
"\tSie können nicht »:X«, »:Next« und »:Print« verwenden.  Der\n"
"\tUnterstrich kann nicht benutzt werden! Sie können Ziffern verwenden,\n"
"\taber davon wird abgeraten.\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:297
msgid "To list the user-defined commands, execute the following command: >"
msgstr ""
"Um die benutzer-definierten Befehle aufzulisten, führen Sie den folgenden "
"Befehl aus: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:299
#, no-wrap
msgid "\t:command\n"
msgstr "\t:command\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:303
msgid ""
"Just like with the builtin commands, the user defined commands can be "
"abbreviated.  You need to type just enough to distinguish the command from "
"another.  Command line completion can be used to get the full name."
msgstr ""
"Ganz wie mit den eingebauten Befehlen, können die benutzer-definierten "
"Befehle abgekürzt werden.  Sie brauchen nur soviel zu tippen, um den "
"Befehl von einem anderen zu unterscheiden.  "
"Befehlszeilen-Vervollständigung kann benutzt werden, um den vollen Namen "
"zu erhalten."

# type: Plain text
#. type: Plain text
#: usr_40.txt:306
msgid "NUMBER OF ARGUMENTS"
msgstr "ANZAHL VON ARGUMENTEN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:311
msgid ""
"User-defined commands can take a series of arguments.  The number of "
"arguments must be specified by the -nargs option.  For instance, the "
"example :DeleteFirst command takes no arguments, so you could have defined "
"it as follows: >"
msgstr ""
"Benutzer-definierte Befehle können eine Folge von Argumenten nehmen.  Die "
"Zahl von Argumenten muss mit der Option -nargs angegeben werden.  Das "
"Beispiel :DeleteFirst etwa nimmt keine Argumente, so dass Sie es wie folgt "
"definieren können: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:313
#, no-wrap
msgid "\t:command -nargs=0 DeleteFirst 1delete\n"
msgstr "\t:command -nargs=0 DeleteFirst 1delete\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:316
msgid ""
"However, because zero arguments is the default, you do not need to add \"-"
"nargs=0\".  The other values of -nargs are as follows:"
msgstr ""
"Da jedoch null Argumente der Standardfall sind, brauchen Sie nicht "
"»-nargs=0« hinzufügen.  Die anderen Werte von -nargs sind wie folgt:"

# type: Plain text
#. type: Plain text
#: usr_40.txt:322
#, no-wrap
msgid ""
"\t-nargs=0\tNo arguments\n"
"\t-nargs=1\tOne argument\n"
"\t-nargs=*\tAny number of arguments\n"
"\t-nargs=?\tZero or one argument\n"
"\t-nargs=+\tOne or more arguments\n"
msgstr ""
"\t-nargs=0\tKeine Argumente\n"
"\t-nargs=1\tEin Argument\n"
"\t-nargs=*\tJede Anzahl von Argumenten\n"
"\t-nargs=?\tNull oder ein Argument\n"
"\t-nargs=+\tEin oder mehr Argumente\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:325
msgid "USING THE ARGUMENTS"
msgstr "DIE ARGUMENTE BENUTZEN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:328
msgid ""
"Inside the command definition, the arguments are represented by the <args> "
"keyword.  For example: >"
msgstr ""
"Innerhalb der Befehls-Definition werden die Argumente durch das "
"Schlüsselwort <args> repräsentiert.  Zum Beispiel: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:330
#, no-wrap
msgid "\t:command -nargs=+ Say :echo \"<args>\"\n"
msgstr "\t:command -nargs=+ Say :echo \"<args>\"\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:332
msgid "Now when you type >"
msgstr "Wenn Sie nun tippen >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:334
#, no-wrap
msgid "\t:Say Hello World\n"
msgstr "\t:Say Hello World\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:337
msgid ""
"Vim echoes \"Hello World\".  However, if you add a double quote, it won't "
"work.  For example: >"
msgstr ""
"gibt Vim »Hello World« aus.  Falls Sie jedoch ein doppeltes Zitatzeichen "
"hinzufügen, funktioniert es nicht.  Zum Beispiel: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:339
#, no-wrap
msgid "\t:Say he said \"hello\"\n"
msgstr "\t:Say he said \"hello\"\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:342
msgid ""
"To get special characters turned into a string, properly escaped to use as "
"an expression, use \"<q-args>\": >"
msgstr ""
"Um Sonderzeichen in eine Zeichenkette verwandelt zu bekommen, richtig "
"geschützt als ein Ausdruck, benutzen Sie »<q-args>«: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:344
#, no-wrap
msgid "\t:command -nargs=+ Say :echo <q-args>\n"
msgstr "\t:command -nargs=+ Say :echo <q-args>\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:346
msgid "Now the above \":Say\" command will result in this to be executed: >"
msgstr "Nun resultiert der obige Befehl »:Say« in diesem zur Ausführung: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:348
#, no-wrap
msgid "\t:echo \"he said \\\"hello\\\"\"\n"
msgstr "\t:echo \"he said \\\"hello\\\"\"\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:354
#, no-wrap
msgid ""
"The <f-args> keyword contains the same information as the <args> keyword,\n"
"except in a format suitable for use as function call arguments.  For "
"example:\n"
">\n"
"\t:command -nargs=* DoIt :call AFunction(<f-args>)\n"
"\t:DoIt a b c\n"
msgstr ""
"Das Schlüsselwort <f-args> enthält dieselben Informationen wie das\n"
"Schlüsselwort <args>, außer dass sie in einem Format sind, das sich für\n"
"einen Funktionsaufruf eignet.  Zum Beispiel:\n"
">\n"
"\t:command -nargs=* DoIt :call AFunction(<f-args>)\n"
"\t:DoIt a b c\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:356
msgid "Executes the following command: >"
msgstr "führt den folgenden Befehl aus: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:358
#, no-wrap
msgid "\t:call AFunction(\"a\", \"b\", \"c\")\n"
msgstr "\t:call AFunction(\"a\", \"b\", \"c\")\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:361
msgid "LINE RANGE"
msgstr "ZEILENBEREICH"

# type: Plain text
#. type: Plain text
#: usr_40.txt:365
msgid ""
"Some commands take a range as their argument.  To tell Vim that you are "
"defining such a command, you need to specify a -range option.  The values "
"for this option are as follows:"
msgstr ""
"Einige Befehlen nehmen einen Bereich als ihr Argument.  Um Vim zu sagen, "
"dass Sie solch einen Befehl definieren, müssen Sie die Option -range "
"angeben.  Die Werte für diese Option sind wie folgt:"

# type: Plain text
#. type: Plain text
#: usr_40.txt:370
#, no-wrap
msgid ""
"\t-range\t\tRange is allowed; default is the current line.\n"
"\t-range=%\tRange is allowed; default is the whole file.\n"
"\t-range={count}\tRange is allowed; the last number in it is used as a\n"
"\t\t\tsingle number whose default is {count}.\n"
msgstr ""
"\t-range\t\tBereich ist erlaubt; Standard ist die aktuelle Zeile.\n"
"\t-range=%\tBereich ist erlaubt; Standard ist die ganze Datei.\n"
"\t-range={count}\tBereich ist erlaubt; die letzte Zeilenzahl in ihm wird\n"
"\t\t\tals eine einzelne Nummer genommen, deren Standard\n"
"\t\t\t{count} ist.\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:375
msgid ""
"When a range is specified, the keywords <line1> and <line2> get the values "
"of the first and last line in the range.  For example, the following "
"command "
"defines the SaveIt command, which writes out the specified range to the "
"file "
"\"save_file\": >"
msgstr ""
"Wenn ein Bereich angegeben wird, erhalten die Schlüsselwörter <line1> und "
"<line2> die Werte der ersten und letzten Zeile im Bereich.  Der folgende "
"Befehl definiert zum Beispiel den Befehl SaveIt, der den angegeben Bereich "
"in die Datei »save_file« schreibt: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:377
#, no-wrap
msgid "\t:command -range=% SaveIt :<line1>,<line2>write! save_file\n"
msgstr "\t:command -range=% SaveIt :<line1>,<line2>write! save_file\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:380
msgid "OTHER OPTIONS"
msgstr "ANDERE OPTIONEN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:382
msgid "Some of the other options and keywords are as follows:"
msgstr "Einige der anderen Optionen und Schlüsselwörter sind wie folgt:"

# type: Plain text
#. type: Plain text
#: usr_40.txt:399
#, no-wrap
msgid ""
"\t-count={number}\t\tThe command can take a count whose default is\n"
"\t\t\t\t{number}.  The resulting count can be used\n"
"\t\t\t\tthrough the <count> keyword.\n"
"\t-bang\t\t\tYou can use a !.  If present, using <bang> will\n"
"\t\t\t\tresult in a !.\n"
"\t-register\t\tYou can specify a register.  (The default is\n"
"\t\t\t\tthe unnamed register.)\n"
"\t\t\t\tThe register specification is available as\n"
"\t\t\t\t<reg> (a.k.a. <register>).\n"
"\t-complete={type}\tType of command-line completion used.  See\n"
"\t\t\t\t|:command-completion| for the list of possible\n"
"\t\t\t\tvalues.\n"
"\t-bar\t\t\tThe command can be followed by | and another\n"
"\t\t\t\tcommand, or \" and a comment.\n"
"\t-buffer\t\t\tThe command is only available for the current\n"
"\t\t\t\tbuffer.\n"
msgstr ""
"\t-count={number}\t\tDer Befehl kann eine Anzahl nehmen, deren\n"
"\t\t\t\tStandard {number} ist.  Die resultierende\n"
"\t\t\t\tAnzahl kann über das Schlüsselwort <count>\n"
"\t\t\t\tverwandt werden.\n"
"\t-bang\t\t\tSie können ein ! benutzen.  Falls vorhanden,\n"
"\t\t\t\tergibt das Benutzen von <bang> ein !.\n"
"\t-register\t\tSie können ein Register angeben.  (Standard\n"
"\t\t\t\tist das unbenannte Register.)\n"
"\t\t\t\tDie Registerangabe ist verfügbar als <reg>\n"
"\t\t\t\t(aka. <register>).\n"
"\t-complete={type}\tTyp der zu verwendenden Befehlszeilen-\n"
"\t\t\t\tVervollständigung. Siehe |:command-completion|\n"
"\t\t\t\tfür die Liste möglicher Werte.\n"
"\t-bar\t\t\tDem Befehl kann | und ein anderer Befehl\n"
"\t\t\t\tfolgen, oder \" und ein Kommentar\n"
"\t-buffer\t\t\tDer Befehl ist nur für den aktuellen Puffer\n"
"\t\t\t\tverfügbar.\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:402
msgid ""
"Finally, you have the <lt> keyword.  It stands for the character <.  Use "
"this to escape the special meaning of the <> items mentioned."
msgstr ""
"Schließlich haben Sie das Schlüsselwort <lt>.  Es steht für das Zeichen "
"<.  Benutzen Sie dies, um die besondere Bedeutung der erwähnten "
"<>-Elemente aufzuheben."

# type: Plain text
#. type: Plain text
#: usr_40.txt:405
msgid "REDEFINING AND DELETING"
msgstr "NEUDEFINIEREN UND LÖSCHEN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:407
msgid "To redefine the same command use the ! argument: >"
msgstr ""
"Um denselben Befehl neu zu definieren, benutzen Sie das Argument »!«: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:410
#, no-wrap
msgid ""
"\t:command -nargs=+ Say :echo \"<args>\"\n"
"\t:command! -nargs=+ Say :echo <q-args>\n"
msgstr ""
"\t:command -nargs=+ Say :echo \"<args>\"\n"
"\t:command! -nargs=+ Say :echo <q-args>\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:413
msgid ""
"To delete a user command use \":delcommand\".  It takes a single argument, "
"which is the name of the command.  Example: >"
msgstr ""
"Um einen Benutzer-Befehl zu löschen, benutzen Sie »:delcommand«.  Er "
"nimmt ein einzelnes Argument, das der Name des Befehls ist.  Beispiel: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:415
#, no-wrap
msgid "\t:delcommand SaveIt\n"
msgstr "\t:delcommand SaveIt\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:417
msgid "To delete all the user commands: >"
msgstr "Um alle Benutzer-Befehle zu löschen: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:419
#, no-wrap
msgid "\t:comclear\n"
msgstr "\t:comclear\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:421
msgid "Careful, this can't be undone!"
msgstr "Vorsicht, dies kann nicht zurück genommen werden!"

# type: Plain text
#. type: Plain text
#: usr_40.txt:423
msgid "More details about all this in the reference manual: |user-commands|."
msgstr "Mehr Details über all dies im Referenz-Handbuch: |user-commands|."

# type: Plain text
#. type: Plain text
#: usr_40.txt:426
#, no-wrap
msgid "*40.3*\tAutocommands\n"
msgstr "*40.3*\tAutomatische Befehle\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:434
#, no-wrap
msgid ""
"An autocommand is a command that is executed automatically in response to "
"some\n"
"event, such as a file being read or written or a buffer change.  Through "
"the\n"
"use of autocommands you can train Vim to edit compressed files, for "
"example.\n"
"That is used in the |gzip| plugin.\n"
"   Autocommands are very powerful.  Use them with care and they will help "
"you\n"
"avoid typing many commands.  Use them carelessly and they will cause a lot "
"of\n"
"trouble.\n"
msgstr ""
"Ein automatischer Befehl wird automatisch als Antwort auf irgendein "
"Ereignis\n"
"ausgeführt, sei es, dass eine Datei gelesen wird, oder ein "
"Puffer-Wechsel.\n"
"Durch die Benutzung von automatischen Befehlen können Sie Vim zum "
"Beispiel\n"
"beibringen, komprimierte Dateien zu editieren.  Dies wird in dem "
"|gzip|-Plugin\n"
"benutzt.\n"
"   Automatische Befehle sind sehr mächtig.  Nutzen Sie sie sorgsam, und "
"sie\n"
"werden Ihnen sehr helfen.  Nutzen Sie sie sorglos, werden Sie Ihnen viel "
"Ärger\n"
"bereiten.\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:437
msgid ""
"Suppose you want to replace a datestamp on the end of a file every time it "
"is written.  First you define a function: >"
msgstr ""
"Angenommen, Sie haben einen Zeitstempel am Ende einer Datei, und wollen ihn "
"jedesmal, wenn die Datei geschrieben wird, ersetzen.  Zuerst definieren Sie "
"eine Funktion: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:442
#, no-wrap
msgid ""
"\t:function DateInsert()\n"
"\t:  $delete\n"
"\t:  read !date\n"
"\t:endfunction\n"
msgstr ""
"\t:function DateInsert()\n"
"\t:  $delete\n"
"\t:  read !date\n"
"\t:endfunction\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:445
msgid ""
"You want this function to be called each time, just before a file is "
"written.  This will make that happen: >"
msgstr ""
"Sie wollen diese Funktion jedesmal aufrufen, gerade bevor eine Datei "
"geschrieben wird.  Dies lässt es geschehen: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:447
#, no-wrap
msgid "\t:autocmd FileWritePre *  call DateInsert()\n"
msgstr "\t:autocmd FileWritePre *  call DateInsert()\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:455
#, no-wrap
msgid ""
"\"FileWritePre\" is the event for which this autocommand is triggered: "
"Just\n"
"before (pre) writing a file.  The \"*\" is a pattern to match with the "
"file\n"
"name.  In this case it matches all files.\n"
"   With this command enabled, when you do a \":write\", Vim checks for any\n"
"matching FileWritePre autocommands and executes them, and then it\n"
"performs the \":write\".\n"
"   The general form of the :autocmd command is as follows: >\n"
msgstr ""
"»FileWritePre« ist das Ereignis, für das dieser automatische Befehl "
"ausgelöst\n"
"wird: Gerade vor (prä) dem Sichern einer Datei.  Der »*« ist ein Muster "
"zur\n"
"Übereinstimmung mit dem Dateinamen.  In diesem Falle greift es bei allen\n"
"Dateien.\n"
"   Wenn dieser Befehl aktiv ist, und Sie »:write« geben, prüft Vim nach\n"
"jedweden automatischen Befehlen für FileWritePre und führt sie aus, und "
"macht\n"
"dann das »:write«.\n"
"   Die generelle Form des Befehls :autocmd ist wie folgt: >\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:457
#, no-wrap
msgid "\t:autocmd [group] {events} {file_pattern} [nested] {command}\n"
msgstr "\t:autocmd [group] {events} {file_pattern} [nested] {command}\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:465
#, no-wrap
msgid ""
"The [group] name is optional.  It is used in managing and calling the "
"commands\n"
"(more on this later).  The {events} parameter is a list of events (comma\n"
"separated) that trigger the command.\n"
"   {file_pattern} is a filename, usually with wildcards.  For example, "
"using\n"
"\"*.txt\" makes the autocommand be used for all files whose name end in "
"\".txt\".\n"
"The optional [nested] flag allows for nesting of autocommands (see below), "
"and\n"
"finally, {command} is the command to be executed.\n"
msgstr ""
"Der Gruppenname ist optional.  Er wird zum Verwalten und Aufrufen der "
"Befehle\n"
"verwandt (mehr dazu später).  Der Parameter {events} ist eine (komma-\n"
"getrennte) Liste von Ereignissen, die den Befehl auslösen.\n"
"   {file_pattern} ist ein Dateiname, für gewöhnlich mit Wildcards.  Das\n"
"Benutzen von »*.txt« lässt den automatischen Befehl für alle Dateien, "
"deren\n"
"Name in ».txt« endet, wirken.  Das optionale Flag [nested] erlaubt die\n"
"Verschachtelung von automatischen Befehlen, und schließlich ist {command} "
"der\n"
"auszuführende Befehl.\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:468
msgid "EVENTS"
msgstr "EREIGNISSE"

# type: Plain text
#. type: Plain text
#: usr_40.txt:473
msgid ""
"One of the most useful events is BufReadPost.  It is triggered after a new "
"file is being edited.  It is commonly used to set option values.  For "
"example, you know that \"*.gsm\" files are GNU assembly language.  To get "
"the syntax file right, define this autocommand: >"
msgstr ""
"Eines der nützlichsten Ereignisse ist BufReadPost.  Es wird ausgelöst, "
"nachdem eine neue Datei editiert wird.  Es wird für gewöhnlich zum Setzen "
"von Optionen verwandt.  Sie wissen zum Beispiel, dass »*.gsm«-Dateien "
"GNU-Assembler-Sprache sind.  Um die Syntax richtig zu bekommen, definieren "
"Sie diesen automatischen Befehl: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:475
#, no-wrap
msgid "\t:autocmd BufReadPost *.gsm  set filetype=asm\n"
msgstr "\t:autocmd BufReadPost *.gsm  set filetype=asm\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:480
msgid ""
"If Vim is able to detect the type of file, it will set the 'filetype' "
"option "
"for you.  This triggers the Filetype event.  Use this to do something when "
"a "
"certain type of file is edited.  For example, to load a list of "
"abbreviations for text files: >"
msgstr ""
"Falls Vim den Typ der Datei erkennen kann, setzt er die Option 'filetype' "
"für Sie.  Dies löst das Ereignis Filetype aus.  Benutzen Sie dies, um "
"etwas zu tun, wenn ein bestimmter Typ Dateien editiert wird.  Zum Beispiel "
"das Laden einer List von Abkürzungen für Text-Dateien: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:482
#, no-wrap
msgid "\t:autocmd Filetype text  source ~/.vim/abbrevs.vim\n"
msgstr "\t:autocmd Filetype text  source ~/.vim/abbrevs.vim\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:484
msgid ""
"When starting to edit a new file, you could make Vim insert a skeleton: >"
msgstr ""
"Beim Beginnen, eine neue Datei zu editieren, könnten Sie Vim ein Skelett "
"einfügen lassen: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:486
#, no-wrap
msgid "\t:autocmd BufNewFile *.[ch]  0read ~/skeletons/skel.c\n"
msgstr "\t:autocmd BufNewFile *.[ch]  0read ~/skeletons/skel.c\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:488
msgid "See |autocmd-events| for a complete list of events."
msgstr "Siehe |autocmd-events| für eine komplette Liste von Ereignissen."

# type: Plain text
#. type: Plain text
#: usr_40.txt:491
msgid "PATTERNS"
msgstr "MUSTER"

# type: Plain text
#. type: Plain text
#: usr_40.txt:496
#, no-wrap
msgid ""
"The {file_pattern} argument can actually be a comma-separated list of file\n"
"patterns.  For example: \"*.c,*.h\" matches files ending in \".c\" and "
"\".h\".\n"
"   The usual file wildcards can be used.  Here is a summary of the most "
"often\n"
"used ones:\n"
msgstr ""
"Das Argument {file_pattern} kann tatsächlich eine komma-getrennte Liste "
"von\n"
"Datei-Mustern sein.  »*.c,*.h« zum Beispiel trifft Dateien, die auf "
"».c« oder\n"
"».h« enden.\n"
"   Die gewöhnlichen Datei-Wildcards können benutzt werden.  Hier ist "
"eine\n"
"Zusammenfassung der am häufigsten benutzten:\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:502
#, no-wrap
msgid ""
"\t*\t\tMatch any character any number of times\n"
"\t?\t\tMatch any character once\n"
"\t[abc]\t\tMatch the character a, b or c\n"
"\t.\t\tMatches a dot\n"
"\ta{b,c}\t\tMatches \"ab\" and \"ac\"\n"
msgstr ""
"\t*\t\tTrifft jedes Zeichen jede Anzahl von Malen\n"
"\t?\t\tTrifft jegliches Zeichen einmal\n"
"\t[abc]\t\tTrifft die Zeichen a, b oder c\n"
"\t.\t\tTrifft einen Punkt\n"
"\ta{b,c}\t\tTriff »ab« und »ac«\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:510
#, no-wrap
msgid ""
"When the pattern includes a slash (/) Vim will compare directory names.\n"
"Without the slash only the last part of a file name is used.  For example,\n"
"\"*.txt\" matches \"/home/biep/readme.txt\".  The pattern \"/home/biep/*\" "
"would\n"
"also match it.  But \"home/foo/*.txt\" wouldn't.\n"
"   When including a slash, Vim matches the pattern against both the full "
"path\n"
"of the file (\"/home/biep/readme.txt\") and the relative path (e.g.,\n"
"\"biep/readme.txt\").\n"
msgstr ""
"Wenn das Muster einen Schrägstrich (/) beinhalten, vergleicht Vim\n"
"Verzeichnisnamen.  Ohne Schrägstrich wird nur der letzte Teil eines\n"
"Dateinamens benutzt.  Zum Beispiel trifft »*.txt« "
"»/home/biep/readme.txt«.\n"
"Das Muster »/home/biep/*« würde es auch treffen.  Aber nicht "
"»/home/foo/*.txt«\n"
"   Wenn ein Schrägstrich einbezogen wird, vergleicht Vim das Muster "
"sowohl\n"
"gegen den vollen Datei-Pfad (»/home/biep/readme.txt« als auch den "
"relativen\n"
"(z.B. »biep/readme.txt«).\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:516
#, no-wrap
msgid ""
"\tNote:\n"
"\tWhen working on a system that uses a backslash as file separator, such\n"
"\tas MS-Windows, you still use forward slashes in autocommands.  This\n"
"\tmakes it easier to write the pattern, since a backslash has a special\n"
"\tmeaning.  It also makes the autocommands portable.\n"
msgstr ""
"\tAnmerkung:\n"
"\tWenn Sie mit einem System arbeiten, das einen Rückwärtsschrägstrich\n"
"\tals Verzeichnistrenner benutzt, so wie MS-Windows, benutzen Sie immer\n"
"\tnoch Vorwärtsschrägstriche.  Dies macht es einfacher, das Muster zu\n"
"\tschreiben, weil ein Rückwärtsschrägstrich eine besondere Bedeutung\n"
"\that.  Es macht den automatischen Befehl außerdem portabel.\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:519
msgid "DELETING"
msgstr "LÖSCHEN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:522
msgid ""
"To delete an autocommand, use the same command as what it was defined with, "
"but leave out the {command} at the end and use a !.  Example: >"
msgstr ""
"Um einen automatischen Befehl zu löschen, benutzen Sie denselben Befehl, "
"mit dem es definiert wurde, aber lassen {command} am Ende aus und benutzen "
"ein »!«.  Beispiel: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:524
#, no-wrap
msgid "\t:autocmd! FileWritePre *\n"
msgstr "\t:autocmd! FileWritePre *\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:527
msgid ""
"This will delete all autocommands for the \"FileWritePre\" event that use "
"the \"*\" pattern."
msgstr ""
"Dies löscht alle automatischen Befehle für das Ereignis »FileWritePre«, "
"die das Muster »*« benutzen."

# type: Plain text
#. type: Plain text
#: usr_40.txt:530
msgid "LISTING"
msgstr "AUFLISTEN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:532
msgid "To list all the currently defined autocommands, use this: >"
msgstr ""
"Um alle aktuell definierten automatischen Befehle aufzulisten, benutzen Sie "
"dies: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:534
#, no-wrap
msgid "\t:autocmd\n"
msgstr "\t:autocmd\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:538
msgid ""
"The list can be very long, especially when filetype detection is used.  To "
"list only part of the commands, specify the group, event and/or pattern.  "
"For example, to list all BufNewFile autocommands: >"
msgstr ""
"Die Liste kann sehr lang sein, besonders wenn Dateityp-Erkennung benutzt "
"wird.  Um nur einen Teil der Befehle aufzulisten, geben Sie die Gruppe, das "
"Ereignis und/oder das Muster an.  Um zum Beispiel alle automatischen "
"Befehle für BufNewFile aufzulisten: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:540
#, no-wrap
msgid "\t:autocmd BufNewFile\n"
msgstr "\t:autocmd BufNewFile\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:542
msgid "To list all autocommands for the pattern \"*.c\": >"
msgstr "Um alle automatischen Befehle für das Muster »*.c« aufzulisten: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:544
#, no-wrap
msgid "\t:autocmd * *.c\n"
msgstr "\t:autocmd * *.c\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:547
msgid ""
"Using \"*\" for the event will list all the events.  To list all "
"autocommands for the cprograms group: >"
msgstr ""
"Das verwenden von »*« für das Ereignis listet alle Ereignisse auf.  Um "
"alle automatischen Befehle für die Gruppe cprograms aufzulisten: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:549
#, no-wrap
msgid "\t:autocmd cprograms\n"
msgstr "\t:autocmd cprograms\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:552
msgid "GROUPS"
msgstr "GRUPPEN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:558
#, no-wrap
msgid ""
"The {group} item, used when defining an autocommand, groups related "
"autocommands\n"
"together.  This can be used to delete all the autocommands in a certain "
"group,\n"
"for example.\n"
"   When defining several autocommands for a certain group, use the "
"\":augroup\"\n"
"command.  For example, let's define autocommands for C programs: >\n"
msgstr ""
"Das Element {group}, benutzt beim Definieren eines automatischen Befehls,\n"
"gruppiert verwandte automatische Befehle zusammen.  Dies kann zum Beispiel\n"
"benutzt werden, um alle automatischen Befehle in einer gewissen Gruppe zu\n"
"löschen.\n"
"   Wenn Sie mehrere automatische Befehle für eine gewisse Gruppe "
"definieren,\n"
"benutzen Sie den Befehl »:augroup«.  Lassen Sie uns zum Beispiel "
"automatische\n"
"Befehle für C-Programme definieren: >\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:563
#, no-wrap
msgid ""
"\t:augroup cprograms\n"
"\t:  autocmd BufReadPost *.c,*.h :set sw=4 sts=4\n"
"\t:  autocmd BufReadPost *.cpp   :set sw=3 sts=3\n"
"\t:augroup END\n"
msgstr ""
"\t:augroup cprograms\n"
"\t:  autocmd BufReadPost *.c,*.h :set sw=4 sts=4\n"
"\t:  autocmd BufReadPost *.cpp   :set sw=3 sts=3\n"
"\t:augroup END\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:565
msgid "This will do the same as: >"
msgstr "Dies tut dasselbe wie: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:568
#, no-wrap
msgid ""
"\t:autocmd cprograms BufReadPost *.c,*.h :set sw=4 sts=4\n"
"\t:autocmd cprograms BufReadPost *.cpp   :set sw=3 sts=3\n"
msgstr ""
"\t:autocmd cprograms BufReadPost *.c,*.h :set sw=4 sts=4\n"
"\t:autocmd cprograms BufReadPost *.cpp   :set sw=3 sts=3\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:570
msgid "To delete all autocommands in the \"cprograms\" group: >"
msgstr "Um alle automatischen Befehle der Gruppe »cprograms« zu löschen: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:572
#, no-wrap
msgid "\t:autocmd! cprograms\n"
msgstr "\t:autocmd! cprograms\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:575
msgid "NESTING"
msgstr "VERSCHACHTELUNG"

# type: Plain text
#. type: Plain text
#: usr_40.txt:580
msgid ""
"Generally, commands executed as the result of an autocommand event will not "
"trigger any new events.  If you read a file in response to a "
"FileChangedShell event, it will not trigger the autocommands that would set "
"the syntax, for example.  To make the events triggered, add the \"nested\" "
"argument: >"
msgstr ""
"Generell lösen Befehle, die als das Ergebnis eines automatischen Befehls "
"ausgeführt werden, keine neuen Ereignisse aus.  Falls Sie zum Beispiel "
"eine Datei als Antwort auf ein Ereignis FileChangedShell lesen, werden die "
"automatischen Befehle, die die Syntax setzen, nicht ausgelöst.  Um zu "
"erreichen, dass die Ereignisse ausgelöst werden, fügen Sie das Argument "
"»nested« hinzu: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:582
#, no-wrap
msgid "\t:autocmd FileChangedShell * nested  edit\n"
msgstr "\t:autocmd FileChangedShell * nested  edit\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:585
msgid "EXECUTING AUTOCOMMANDS"
msgstr "AUTOMATISCHE BEFEHLE AUSFÜHREN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:588
msgid ""
"It is possible to trigger an autocommand by pretending an event has "
"occurred.  This is useful to have one autocommand trigger another one.  "
"Example: >"
msgstr ""
"Es ist möglich, einen automatischen Befehl auszulösen, indem man vorgibt, "
"dass sich ein Ereignis ereignet hat.  Dies ist nützlich, um einen "
"automatischen Befehl einen anderen auslösen zu lassen.  Beispiel: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:590
#, no-wrap
msgid ""
"\t:autocmd BufReadPost *.new  execute \"doautocmd BufReadPost \" . expand(\"<afile>:r\")\n"
msgstr ""
"\t:autocmd BufReadPost *.new  execute \"doautocmd BufReadPost \" . "
"expand(\"<afile>:r\")\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:595
msgid ""
"This defines an autocommand that is triggered when a new file has been "
"edited.  The file name must end in \".new\".  The \":execute\" command uses "
"expression evaluation to form a new command and execute it.  When editing "
"the file \"tryout.c.new\" the executed command will be: >"
msgstr ""
"Dies definiert einen automatischen Befehl, der ausgelöst wird, wenn eine "
"neue Datei editiert wird.  Der Dateiname muss auf ».new« enden.  Der "
"Befehl »:execute« benutzt Ausdrucks-Auswertung, um einen neuen Befehl zu "
"formen und auszuführen.  Wenn die Datei »tryout.c.new« editiert wird, "
"ist der ausgeführte Befehl: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:597
#, no-wrap
msgid "\t:doautocmd BufReadPost tryout.c\n"
msgstr "\t:doautocmd BufReadPost tryout.c\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:601
msgid ""
"The expand() function takes the \"<afile>\" argument, which stands for the "
"file name the autocommand was executed for, and takes the root of the file "
"name with \":r\"."
msgstr ""
"Die Funktion expand() nimmt das Argument »<afile>«, was für den "
"Dateinamen steht, für den der automatische Befehl ausgeführt wurde, und "
"nimmt die Wurzel des Dateinamens mit »:r«."

# type: Plain text
#. type: Plain text
#: usr_40.txt:604
msgid ""
"\":doautocmd\" executes on the current buffer.  The \":doautoall\" command "
"works like \"doautocmd\" except it executes on all the buffers."
msgstr ""
"»:doautocmd« führt auf dem aktuellen Puffer aus.  Der Befehl "
"»:doautoall« funktioniert wie »doautocmd«, außer dass er auf allen "
"Puffern ausführt."

# type: Plain text
#. type: Plain text
#: usr_40.txt:607
msgid "USING NORMAL MODE COMMANDS"
msgstr "BEFEHLE DES NORMALEN MODUS BENUTZEN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:611
msgid ""
"The commands executed by an autocommand are Command-line commands.  If you "
"want to use a Normal mode command, the \":normal\" command can be used.  "
"Example: >"
msgstr ""
"Die Befehle, die von einem automatischen Befehl ausgeführt werden, sind "
"Befehlszeilen-Befehle.  Falls Sie einen Befehl des normalen Modus verwenden "
"wollen, kann der Befehl »:normal« benutzt werden.  Beispiel: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:613
#, no-wrap
msgid "\t:autocmd BufReadPost *.log normal G\n"
msgstr "\t:autocmd BufReadPost *.log normal G\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:625
#, no-wrap
msgid ""
"This will make the cursor jump to the last line of *.log files when you "
"start\n"
"to edit it.\n"
"   Using the \":normal\" command is a bit tricky.  First of all, make sure "
"its\n"
"argument is a complete command, including all the arguments.  When you use "
"\"i\"\n"
"to go to Insert mode, there must also be a <Esc> to leave Insert mode "
"again.\n"
"If you use a \"/\" to start a search pattern, there must be a <CR> to "
"execute\n"
"it.\n"
"   The \":normal\" command uses all the text after it as commands.  Thus "
"there\n"
"can be no | and another command following.  To work around this, put the\n"
"\":normal\" command inside an \":execute\" command.  This also makes it "
"possible\n"
"to pass unprintable characters in a convenient way.  Example: >\n"
msgstr ""
"Dies lässt den Cursor in die letzte Zeile von *.log-Dateien springen, wenn "
"Sie\n"
"beginnen, eine zu editieren.\n"
"   Den Befehl »:normal« zu verwenden ist ein wenig verzwickt.  Zuerst "
"stellen\n"
"Sie sicher, dass sein Argument ein vollständiger Befehl ist, "
"eingeschlossen\n"
"aller Argumente.  Wenn Sie »i« benutzen, um in den Einfüge-Modus zu "
"gehen,\n"
"muss es auch auch ein <Esc> geben, um den Einfüge-Modus zu verlassen.  "
"Falls\n"
"Sie »/« verwenden, um ein Suchmuster zu beginnen, muss es ein <CR> geben, "
"um\n"
"es auszuführen.\n"
"   Der Befehl »:normal« benutzt allen Text nach ihm als Befehle.  Also "
"kann es\n"
"kein | geben, dem ein weiterer Befehl folgt.  Um dies zu umgehen, packen "
"Sie\n"
"den Befehl »:normal« in einen »:execute«-Befehl.  Dies macht es auch "
"möglich,\n"
"undruckbare Zeichen auf eine angenehme Weise zu übergeben.  Beispiel: >\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:628
#, no-wrap
msgid ""
"\t:autocmd BufReadPost *.chg execute \"normal ONew entry:\\<Esc>\" |\n"
"\t\t\\ 1read !date\n"
msgstr ""
"\t:autocmd BufReadPost *.chg execute \"normal ONew entry:\\<Esc>\" |\n"
"\t\t\\ 1read !date\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:631
msgid ""
"This also shows the use of a backslash to break a long command into more "
"lines.  This can be used in Vim scripts (not at the command line)."
msgstr ""
"Dies zeigt auch den Gebrauch des Rückwärtsschrägstrichs, um einen langen "
"Befehl auf mehrere Zeilen zu verteilen.  Dies kann in Vim-Skripten verwandt "
"werden (nicht auf der Befehlszeile)."

# type: Plain text
#. type: Plain text
#: usr_40.txt:635
msgid ""
"When you want the autocommand do something complicated, which involves "
"jumping around in the file and then returning to the original position, you "
"may want to restore the view on the file.  See |restore-position| for an "
"example."
msgstr ""
"Wenn Sie wollen, dass der automatische Befehl etwas Kompliziertes macht, "
"was es beinhaltet, in der Datei herumzuspringen und dann an die "
"ursprüngliche Position zurückzukehren, mögen Sie die Ansicht der Datei "
"wiederherstellen wollen.  Siehe |restore-position| für ein Beispiel."

# type: Plain text
#. type: Plain text
#: usr_40.txt:638
msgid "IGNORING EVENTS"
msgstr "EREIGNISSE IGNORIEREN"

# type: Plain text
#. type: Plain text
#: usr_40.txt:642
msgid ""
"At times, you will not want to trigger an autocommand.  The 'eventignore' "
"option contains a list of events that will be totally ignored.  For "
"example, "
"the following causes events for entering and leaving a window to be "
"ignored: "
">"
msgstr ""
"Bisweilen wollen Sie nicht, dass ein automatischer Befehl ausgelöst wird.  "
"Die Option 'eventignore' enthält eine List von Ereignissen, die komplett "
"ignoriert werden.  Das folgende zum Beispiel lässt Ereignisse für das "
"Betreten und Verlassen eines Fensters ignorieren: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:644
#, no-wrap
msgid "\t:set eventignore=WinEnter,WinLeave\n"
msgstr "\t:set eventignore=WinEnter,WinLeave\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:646
msgid "To ignore all events, use the following command: >"
msgstr ""
"Um alle Ereignisse zu ignorieren, benutzen Sie den folgenden Befehl: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:648
#, no-wrap
msgid "\t:set eventignore=all\n"
msgstr "\t:set eventignore=all\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:650
msgid "To set it back to the normal behavior, make 'eventignore' empty: >"
msgstr ""
"Um es zum normalen Verhalten zurück zu setzen, machen Sie 'eventignore' "
"leer: >"

# type: Plain text
#. type: Plain text
#: usr_40.txt:652
#, no-wrap
msgid "\t:set eventignore=\n"
msgstr "\t:set eventignore=\n"

# type: Plain text
#. type: Plain text
#: usr_40.txt:656
msgid "Next chapter: |usr_41.txt| Write a Vim script"
msgstr "Nächstes Kapitel: |usr_41.txt| Ein Vim-Skript schreiben"

# type: Plain text
#. type: Plain text
#: usr_40.txt:657
msgid "Copyright: see |manual-copyright| vim:tw=78:ts=8:ft=help:norl:"
msgstr "Copyright: siehe |manual-copyright| vim:tw=78:ts=8:ft=help:norl:"