vimhilfe 9.1.2024-01-02T15-51-11 - en to de translation catalogue (130 entries)

note: type: description
en: For Vim version 9.1.  Last change: 2021 May 20
de: Für Vim Version 9.1.  Letzte Änderung: 20.Mai.2021

note: type: paragraph
en: VIM USER MANUAL - by Bram Moolenaar
de: VIM ANWENDERHANDBUCH - von Bram Moolenaar

note: type: paragraph
en: Splitting windows
de: Fenster aufteilen

note: type: paragraph
en: Display two different files above each other.  Or view two locations in the
    file at the same time.  See the difference between two files by putting them
    side by side.  All this is possible with split windows.
de: Zwei verschiedene Dateien übereinander anzeigen. Oder zwei verschiedene
    Stellen in einer Datei zur gleichen Zeit. Sehen Sie die Unterschiede zwischen
    zwei Dateien, indem Sie sie Seite an Seite stellen. All dies ist möglich mit
    geteilten Fenstern.

note: type: paragraph
en: |08.1|	Split a window
    |08.2|	Split a window on another file
    |08.3|	Window size
    |08.4|	Vertical splits
    |08.5|	Moving windows
    |08.6|	Commands for all windows
    |08.7|	Viewing differences with vimdiff
    |08.8|	Various
    |08.9|	Tab pages
de: |08.1|	Ein Fenster aufteilen
    |08.2|	Ein Fenster auf eine andere Datei aufteilen
    |08.3|	Fenstergröße
    |08.4|	Vertikales Aufteilen
    |08.5|	Fenster bewegen
    |08.6|	Befehle für alle Fenster
    |08.7|	Unterschiede mit "vimdiff" betrachten
    |08.8|	Verschiedenes

note: type: paragraph
en:      Next chapter: |usr_09.txt|  Using the GUI
     Previous chapter: |usr_07.txt|  Editing more than one file
    Table of contents: |usr_toc.txt|
de:   Nächstes Kapitel: |usr_09.txt|  Die GUI verwenden
    Vorheriges Kapitel: |usr_07.txt|  Mehr als eine Datei editieren
      Inhaltsübersicht: |usr_toc.txt|

note: type: paragraph
en: *08.1*	Split a window
de: *08.1*	Ein Fenster aufteilen

note: type: paragraph
en: The easiest way to open a new window is to use the following command:
de: Der einfachste Weg, ein neues Fenster zu öffnen, ist es, den folgenden Befehl
    zu verwenden:

note: type: paragraph
en: This command splits the screen into two windows and leaves the cursor in the
    top one:
de: Dieser Befehl teilt den Bildschirm in zwei Fenster und lässt den Cursor in
    dem oberen:

note: type: paragraph
en: +----------------------------------+
    |/* file one.c */		   |
    |~				   |
    |~				   |
    |one.c=============================|
    |/* file one.c */		   |
    |~				   |
    |one.c=============================|
    |				   |
    +----------------------------------+
de: +----------------------------------+
    |/* Datei eins.c */		   |
    |~				   |
    |~				   |
    |eins.c============================|
    |/* Datei eins.c */		   |
    |~				   |
    |eins.c============================|
    |				   |
    +----------------------------------+

note: type: paragraph
en: What you see here is two windows on the same file.  The line with "====" is
    the status line.  It displays information about the window above it.  (In
    practice the status line will be in reverse video.)
       The two windows allow you to view two parts of the same file.  For example,
    you could make the top window show the variable declarations of a program, and
    the bottom one the code that uses these variables.
de: Was Sie hier sehen, sind zwei Fenster auf derselben Datei. Die Zeile mit
    "====" ist die Statuszeile. Sie zeigt Informationen über das Fenster
    oberhalb an. (in der Praxis ist die Statuszeile in inverser Darstellung.)
       Die beiden Fenster erlauben Ihnen, zwei Teile derselben Datei zu
    betrachten. Zum Beispiel könnten Sie in dem oberen Fenster die Variablen-
    Deklaration eines Programms anzeigen lassen und in dem unteren den Code, der
    diese Variablen verwendet.

note: type: paragraph
en: The CTRL-W w command can be used to jump between the windows.  If you are in
    the top window, CTRL-W w jumps to the window below it.  If you are in the
    bottom window it will jump to the first window.  (CTRL-W CTRL-W does the same
    thing, in case you let go of the CTRL key a bit later.)
de: Der Befehl CTRL-W w kann verwendet werden, um zwischen den Fenstern hin und
    her zu springen. Wenn Sie in dem oberen Fenster sind, springt CTRL-W w in das
    Fenster unterhalb. Wenn Sie in dem unteren Fenster sind, springt er in das
    erste Fenster. (CTRL-W CTRL-W macht dasselbe, falls Sie die Strg-Taste ein
    wenig länger halten.)

note: type: paragraph
en: CLOSE THE WINDOW
de: DAS FENSTER SCHLIEßEN

note: type: paragraph
en: To close a window, use the command:
de: Um ein Fenster zu schließen, verwenden Sie den Befehl:

note: type: paragraph
en: Actually, any command that quits editing a file works, like ":quit" and "ZZ".
    But ":close" prevents you from accidentally exiting Vim when you close the
    last window.
de: Tatsächlich funktioniert jeder Befehl, der das Bearbeiten einer Datei
    beendet, wie ":quit" und "ZZ". Aber ":close" bewahrt Sie davor, aus
    Versehen Vim zu beenden, wenn Sie das letzte Fenster schließen.

note: type: paragraph
en: CLOSING ALL OTHER WINDOWS
de: ALLE ANDEREN FENSTER SCHLIEßEN

note: type: paragraph
en: If you have opened a whole bunch of windows, but now want to concentrate on
    one of them, this command will be useful:
de: Falls Sie eine ganze Reihe von Fenster geöffnet haben, sich aber nun auf
    eines von ihnen konzentrieren wollen, ist dieser Befehl nützlich:

note: type: paragraph
en: This closes all windows, except for the current one.  If any of the other
    windows has changes, you will get an error message and that window won't be
    closed.
de: Dies schließt alle Fenster, außer dem aktuellen. Falls irgendeines der
    anderen Fenster Änderungen hat, erhalten Sie eine Fehlermeldung, und das
    Fenster wird nicht geschlossen.

note: type: paragraph
en: *08.2*	Split a window on another file
de: *08.2*	Ein Fenster auf eine andere Datei aufteilen

note: type: paragraph
en: The following command opens a second window and starts editing the given file:
de: Der folgende Befehl öffnet ein zweites Fenster und beginnt die angegebene
    Datei zu editieren:

note: type: codeblock
en: :split two.c
de: t:split zwei.c

note: type: paragraph
en: If you were editing one.c, then the result looks like this:
de: Falls Sie zuvor eins.c editiert haben, sieht das Resultat etwa so aus:

note: type: paragraph
en: +----------------------------------+
    |/* file two.c */		   |
    |~				   |
    |~				   |
    |two.c=============================|
    |/* file one.c */		   |
    |~				   |
    |one.c=============================|
    |				   |
    +----------------------------------+
de: +----------------------------------+
    |/* Datei zwei.c */		   |
    |~				   |
    |~				   |
    |zwei.c============================|
    |/* Datei eins.c */		   |
    |~				   |
    |eins.c============================|
    |				   |
    +----------------------------------+

note: type: paragraph
en: To open a window on a new, empty file, use this:
de: Um ein Fenster mit einer neuen, leeren Datei zu öffnen, verwenden Sie dies:

note: type: paragraph
en: You can repeat the ":split" and ":new" commands to create as many windows as
    you like.
de: Sie können die Befehle ":split" und ":new" wiederholen, um so viele
    Fenster zu erzeugen, wie Sie wollen.

note: type: paragraph
en: *08.3*	Window size
de: *08.3*	Fenstergröße

note: type: paragraph
en: The ":split" command can take a number argument.  If specified, this will be
    the height of the new window.  For example, the following opens a new window
    three lines high and starts editing the file alpha.c:
de: Der Befehl ":split" kann als Argument eine Zahl annehmen. Falls angegeben,
    ist dies die Höhe des neuen Fensters. Zum Beispiel öffnet das folgende ein
    neues Fenster, das drei Zeilen hoch ist, und beginnt die Datei alpha.c zu
    bearbeiten:

note: type: paragraph
en: For existing windows you can change the size in several ways.  When you have a
    working mouse, it is easy: Move the mouse pointer to the status line that
    separates two windows, and drag it up or down.
de: Bei bestehenden Fenstern können Sie auf mehrere Arten die Größe ändern. Wenn
    Sie eine funktionierende Maus haben, ist es einfach: bewegen Sie den
    Mauszeiger auf die Statuszeile, die zwei Fenster trennt, und ziehen Sie sie
    nach oben oder unten.

note: type: paragraph
en: To increase the size of a window:
de: Um die Größe eines Fensters zu erhöhen:

note: type: paragraph
en: To decrease it:
de: Um sie zu verringern:

note: type: paragraph
en: Both of these commands take a count and increase or decrease the window size
    by that many lines.  Thus "4 CTRL-W +" make the window four lines higher.
de: Beide Befehle nehmen eine Anzahl an und erhöhen oder verringern die
    Fenstergröße um so viele Zeile. Also macht "4 CTRL-W +" das Fenster vier
    Zeilen höher.

note: type: paragraph
en: To set the window height to a specified number of lines:
de: Um die Fensterhöhe auf eine bestimmte Anzahl Zeilen zu setzen:

note: type: codeblock
en: {height}CTRL-W _
de: {Höhe}CTRL-W _

note: type: paragraph
en: That's: a number {height}, CTRL-W and then an underscore (the - key with Shift
    on English-US keyboards).
       To make a window as high as it can be, use the CTRL-W _ command without a
    count.
de: Das ist eine Anzahl {Höhe}, CTRL-W und dann ein Unterstrich (Umschalttaste -
    Minus auf deutschen Tastaturen).
       Um ein Fenster so hoch wie möglich zu machen, verwenden Sie den Befehl
    "CTRL-W _" ohne eine Anzahl.

note: type: paragraph
en: USING THE MOUSE
de: DIE MAUS VERWENDEN

note: type: paragraph
en: In Vim you can do many things very quickly from the keyboard.  Unfortunately,
    the window resizing commands require quite a bit of typing.  In this case,
    using the mouse is faster.  Position the mouse pointer on a status line.  Now
    press the left mouse button and drag.  The status line will move, thus making
    the window on one side higher and the other smaller.
de: In Vim können Sie viele Dinge sehr schnell mit der Tastatur erledigen.
    Unglücklicherweise erfordern die Befehle zu Fenstergrößen-Änderung einiges
    Tippen. In diesem Falle ist die Maus schneller. Positionieren Sie den
    Mauszeiger auf einer Statuszeile. Nun drücken Sie den linken Mausknopf und
    ziehen. Die Statuszeile bewegt sich und macht damit das Fenster auf einer
    Seite größer und das andere kleiner.

note: type: paragraph
en: OPTIONS
de: OPTIONEN

note: type: paragraph
en: The 'winheight' option can be set to a minimal desired height of a window and
    'winminheight' to a hard minimum height.
       Likewise, there is 'winwidth' for the minimal desired width and
    'winminwidth' for the hard minimum width.
       The 'equalalways' option, when set, makes Vim equalize the windows sizes
    when a window is closed or opened.
de: Die Option 'winheight' kann auf die minimal erwünschte Höhe eines Fensters
    gesetzt werden und 'winminheight' auf eine harte minimale Höhe.
       Analog gibt es 'winwidth' für die minimal erwünschte Breite und
    'winminwidth' für die harte minimale Breite.
       Die gesetzte Option 'equalalways' lässt Vim die Fenstergrößen gleich
    machen, wenn ein Fenster geschlossen oder geöffnet wird.

note: type: paragraph
en: *08.4*	Vertical splits
de: *08.4*	Vertikales Aufteilen

note: type: paragraph
en: The ":split" command creates the new window above the current one.  To make
    the window appear at the left side, use:
de: Der Befehl ":split" erzeugt das neue Fenster über dem aktuellen. Um das
    Fenster links erscheinen zu lassen, verwenden Sie:

note: type: paragraph
en: or:
de: oder:

note: type: codeblock
en: :vsplit two.c
de: :vsplit zwei.c

note: type: paragraph
en: The result looks something like this:
de: Das Ergebnis sieht etwa so aus:

note: type: paragraph
en: +--------------------------------------+
    |/* file two.c */   |/* file one.c */  |
    |~		    |~		       |
    |~		    |~		       |
    |~		    |~		       |
    |two.c===============one.c=============|
    |				       |
    +--------------------------------------+
de: +--------------------------------------+
    |/* Datei zwei.c */ |/* Datei eins.c */|
    |~		    |~		       |
    |~		    |~		       |
    |~		    |~		       |
    |zwei.c==============eins.c============|
    |				       |
    +--------------------------------------+

note: type: paragraph
en: Actually, the | lines in the middle will be in reverse video.  This is called
    the vertical separator.  It separates the two windows left and right of it.
de: Tatsächlich werden die |-Linien in der Mitte in inverser Darstellung sein.
    Dies heißt der vertikale Trenner. Er trennt die beiden Fenster links und
    rechts von ihm.

note: type: paragraph
en: There is also the ":vnew" command, to open a vertically split window on a new,
    empty file.  Another way to do this:
de: Es gibt auch den Befehl ":vnew", um ein vertikal geteiltes Fenster auf
    einer neuen, leeren Datei zu öffnen. Ein anderer Weg, dies zu machen:

note: type: paragraph
en: The ":vertical" command can be inserted before another command that splits a
    window.  This will cause that command to split the window vertically instead
    of horizontally.  (If the command doesn't split a window, it works
    unmodified.)
de: Der Befehl ":vertical" kann vor anderen Befehlen eingefügt werden, die ein
    Fenster teilen. Dies lässt den Befehl das Fenster vertikal statt horizontal
    teilen. (Wenn der Befehl kein Fenster teilt, funktioniert er unmodifiziert.)

note: type: paragraph
en: MOVING BETWEEN WINDOWS
de: ZWISCHEN FENSTERN BEWEGEN

note: type: paragraph
en: Since you can split windows horizontally and vertically as much as you like,
    you can create almost any layout of windows.  Then you can use these commands
    to move between them:
de: Da Sie Fenster horizontal und vertikal so oft aufteilen können, wie Sie
    wollen, können Sie fast jedes Fensterlayout erzeugen. Dann können Sie diese
    Befehle verwenden, um sich zwischen ihnen zu bewegen.

note: type: paragraph
en: CTRL-W h	move to the window on the left
    CTRL-W j	move to the window below
    CTRL-W k	move to the window above
    CTRL-W l	move to the window on the right
de: CTRL-W h	geht in das Fenster links
    CTRL-W j	geht in das Fenster unterhalb
    CTRL-W k	geht in das Fenster oberhalb
    CTRL-W l	geht in das Fenster rechts

note: type: paragraph
en: CTRL-W t	move to the TOP window
    CTRL-W b	move to the BOTTOM window
de: 	CTRL-W t	geht in das oberste (top) Fenster
    	CTRL-W b	geht in das unterste (bottom) Fenster

note: type: paragraph
en: You will notice the same letters as used for moving the cursor.  And the
    cursor keys can also be used, if you like.
       More commands to move to other windows: |Q_wi|.
de: Sie bemerken dieselben Buchstaben wie für das Bewegen des Cursors. Und auch
    die Pfeiltasten können verwendet werden, wenn Sie mögen.
       Weitere Befehle, um in andere Fenster zu gehen: |Q_wi|.

note: type: paragraph
en: *08.5*	Moving windows
de: *08.5*	Fenster bewegen

note: type: paragraph
en: You have split a few windows, but now they are in the wrong place.  Then you
    need a command to move the window somewhere else.  For example, you have three
    windows like this:
de: Sie haben ein paar Fenster aufgeteilt, aber nun sind Sie an der falschen
    Stelle. Dann brauchen Sie einen Befehl, um das Fenster irgendwo anders
    hinzubewegen. Sie haben zum Beispiel drei Fenster wie hier:

note: type: paragraph
en: +----------------------------------+
    |/* file two.c */		   |
    |~				   |
    |~				   |
    |two.c=============================|
    |/* file three.c */		   |
    |~				   |
    |~				   |
    |three.c===========================|
    |/* file one.c */		   |
    |~				   |
    |one.c=============================|
    |				   |
    +----------------------------------+
de: +----------------------------------+
    |/* Datei zwei.c */		   |
    |~				   |
    |~				   |
    |zwei.c============================|
    |/* Datei drei.c */		   |
    |~				   |
    |~				   |
    |drei.c============================|
    |/* Datei eins.c */		   |
    |~				   |
    |eins.c============================|
    |				   |
    +----------------------------------+

note: type: paragraph
en: Clearly the last one should be at the top.  Go to that window (using CTRL-W w)
    and then type this command:
de: Klar sollte das letzte das oberste sein. Gehen Sie in das Fenster (indem Sie
    CTRL-W w verwenden) und dann tippen Sie diesen Befehl:

note: type: paragraph
en: This uses the uppercase letter K.  What happens is that the window is moved to
    the very top.  You will notice that K is again used for moving upwards.
       When you have vertical splits, CTRL-W K will move the current window to the
    top and make it occupy the full width of the Vim window.  If this is your
    layout:
de: Dies verwendet den Großbuchstaben "K". Was passiert ist dass das Fenster ganz
    nach oben gebracht wird. Sie bemerken, dass wieder K für nach oben bewegen
    benutzt wird.
       Wenn Sie eine vertikale Aufteilung haben, bewegt CTRL-W K das aktuelle
    Fenster an den oberen Rand und lässt es die volle Breite des Vim-Fensters
    einnehmen. Wenn dies Ihr Layout ist:

note: type: paragraph
en: +-------------------------------------------+
    |/* two.c */  |/* three.c */  |/* one.c */  |
    |~	      |~	      |~	    |
    |~	      |~	      |~	    |
    |~	      |~	      |~	    |
    |~	      |~	      |~	    |
    |~	      |~	      |~	    |
    |two.c=========three.c=========one.c========|
    |					    |
    +-------------------------------------------+
de: +-------------------------------------------+
    |/* zwei.c */ |/* drei.c */   |/* eins.c */ |
    |~	      |~	      |~	    |
    |~	      |~	      |~	    |
    |~	      |~	      |~	    |
    |~	      |~	      |~	    |
    |~	      |~	      |~	    |
    |zwei.c========drei.c==========eins.c=======|
    |					    |
    +-------------------------------------------+

note: type: paragraph
en: Then using CTRL-W K in the middle window (three.c) will result in:
de: Dann resultiert das Benutzen von CTRL-W K im mittleren Fenster (drei.c) in:

note: type: paragraph
en: +-------------------------------------------+
    |/* three.c */				    |
    |~					    |
    |~					    |
    |three.c====================================|
    |/* two.c */	       |/* one.c */	    |
    |~		       |~		    |
    |two.c==================one.c===============|
    |					    |
    +-------------------------------------------+
de: +-------------------------------------------+
    |/* drei.c */				    |
    |~					    |
    |~					    |
    |drei.c=====================================|
    |/* zwei.c */	       |/* eins.c */	    |
    |~		       |~		    |
    |zwei.c=================eins.c==============|
    |					    |
    +-------------------------------------------+

note: type: paragraph
en: The other three similar commands (you can probably guess these now):
de: Die anderen drei ähnlichen Befehle (Sie können sie nun sicher raten):

note: type: paragraph
en: CTRL-W H	move window to the far left
    CTRL-W J	move window to the bottom
    CTRL-W L	move window to the far right
de: CTRL-W H	bewegt Fenster an den linken Bildschirmrand
    CTRL-W J	bewegt Fenster an den unteren Rand
    CTRL-W L	bewegt Fenster an den linken Rand

note: type: paragraph
en: *08.6*	Commands for all windows
de: *08.6*	Befehle für alle Fenster

note: type: paragraph
en: When you have several windows open and you want to quit Vim, you can close
    each window separately.  A quicker way is using this command:
de: Wenn Sie mehrere Fenster offen haben und Vim beenden wollen, können Sie jedes
    Fenster getrennt schließen. Ein schnellerer Weg ist es diesen Befehl zu
    verwenden:

note: type: paragraph
en: This stands for "quit all".  If any of the windows contain changes, Vim will
    not exit.  The cursor will automatically be positioned in a window with
    changes.  You can then either use ":write" to save the changes, or ":quit!" to
    throw them away.
de: Dies steht für "quit all" (beendet alle). Falls eines der Fenster
    Änderungen enthält, beendet sich Vim nicht. Der Cursor wird automatisch in
    einem Fenster mit Änderungen positioniert. Dann können Sie entweder
    ":write" benutzen, um die Änderungen zu sichern, oder "quit!", um sie
    alle wegzuwerfen.

note: type: paragraph
en: If you know there are windows with changes, and you want to save all these
    changes, use this command:
de: Falls Sie wissen, dass es Fenster mit Änderungen gibt, und Sie wollen alle
    diese Änderungen sichern, verwenden Sie diesen Befehl:

note: type: paragraph
en: This stands for "write all".  But actually, it only writes files with
    changes.  Vim knows it doesn't make sense to write files that were not
    changed.
       And then there is the combination of ":qall" and ":wall": the "write and
    quit all" command:
de: Dies steht für "write all" (schreibt alle). Aber tatsächlich schreibt er nur
    Dateien mit Änderungen. Vim weiß, dass es keinen Sinn ergibt, Dateien zu
    schreiben, die nicht geändert wurden.
       Und dann ist da die Kombination aus ":qall" und ":wall": der Befehl "write
    and quit all" (schreibe und beende alle):

note: type: paragraph
en: This writes all modified files and quits Vim.
       Finally, there is a command that quits Vim and throws away all changes:
de: Dies schreibt alle modifizierten Dateien und beendet Vim.
       Schließlich gibt es einen Befehl, der Vim beendet und alle Änderungen
    wegwirft:

note: type: paragraph
en: Be careful, there is no way to undo this command!
de: Seien Sie vorsichtig, es gibt keine Möglichkeit, diesen Befehl
    zurückzunehmen!

note: type: paragraph
en: OPENING A WINDOW FOR ALL ARGUMENTS
de: EIN FENSTER FÜR ALLE ARGUMENTE ÖFFNEN

note: type: paragraph
en: To make Vim open a window for each file, start it with the "-o" argument:
de: Um Vim ein Fenster für jede Datei öffnen zu lassen, starten Sie ihn mit dem
    Argument "-o":

note: type: codeblock
en: vim -o one.txt two.txt three.txt
de: vim -o eins.txt zwei.txt drei.txt

note: type: paragraph
en: This results in:
de: Dies ergibt:

note: type: paragraph
en: +-------------------------------+
    |file one.txt			|
    |~				|
    |one.txt========================|
    |file two.txt			|
    |~				|
    |two.txt========================|
    |file three.txt			|
    |~				|
    |three.txt======================|
    |				|
    +-------------------------------+
de: +-------------------------------+
    |Datei eins.txt			|
    |~				|
    |eins.txt=======================|
    |Datei zwei.txt			|
    |~				|
    |zwei.txt=======================|
    |Datei drei.txt			|
    |~				|
    |drei.txt=======================|
    |				|
    +-------------------------------+

note: type: paragraph
en: The "-O" argument is used to get vertically split windows.
       When Vim is already running, the ":all" command opens a window for each
    file in the argument list.  ":vertical all" does it with vertical splits.
de: Das Argument "-O" wird verwendet, um vertikal geteilte Fenster zu erhalten.
       Wenn Vim bereits läuft, öffnet der Befehl ":all" ein Fenster für jede Datei
    in der Argumentenliste. ":vertical all" ergibt eine vertikale Teilung.

note: type: paragraph
en: *08.7*	Viewing differences with vimdiff
de: *08.7*	Unterschiede mit "vimdiff" betrachten

note: type: paragraph
en: There is a special way to start Vim, which shows the differences between two
    files.  Let's take a file "main.c" and insert a few characters in one line.
    Write this file with the 'backup' option set, so that the backup file
    "main.c~" will contain the previous version of the file.
       Type this command in a shell (not in Vim):
de: Es gibt eine besondere Art, Vim zu starten, die die Unterschiede zwischen
    zwei Dateien zeigt. Lassen Sie uns eine Datei "main.c" nehmen und ein Paar
    Zeichen in einer Zeile einfügen. Schreiben Sie diese Datei mit gesetzter
    'backup'-Option, so dass die Sicherheitskopie "main.c~" die vorige Version
    der Datei enthält.
       Tippen Sie diesen Befehl in einer Shell (nicht in Vim):

note: type: paragraph
en: Vim will start, with two windows side by side.  You will only see the line
    in which you added characters, and a few lines above and below it.
de: Vim startet mit zwei Fenstern Seite an Seite. Sie sehen nur die Zeile, in der
    Sie Zeichen hinzugefügt haben, und ein Paar Zeilen unter- und oberhalb.

note: type: paragraph
en:  VV		      VV
    +-----------------------------------------+
    |+ +--123 lines: /* a|+ +--123 lines: /* a|  <- fold
    |  text		     |	text		  |
    |  text		     |	text		  |
    |  text		     |	text		  |
    |  text		     |	changed text	  |  <- changed line
    |  text		     |	text		  |
    |  text		     |	------------------|  <- deleted line
    |  text		     |	text		  |
    |  text		     |	text		  |
    |  text		     |	text		  |
    |+ +--432 lines: text|+ +--432 lines: text|  <- fold
    |  ~		     |	~		  |
    |  ~		     |	~		  |
    |main.c~==============main.c==============|
    |					  |
    +-----------------------------------------+
de:  VV		      VV
    +-----------------------------------------+
    |+ +--123 lines: /* a|+ +--123 lines: /* a|  <- Faltung
    |  text		     |	text		  |
    |  text		     |	text		  |
    |  text		     |	text		  |
    |  text		     |	changed text	  |  <- geänderte Zeile
    |  text		     |	text		  |
    |  text		     |	------------------|  <- gelöschte Zeile
    |  text		     |	text		  |
    |  text		     |	text		  |
    |  text		     |	text		  |
    |+ +--432 lines: text|+ +--432 lines: text|  <- Faltung
    |  ~		     |	~		  |
    |  ~		     |	~		  |
    |main.c~==============main.c==============|
    |					  |
    +-----------------------------------------+

note: type: paragraph
en: (This picture doesn't show the highlighting, use the vimdiff command for a
    better look.)
de: (Dieses Bild zeigt nicht die Hervorhebung, verwenden Sie den Befehl vimdiff
    für eine bessere Ansicht.)

note: type: paragraph
en: The lines that were not modified have been collapsed into one line.  This is
    called a closed fold.  They are indicated in the picture with "<- fold".  Thus
    the single fold line at the top stands for 123 text lines.  These lines are
    equal in both files.
       The line marked with "<- changed line" is highlighted, and the inserted
    text is displayed with another color.  This clearly shows what the difference
    is between the two files.
       The line that was deleted is displayed with "---" in the main.c window.
    See the "<- deleted line" marker in the picture.  These characters are not
    really there.  They just fill up main.c, so that it displays the same number
    of lines as the other window.
de: Die Zeilen, die nicht modifiziert wurden, werden zu einer Zeile
    zusammengefasst. Dies nennt sich geschlossene Faltung. Sie werden in dem
    Bild durch "<- Faltung" angezeigt. Also steht die einzelne Faltungszeile am
    Anfang für 123 Textzeilen. Diese Zeilen sind in beiden Dateien gleich.
       Die mit "<- geänderte Zeile" markierte Zeile wird hervorgehoben, und der
    eingefügte Text wird in einer anderen Farbe angezeigt. Dies zeigt deutlich,
    was der Unterschied zwischen den beiden Dateien ist.
       Die gelöschte Zeile wird mit "---" in dem Fenster von main.c angezeigt.
    Siehe die Markierung "<- gelöschte Zeile" in dem Bild. Diese Zeichen sind
    nicht wirklich da. Sie füllen nur main.c, so dass sie dieselbe Anzahl Zeilen
    wie das andere Fenster anzeigt.

note: type: paragraph
en: THE FOLD COLUMN
de: DIE FALTUNGSSPALTE

note: type: paragraph
en: Each window has a column on the left with a slightly different background.  In
    the picture above these are indicated with "VV".  You notice there is a plus
    character there, in front of each closed fold.  Move the mouse pointer to that
    plus and click the left button.  The fold will open, and you can see the text
    that it contains.
       The fold column contains a minus sign for an open fold.  If you click on
    this -, the fold will close.
       Obviously, this only works when you have a working mouse.  You can also use
    "zo" to open a fold and "zc" to close it.
de: Jedes Fenster hat links eine Spalte mit einem etwas anderen Hintergrund. In
    dem obigen Bild werden diese durch "VV" angezeigt. Sie bemerken, dass ein
    Plus vor jeder geschlossenen Faltung ist. Bewegen Sie den Mauszeiger auf
    dieses Plus und klicken Sie den linken Knopf. Die Faltung öffnet sich, und
    Sie können den Text sehen, den sie enthält.
       Die Faltungsspalte enthält ein Minuszeichen für eine offene Faltung. Wenn
    Sie auf dieses Minus klicken, schließt sich die Faltung.
       Offensichtlich funktioniert dies nur, wenn Sie eine funktionierende Maus
    haben. Sie können auch "zo" verwenden, um eine Faltung zu öffnen, und
    "zc", um sie zu schließen.

note: type: paragraph
en: DIFFING IN VIM
de: DIFFEN IN VIM

note: type: paragraph
en: Another way to start in diff mode can be done from inside Vim.  Edit the
    "main.c" file, then make a split and show the differences:
de: Eine andere Art, den Diff-Modus zu starten, kann aus Vim erledigt werden.
    Bearbeiten Sie die Datei "main.c", dann machen Sie eine Aufteilung und
    zeigen die Unterschiede:

note: type: paragraph
en: The ":vertical" command is used to make the window split vertically.  If you
    omit this, you will get a horizontal split.
de: Der Befehl ":vertical" wird verwendet, um das Fenster vertikal aufzuteilen.
    Falls Sie dies auslassen, erhalten Sie eine horizontale Aufteilung.

note: type: paragraph
en: If you have a patch or diff file, you can use the third way to start diff
    mode.  First edit the file to which the patch applies.  Then tell Vim the name
    of the patch file:
de: Falls Sie eine Patch- oder Diff-Datei haben, können Sie die dritte Art
    verwenden, den Diff-Modus zu starten. Zuerst bearbeiten Sie die Datei, auf
    die der Patch angewendet wird. Dann geben Sie Vim den Namen der Patch-Datei
    an:

note: type: paragraph
en: WARNING: The patch file must contain only one patch, for the file you are
    editing.  Otherwise you will get a lot of error messages, and some files might
    be patched unexpectedly.
       The patching will only be done to the copy of the file in Vim.  The file on
    your harddisk will remain unmodified (until you decide to write the file).
de: WARNUNG: Die Patch-Datei darf nur einen Patch enthalten, für die Datei, die
    Sie bearbeiten. Ansonsten bekommen Sie viele Fehlermeldungen, und einige
    Dateien könnten unerwartet gepatcht werden.
       Das Patchen wird nur auf die Kopie der Datei in Vim angewendet. Die Datei
    auf Ihrem Speichermedium bleibt unmodifiziert (bis Sie sich entscheiden, die
    Datei zu schreiben).

note: type: paragraph
en: SCROLL BINDING
de: SCROLL-BINDUNG

note: type: paragraph
en: When the files have more changes, you can scroll in the usual way.  Vim will
    try to keep both the windows start at the same position, so you can easily see
    the differences side by side.
       When you don't want this for a moment, use this command:
de: Wenn die Dateien mehr Änderungen haben, können Sie wie üblich blättern. Vim
    versucht, beide Fenster an derselben Position starten zu lassen, so dass Sie
    einfach die Unterschiede Seite an Seite sehen können.
       Wenn Sie dies für einen Moment nicht wollen, verwenden Sie diesen Befehl:

note: type: paragraph
en: JUMPING TO CHANGES
de: ZU ÄNDERUNGEN SPRINGEN

note: type: paragraph
en: When you have disabled folding in some way, it may be difficult to find the
    changes.  Use this command to jump forward to the next change:
de: Wenn Sie irgendwie das Falten deaktiviert haben, mag es schwer sein, die
    Änderungen zu finden. Verwenden Sie diesen Befehl, um vorwärts zur nächsten
    Änderung zu springen:

note: type: paragraph
en: To go the other way use:
de: Für die andere Richtung verwenden Sie:

note: type: paragraph
en: Prepended a count to jump further away.
de: Stellen Sie eine Anzahl voran, um weiter weg zu springen.

note: type: paragraph
en: REMOVING CHANGES
de: ÄNDERUNGEN ENTFERNEN

note: type: paragraph
en: You can move text from one window to the other.  This either removes
    differences or adds new ones.  Vim doesn't keep the highlighting updated in
    all situations.  To update it use this command:
de: Sie können Text von einem Fenster zum anderen bewegen. Dies entfernt entweder
    Unterschiede oder fügt neue hinzu. Vim hält nicht in allen Situationen die
    Hervorhebung aktuell. Um sie zu aktualisieren, verwenden Sie diesen Befehl:

note: type: paragraph
en: To remove a difference, you can move the text in a highlighted block from one
    window to another.  Take the "main.c" and "main.c~" example above.  Move the
    cursor to the left window, on the line that was deleted in the other window.
    Now type this command:
de: Um einen Unterschied zu entfernen, können Sie den Text in einem
    hervorgehobenen Block von einem Fenster zu einem anderen bewegen. Nehmen Sie
    das Beispiel "main.c" und "main.c~" oben. Bewegen Sie den Cursor in das
    linke Fenster, auf die Zeile, die im anderen Fenster gelöscht wurde. Nun
    tippen Sie diesen Befehl:

note: type: paragraph
en: The change will be removed by putting the text of the current window in the
    other window.  "dp" stands for "diff put".
       You can also do it the other way around.  Move the cursor to the right
    window, to the line where "changed" was inserted.  Now type this command:
de: Die Änderung wird entfernt, indem der Text des aktuellen Fensters in dem
    anderen Fenster eingefügt wird. "dp" steht für "diff put".
       Sie können es auch anders herum machen. Bewegen Sie den Cursor in das
    rechte Fenster, zu der Zeile wo "changed" eingefügt wurde. Nun tippen Sie
    diesen Befehl:

note: type: paragraph
en: The change will now be removed by getting the text from the other window.
    Since there are no changes left now, Vim puts all text in a closed fold.
    "do" stands for "diff obtain".  "dg" would have been better, but that already
    has a different meaning ("dgg" deletes from the cursor until the first line).
de: Die Änderung wird nun entfernt, indem der Text aus dem anderen Fenster geholt
    wird. Weil nun keine Änderungen mehr übrig sind, stellt Vim allen Text in
    eine geschlossene Faltung. "do" steht für "diff obtain" (beziehen).
    "dg" wäre besser gewesen, aber das hat schon eine andere Bedeutung ("dgg"
    löscht vom Cursor bis zur ersten Zeile).

note: type: paragraph
en: For details about diff mode, see |vimdiff|.
de: Zu den Detail zum Diff-Modus siehe |vimdiff|.

note: type: paragraph
en: *08.8*	Various
de: *08.8*	Verschiedenes

note: type: paragraph
en: The 'laststatus' option can be used to specify when the last window has a
    statusline:
de: Die Option 'laststatus' kann verwendet werden, um anzugeben, wann das letzte
    Fenster eine Statuszeile hat:

note: type: paragraph
en: 0	never
    1	only when there are split windows (the default)
    2	always
de: 0	nie
    1	nur bei mehreren Fenstern (Voreinstellung)
    2	immer

note: type: paragraph
en: Many commands that edit another file have a variant that splits the window.
    For Command-line commands this is done by prepending an "s".  For example:
    ":tag" jumps to a tag, ":stag" splits the window and jumps to a
    tag.
       For Normal mode commands a CTRL-W is prepended.  CTRL-^ jumps to the
    alternate file, CTRL-W CTRL-^ splits the window and edits the alternate file.
de: Viele Befehle, die eine andere Datei bearbeiten, haben eine Variante, die
    das Fenster aufteilt. Bei Befehlen auf der Befehlszeile wird ein "s"
    voran gestellt. Zum Beispiel springt ":tag" auf ein Tag. ":stag" teilt
    das Fenster und springt auf ein Tag.
       Befehlen im Normalmodus wird ein CTRL-W vorangestellt. CTRL-^ springt zu
    der alternativen Datei, CTRL-W CTRL-^ teilt das Fenster und bearbeit die
    alternative Datei.

note: type: paragraph
en: The 'splitbelow' option can be set to make a new window appear below the
    current window.  The 'splitright' option can be set to make a vertically split
    window appear right of the current window.
de: Die Option 'splitbelow' kann gesetzt werden, um ein neues Fenster unter dem
    aktuellen Fenster erscheinen zu lassen. Die Option 'splitright' kann gesetzt
    werden, um beim vertikalen Aufteilen das neue Fenster rechts vom aktuellen
    erscheinen zu lassen.

note: type: paragraph
en: When splitting a window you can prepend a modifier command to tell where the
    window is to appear:
de: Beim Fensteraufteilen können Sie einen Modifizierungsbefehl voranstellen, der
    sagt, wo das Fenster erscheinen soll:

note: type: paragraph
en: :leftabove {cmd}	left or above the current window
    :aboveleft {cmd}	idem
    :rightbelow {cmd}	right or below the current window
    :belowright {cmd}	idem
    :topleft {cmd}		at the top or left of the Vim window
    :botright {cmd}		at the bottom or right of the Vim window
de: :leftabove {bef}	links oder über dem aktuellen Fenster
    :aboveleft {bef}	ebenso
    :rightbelow {bef}	rechts oder unterhalb des aktuellen Fensters
    :belowright {bef}	ebenso
    :topleft {bef}		am oberen oder linken Rand des Vim-Fensters
    :botright {bef}		am unteren oder rechten Rand des Vim-Fensters

note: type: paragraph
en: *08.9*	Tab pages
de: *08.9*	Reiterseiten

note: type: paragraph
en: You will have noticed that windows never overlap.  That means you quickly run
    out of screen space.  The solution for this is called Tab pages.
de: Sie werden bemerkt haben, dass sich Fenster nie überlappen. Dass bedeutet,
    dass der Platz schnell knapp werden kann. Die Lösung hierfür nennt sich Reiterseiten (tab pages).

note: type: paragraph
en: Assume you are editing "thisfile".  To create a new tab page use this command:
de: Nehmen Sie an, Sie bearbeiteh "diesedatei". Um eine neue Reiterseite zu erzeugen, verwenden Sie diesen Befehl:

note: type: codeblock
en: :tabedit thatfile
de: :tabedit jenedatei

note: type: paragraph
en: This will edit the file "thatfile" in a window that occupies the whole Vim
    window.  And you will notice a bar at the top with the two file names:
de: Dies vearbeite die Datei "jenedatei" in einem neuen Fenster, das das ganze
    Vim-Fenster einnimmt. Und Sie bemerken am oberen Bildschirmrand eine Leiste
    mit den beiden Dateinamen:

note: type: paragraph
en: +----------------------------------+
    | thisfile | /thatfile/ __________X|    (thatfile is bold)
    |/* thatfile */			   |
    |that				   |
    |that				   |
    |~				   |
    |~				   |
    |~				   |
    |				   |
    +----------------------------------+
de: +----------------------------------+
    | diesedatei | /jenedatei/ _______X|    (jenedatei ist fett)
    |/* jenedatei */		   |
    |jenes				   |
    |jenes				   |
    |~				   |
    |~				   |
    |~				   |
    |				   |
    +----------------------------------+

note: type: paragraph
en: You now have two tab pages.  The first one has a window for "thisfile" and the
    second one a window for "thatfile".  It's like two pages that are on top of
    each other, with a tab sticking out of each page showing the file name.
de: Sie haben nun zwei Reiterseiten. Die erste hat ein Fenster für "diesedatei"
    und die zweite ein Fenster für "jenedatei". Es verhält sich wie zwei Seiten
    übereinander, mit einem herausschauenden Reiter, der den Dateinamen anzeigt.

note: type: paragraph
en: Now use the mouse to click on "thisfile" in the top line.  The result is
de: Nun klicken Sie mit der Maus auf "diesedatei" in der obersten Zeile. Das
    Ergebnis ist:

note: type: paragraph
en: +----------------------------------+
    | /thisfile/ | thatfile __________X|    (thisfile is bold)
    |/* thisfile */			   |
    |this				   |
    |this				   |
    |~				   |
    |~				   |
    |~				   |
    |				   |
    +----------------------------------+
de: +----------------------------------+
    | /diesedatei/ | jenedatei _______X|    (diesedatei ist fett)
    |/* diesedatei */		   |
    |dieses				   |
    |dieses				   |
    |~				   |
    |~				   |
    |~				   |
    |				   |
    +----------------------------------+

note: type: paragraph
en: Thus you can switch between tab pages by clicking on the label in the top
    line.  If you don't have a mouse or don't want to use it, you can use the "gt"
    command.  Mnemonic: Goto Tab.
de: Also können Sie, indem Sie auf die Markierung in der obersten Zeile klicken,
    zwischen Reiterseiten wechseln. Falls Sie keine Maus haben oder sie nicht
    verwenden wollen, können Sie den Befehl "gt" verwenden. Merkhilfe: Goto Tab
    (gehe zu Reiter

note: type: paragraph
en: Now let's create another tab page with the command:
de: Lassen Sie uns nun mit folgendem Befehl eine weitere Reiterseite erzeugen:

note: type: paragraph
en: This makes a new tab page with one window that is editing the same buffer as
    the window we were in:
de: Dies erzeugt eine neue Reiterseite mit einem Fenster, das denselben Puffer
    editiertwie das Fenster wo wir waren:

note: type: paragraph
en: +-------------------------------------+
    | thisfile | /thisfile/ | thatfile __X|   (thisfile is bold)
    |/* thisfile */			      |
    |this				      |
    |this				      |
    |~				      |
    |~				      |
    |~				      |
    |				      |
    +-------------------------------------+
de: +----------------------------------------+
    | diesedatei | /diesedatei/ | jenedatei X|   (diesedatei ist fett)
    |/* diesedatei */		         |
    |dieses				         |
    |dieses				         |
    |~				         |
    |~				         |
    |~				         |
    |				         |
    +----------------------------------------+

note: type: paragraph
en: You can put ":tab" before any Ex command that opens a window.  The window will
    be opened in a new tab page.  Another example:
de: Sie können ":tab" vor jeden Ex-Befehl setzen, der ein Fenster öffnet. Das
    Fenster wird in einer neuen Reiterseite geöffnet. Noch ein Beispiel:

note: type: paragraph
en: Will show the help text for "gt" in a new tab page.
de: ... zeigt den Hilfetext für "gt" in einer neuen Reiterseite.

note: type: paragraph
en: A few more things you can do with tab pages:
de: Ein paar weitere Dinge, die Sie mit Reiterseiten tun können:

note: type: paragraph
en: - click with the mouse in the space after the last label
    	The next tab page will be selected, like with "gt".
de: - klicken Sie mit der Maus in den Bereich nach dem letzten Label
    	Die nächste Reiterseite wird ausgewählt, wie mit "gt".

note: type: paragraph
en: - click with the mouse on the "X" in the top right corner
    	The current tab page will be closed.  Unless there are unsaved
    	changes in the current tab page.
de: - klicken Sie mit der Maus auf das "X" in der oberen rechten Ecke
    	Die aktuelle Reiterseite wird geschlossen. Außer es gibt ungesicherte
    	Änderungen in der aktuellen Reiterseite.

note: type: paragraph
en: - double click with the mouse in the top line
    	A new tab page will be created.
de: - doppelklicken Sie mit der Maus in die oberste Zeile
    	Eine neue Reiterseite wird erzeugt.

note: type: paragraph
en: - the "tabonly" command
    	Closes all tab pages except the current one.  Unless there are unsaved
    	changes in other tab pages.
de: - der Befehl ":tabonly"
    	Schließt alle Reiterseiten außer der aktuellen. Außer es gibt
    	ungesicherte Änderungen in anderen Reiterseiten.

note: type: paragraph
en: For more information about tab pages see |tab-page|.
de: Für weitere Informationen zu Reiterseiten siehe |tab-page|.

note: type: paragraph
en: Next chapter: |usr_09.txt|  Using the GUI
de: Nächstes Kapitel: |usr_09.txt|  Die GUI verwenden

note: type: paragraph
en: Copyright: see |manual-copyright|  vim:tw=78:ts=8:noet:ft=help:norl:
de: Copyright: siehe |manual-copyright|  vim:tw=78:ts=8:noet:ft=help:norl:
