Die zsh lässt sich auf quasi allen Linuxsystemen über die Paketverwaltung installieren. Unter Ubuntu z.B. mit dem Befehl

sudo apt-get install zsh

Danach kann man sie mit dem Aufruf von zsh ausführen. Um sie zur Standardshell zu machen genügt der Befehl

chsh -s /usr/bin/zsh username

Wobei username durch den entsprechenden Usernamen ersetzt werden muss und der Pfad zu zsh stimmen muss. Auf manchen Systemen liegt zsh in /bin. Wo zsh liegt kann man mit dem folgenden Befehl heraus finden:

which zsh

Die zsh bedient sich Elementen der Bash, der Korn-Shell (ksh) und der TENEX-C-Shell (tcsh – eine erweiterte C-Shell). Sie ist sehr gut konfigurierbar und fast jedes Verhalten der Bash kann nachgeahmt werden so dass der Umstieg sehr leicht fällt. Bestehende Bash-Scripte können natürlich weiterhin genutzt werden, wenn der Shebang entsprechend gesetzt ist. Also in der ersten Zeile folgendes steht:

#!/bin/bash

Im Folgenden werde ich einige interessante Vorteile der zsh kurz beschreiben. Zu einzelnen Themen werde wahrscheinlich in anderen Artikel ausführlicher eingehen. Dies sollen also nur Beispiele sein, die die Mächtigkeit demonstrieren sollen. Da die zsh so viele Möglichkeiten bietet ist es nicht möglich hier alles im Detail zu erläutern. Optionen werden mit dem Befehl setopt gesetzt. Dies kann man auch so in die Konfigurationsdatei ~/.zshrc schreiben.

Autokorrektur
Die zsh beherrscht einen Mechanismus, der kleine Tippfehler automatisch korrigiert. Hat man in einem Ordner eine Datei testfile.txt und möchte diese kopieren nach file2.txt, so führt man in der Regel folgenden Befehl aus:

cp testfile.txt file2.txt

wie von der Bash gewohnt nutzt man dafür die Autovervollständigung mittels TAB. Bei einem Verschreiber wird dieser in der zsh automatisch korrigiert. Beispiel:

cp tsetf<TAB>

wird automatisch korrigiert und zu

cp testfile.txt

vervollständigt.

Die Autokorrektur aktiviert man mit der Option correct

Globale Aliase
Neben den normalen Aliasen für Kommandos, wie man sie aus der Bash kennt, gibt es in der zsh noch globale Aliase, die überall im Befehl genutzt werden können, nicht nur am Anfang. Zwei Beispiele verdeutlichen dies:

alias -g G='| grep'
alias -g L='| less'

erzeugt die globalen Aliase G und L die man hinter alle möglichen Befehle schreiben kann um die Ausgabe des entsprechenden Befehls in grep oder less zu pipen. Z.B.

ls G txt

entspricht dem Befehl

ls | grep txt

oder

ps -e L

entspricht

ps -e | less

Natürlich ist auch folgendes Möglich:

ls G txt L

was folgendem Befehl entspricht:

ls | grep txt | less

Suffix Aliase
Mit Suffixaliasen kann man Programme festlegen, mit denen bestimmte Dateitypen (anhand ihrer Endung) geöffnet werden sollen. Man braucht dann nur noch den Namen der Datei eingeben und sie wird mit dem entsprechenden Programm geöffnet. Beispiel:

alias -s pdf=evince

legt einen Alias für pdf Dateien an. Sie sollen mit evince geöffnet werden. Danach reicht die Eingabe von

dokument.pdf

und die Datei dokument.pdf wird mit evince geöffnet.

Aliase für Verzeichnisse: Hashes
Mit sogenannten Hashes lassen sich Aliase für beliebige Verzeichnisse anlegen. Auf diese kann dann sehr einfach zugegriffen werden. Mit dem Befehl

hash -d perl=~/developement/scripting/perl

legt man einen Hash namens perl für das Verzeichnis ~/developement/scripting/perl an. Auf dieses Verzeichnis kann man jetzt mit ~perl zugreifen. Auch innerhalb eines Befehls wie folgendes Beispiel zeigt:

cp testscript.pl ~perl

Dieser Befehl kopiert die Datei testscript.pl in das Verzeichnis ~/developement/scripting/perl.

Auto-CD
Mit der Option autocd kann man zum Wechseln in ein Verzeichnis einfach den Namen eines Verzeichnisses eingeben und das Kommando cd davor einfach weglassen. Wenn es keinen Befehl gibt, der so heißt wie das Verzeichnis, so wird in das Verzeichnis gewechselt.

Kurze for-Schleifen
Statt einem

for i in *.eps; do epstopdf $i; done

um alle eps-Dateien in einem Verzeichnis in pdf-Dateien umzuwandeln genügt unter zsh die kürzere Form

for i (*.eps) epstopdf $i

Globale History
Die History, die man mit der Pfeil-auf Taste durchgehen kann, kann man in der zsh so einstellen, dass sie in jeder zsh-Instanz gleich ist. Das heißt man hat nicht mehr für jedes Fenster seine eigene History sondern kann mit der Pfeil-auf Taste auch Befehle raussuchen, die in anderen Fenstern eingegeben wurden. Die History wird jedoch nur nach jedem Befehl geupdated, das heißt man muss ggf. einmal Return drücken, damit die Befehle aus einem anderen Fenster verfügbar sind.

Dieses Verhalten kann mit der Option share_history aktiviert werden.

Directory Stack
Wie Bash, hat die zsh auch einen Directory stack. Mit dem Befehl pushd kann man das aktuelle Verzeichnis auf den Stack legen und mit popd das jeweils letzte Verzeichnis vom Stack nehmen und dorthin springen. Mit der Option auto_pushd legt die zsh automatisch jedes Verzeichnis auf den Directorystack, aus welchem man in ein anderes Verzeichnis wechselt. So hat man immer eine History der Verzeichnisse in denen man war und kann mit popd sehr einfach wieder in Verzeichnisse welchseln, die man vorher besucht hatte.

Globbing
Die Nutzung von Wildcards – unter zsh globbing genannt – ist bei der Z-Shell wesentlich mächtiger als in der Bash. Zunächst gibt es rekursives Globbing (gibts in der Bash in neueren Versionen wohl auch). So kann man mit dem Befehl

ls **/*.html

alle HTML-Dateien im aktuellen Verzeichnis und allen Unterverzeichnissen auflisten lassen.

Es gibt jedoch auch noch Qualifier um Dateien mit bestimmten Eigenschaften auszuwählen. Diese schreibt man in runde Klammern. So kann man mit . normale Dateien, mit / Verzeichnisse und mit @ Symbolische Links matchen. Praktisch ist das z.B. wenn man allen Verzeichnissen ab einem bestimmten Verzeichnis die Rechte 755 und allen Dateien 644 vergeben möchte. Dies kann man mit den folgenden zwei Befehlen bewerkstelligen statt mit find und exec zu arbeiten.

chmod 755 **/*(/)
chmod 644 **/*(.)

Zusätzlich gibt es auch Qualifier für verschiedenste Dateirechte. Folgender Befehl listet alle Dateien auf, die von allen beschrieben werden können:

ls **/*(.W)

Auch nach der Dateigröße lässt sich suchen:

print **/*(L0)

listet alle leeren Dateien auf.

Auch die Sortierung lässt sich beliebig anpassen. Mit dem Befehl:

print *(oL)

Listet alle Dateien der Größe nach von klein nach groß auf. Mit großem O wird die Sortierung umgekehrt.

Somit lässt sich mittels globbing in der zsh das Kommando find quasi komplett ersetzen. Die hier gezeigten Beispiele sehen auf den ersten Blick recht kompliziert und kryptisch aus. Wenn man das Prinzip aber einmal verstanden hat und die wichtigsten Qualifier kennt ist es aber ganz einfach und sehr praktisch.

Es gibt noch jede Menge weiterer Qualifier und Möglichkeiten für das Globbing (z.B. nur das erste oder eine bestimmte Anzahl von Elementen auszuwählen), die ich hier gar nicht alle erwähnen kann. Im zsh-Manual gibt es jedoch eine Liste der Glob-Qualifier.

Um alle Möglichkeiten nutzen zu können sollte die Option extended_glob gesetzt werden.

Vervollständigung
Die zsh hat wie die Bash einen Vervollständigungsmechanismus, so dass man mit der TAB-Taste Kommandos, Dateinamen und vieles mehr vervollständigen kann. In der zsh ist dieser Mechanismus jedoch extrem gut konfigurierbar und programierbar. So kann man z.B. beim scp Befehl (der Dateien über ssh kopiert) die Verzeichnisse auf dem entfernten Rechner vervollständigen und genau definieren welche Programme mit welchen Dateitypen zusammen arbeiten können. Für sehr viele Programme ist dies schon vorgefertigt, so dass ein

latex doku<TAB>

automatisch zu

 latex dokument.tex

vervollständigt wird. Dies beherrscht die Bash zum Teil auch. Jedoch ist es in der zsh wesentlich besser konfigurierbar und anpassbar.

Sehr praktisch finde ich auch die Menüfunktion. So wird beim ersten Druck auf die TAB-Taste wie in der Bash soweit vervollständigt, bis nicht mehr entschieden werden kann welche Datei (bzw. welcher Befehl) gemeint ist. Ein weiterer Druck auf die TAB-Taste listet alle weiteren Möglichkeiten auf und jeder weitere Druck geht diese Möglichkeiten durch. Wenn ich also drei Dateien habe: test.txt, testfile1.txt und testfile2.txt und gebe folgendes ein:

ls te<TAB>

so wird zuerst auf test vervollständigt. Ein weiterer Druck gibt mir alle Möglichkeiten aus:

testfile1.txt  testfile2.txt  test.txt

und ein dritter Druck auf die Tab-Taste vervollständigt den Befehl zu

ls testfile1.txt

Das ist viel schneller als erst ein f einzugeben um erneut TAB zu drücken und dann die 1 einzugeben um wiederum TAB zu drücken bis der Dateiname endgültig vervollständigt wird.

Ein weiterer Druck auf TAB nimmt dann die nächste Möglichkeit. In diesem Beispiel also

ls testfile2.txt

und so weiter.

Expansion
Mit der TAB-Taste kann man in der zsh nicht nur Kommandos, Dateinamen, … vervollständigen, sondern auch Variablen expandieren. Viele kennen ja die spezielle Variable !!, die den zuletzt ausgeführten Befehl enthält. In der zsh kann man nun folgendes eingeben:

!!<TAB>

und die Variable !! wird automatisch zum zuletzt ausgeführten Befehl expandiert. Genauso kann man auch jede andere Variable expandieren:

$PWD<TAB>

wird zu /home/zimon/developement (vorrausgesetzt ich befinde mich zum Zeitpunkt der expansion in diesem Verzeichnis).

History Kontrolle
Wie bei der Bash auch, kann man in der zsh die History durchsuchen. Die zsh geht jedoch so weit, dass man auch nach bestimmten Parametern suchen kann. Ein Beispiel:

cp ../perl/foo.pl ~/developement/projektordner

Danach kommen ein paar andere Kommandos. Möchte nun eine andere Datei in den gleichen Projektordner kopieren reicht folgende Eingabe:

cp ../perl/bar.pl !?proj?:3

Mit !? wird nach einem vorherigen Befehl gesucht. Das proj ist ein String der in diesem Befehl vorkam. Mit dem ?:3 wird das dritte Argument genutzt. Durch die Expansion kann manmit durch einen Druck auf TAB diesen Ausdruck auch noch expandieren um sicher zu gehen, dass das richtige Argument ausgewählt wurde. Man kann zwar mit Alt+. wie in der Bash die jeweils letzten Argumente durchgehen, auf diese Weise kann man aber auch das zweite von drei Argumenten suchen.

Es gibt noch wesentlich mehr Möglichkeiten die History zu durchsuchen und zu verwenden.

Hochkonfigurierbarer Prompt
In der Z-Shell kann man nicht nur die linke Seite des Prompts sondern auch die rechte Seite konfigurieren. Als Beispiel hier mal mein aktueller Prompt:

Mein aktueller zsh-Prompt

Ich finde die Anzeige der Uhrzeit inklusive Sekunden recht praktisch, da man daran sieht wie lange ein Befehl gedauert hat oder wann man ihn ausgeführt hat. Es gibt jedoch auch die Möglichkeit automatisch die Ausgabe von time bei der Beendigung eines Befehls ausgeben zu lassen, der länger als eine vorher definierte Zeit benötigt hat.

Der Prompt ist eine abgeänderte Version von Phil!s ZSH Prompt.

[UPDATE] Auf Anfrage hin ist hier noch der Code für die von mir abgeänderte Version des Prompts:

setprompt () {
    ###
    # Need this so the prompt will work.
 
    setopt prompt_subst
 
 
    ###
    # See if we can use colors.
 
    autoload colors zsh/terminfo
    if [[ "$terminfo[colors]" -ge 8 ]]; then
	colors
    fi
    for color in RED GREEN YELLOW BLUE MAGENTA CYAN WHITE; do
	eval PR_$color='%{$terminfo[bold]$fg[${(L)color}]%}'
	eval PR_LIGHT_$color='%{$fg[${(L)color}]%}'
	(( count = $count + 1 ))
    done
    PR_NO_COLOUR="%{$terminfo[sgr0]%}"
 
 
    ###
    # See if we can use extended characters to look nicer.
 
    typeset -A altchar
    set -A altchar ${(s..)terminfo[acsc]}
    PR_SET_CHARSET="%{$terminfo[enacs]%}"
    PR_SHIFT_IN="%{$terminfo[smacs]%}"
    PR_SHIFT_OUT="%{$terminfo[rmacs]%}"
    PR_HBAR=${altchar[q]:--}
    PR_ULCORNER=${altchar[l]:--}
    PR_LLCORNER=${altchar[m]:--}
    PR_LRCORNER=${altchar[j]:--}
    PR_URCORNER=${altchar[k]:--}
 
    if [[ "$TERM" == "screen" ]]; then
	PR_HBAR=-
     	PR_ULCORNER=--
    	PR_LLCORNER=--
    	PR_LRCORNER=--
    	PR_URCORNER=-
   fi 
 
 
    ###
    # Decide if we need to set titlebar text.
 
    case $TERM in
	xterm*)
	    PR_TITLEBAR=$'%{\e]0;%(!.-=*[ROOT]*=- | .)%n@%m:%~ | ${COLUMNS}x${LINES} | %y\a%}'
	    ;;
	screen)
	    PR_TITLEBAR=$'%{\e_screen \005 (\005t) | %(!.-=[ROOT]=- | .)%n@%m:%~ | ${COLUMNS}x${LINES} | %y\e\\%}'
	    ;;
	*)
	    PR_TITLEBAR=''
	    ;;
    esac
 
 
    ###
    # Decide whether to set a screen title
    if [[ "$TERM" == "screen" ]]; then
        PR_STITLE=$'%{\ekzsh\e\\%}'
    else
        PR_STITLE=''
    fi
 
 
    ###
    # Finally, the prompt.
 
    PROMPT='$PR_SET_CHARSET$PR_STITLE${(e)PR_TITLEBAR}\
$PR_RED$PR_SHIFT_IN$PR_ULCORNER$PR_BLUE$PR_HBAR$PR_SHIFT_OUT(\
$PR_GREEN%(!.%SROOT%s.%n)$PR_GREEN@%m:%l\
$PR_BLUE)$PR_SHIFT_IN$PR_HBAR$PR_RED$PR_HBAR${(e)PR_FILLBAR}$PR_BLUE$PR_HBAR$PR_SHIFT_OUT(\
$PR_MAGENTA%$PR_PWDLEN<...<%~%<<\
$PR_BLUE)$PR_SHIFT_IN$PR_HBAR$PR_RED$PR_URCORNER$PR_SHIFT_OUT\
 
$PR_RED$PR_SHIFT_IN$PR_LLCORNER$PR_BLUE$PR_HBAR$PR_SHIFT_OUT(\
%(?..$PR_LIGHT_RED%?$PR_BLUE:)\
${(e)PR_APM}$PR_YELLOW%D{%H:%M:%S}\
$PR_BLUE)$PR_SHIFT_IN$PR_HBAR$PR_SHIFT_OUT\
$PR_RED$PR_SHIFT_IN$PR_HBAR$PR_SHIFT_OUT\
$PR_NO_COLOUR '
 
    RPROMPT=' $PR_RED$PR_SHIFT_IN$PR_HBAR$PR_BLUE$PR_HBAR$PR_SHIFT_OUT\
($PR_YELLOW%D{%a,%b%d}$PR_BLUE)$PR_SHIFT_IN$PR_HBAR$PR_RED$PR_LRCORNER$PR_SHIFT_OUT$PR_NO_COLOUR'
 
    PS2='$PR_RED$PR_SHIFT_IN$PR_HBAR$PR_SHIFT_OUT\
$PR_BLUE$PR_SHIFT_IN$PR_HBAR$PR_SHIFT_OUT(\
$PR_LIGHT_GREEN%_$PR_BLUE)$PR_SHIFT_IN$PR_HBAR$PR_SHIFT_OUT\
$PR_RED$PR_SHIFT_IN$PR_HBAR$PR_SHIFT_OUT$PR_NO_COLOUR '
 
}
 
setprompt

[/UPDATE]

ZLE-Widgets
Der Z-Line-Editor (ZLE) ist quasi die Eingabezeile in der zsh. Dafür kann man sich kleine Programme schreiben, die einem das Leben vereinfachen. Ein Beispiel wäre ein Programm, dass bei der Eingabe von ... diese zu ../.. umwandelt. Jeder weitere Punkt wird wieder umgewandelt. So kann man recht einfach folgendes eingeben:

cd ..../directory

Auf dem Bildschirm erscheint jedoch folgendes:

cd ../../../directory

Dieses Widget ist kein Standard bei der Z-Shell. Man kann es aber durch folgenden Code in der Konfigurationsdatei ~/.zshrc erzeugen:

rationalise-dot() {
    if [[ $LBUFFER = *.. ]]; then
        LBUFFER+=/..
    else
        LBUFFER+=.
            fi
}
zle -N rationalise-dot
bindkey . rationalise-dot

Automatisches tee-ing
In der Z-Shell kann man die Ausgabe eines Kommandos recht einfach in mehrere verschiedene Dateien umleiten. Statt wie in der Bash

ls | tee -a all | tee actual

zu schreiben, kann man in der zsh einfach

ls >>all >actual

eingeben. Beide Befehle führen ls aus und hängen die Ausgabe an die Datei all an und schreiben sie in die Datei actual wobei der inhalt jeweils überschrieben wird.
Möchte man die Ausgabe wie beim original tee Befehl auch auf dem Bildschirm sehen, so leitet man sie auch noch auf STDOUT um:

ls >>all >actual >&1

Verzeichnisse durch Ersetzung wechseln
Ein Beispiel sollte dies am besten Erklären. Man nehme an man hat zwei Verzeichnisse: ~/developement/scripting/perl/modules und ~/developement/scripting/python/modules und man befindet sich in ~/developement/scripting/perl/modules, so kann man durch den Befehl

cd perl python

in das Verzeichnis ~/developement/scripting/python/modules wechseln. Bei einem cd Kommando mit zwei Parametern wird im aktuellen Verzeichnis-String das erste Wort durch das zweite ersetzt. Hier also perl durch python.

Fazit
Ich bin jetzt nicht 100% sicher, dass alles hier beschriebene nicht auch in der Bash möglich ist. Es zeigt aber auf jeden Fall, dass die Z-Shell jede Menge interessante Möglichkeiten bietet und man viele Dinge einfacher und schneller erledigen kann als in der Bash. Die oben gezeigten Features sind meist nur angerissen und nur eine kleine Auswahl von dem was die Z-Shell bietet. Darüber hinaus besitzt die Z-Shell eine ganze Reihe Module z.B. für Matheoperationen oder einen eigenen FTP-Client, die man bei Bedarf laden kann.

Sehr schön ist auch die Möglichkeit den Screen-Title von der zsh aus zu setzen.

Es lohnt sich auf jeden Fall, diese Shell etwas genauer zu betrachten. Bei mir hat sie mittlerweile die Bash fast vollständig ersetzt (vorhandene Scripte habe ich nicht umgeschrieben).

Links

• Offizielle zsh Projektseite (englisch)
• zsh Manual (englisch)
• zsh User’s Guide (englisch)
• Michael Prokops zsh Seite – Seite mit Features und Beispielen wo zsh mit Bash verglichen wird
• Michael Prokops zsh Liebhaberseite – Viele gute Beispiele und zsh Tricks angelehnt an das zsh-lovers Projekt.
• zsh wiki – Wiki über zsh (englisch)
• zsh-lovers – Sammlung von Tipps, Tricks und Beispielen (englisch)
• grml zsh Seite – Seite mit sehr großer zsh-Konfigurationsdatei, Referenzkarte und anderen zsh Infos. Die grml-Linuxdistribution hat zsh als Standardshell. (englisch)
• strcat.de/zsh/ – Seite mit Auflistung vieler Features und Tipps (englisch)
• Zzappers Best of ZSH Tips – Viele zsh Tipps (englisch)

Screenshot des Single-Window Modus von Gimp 2.7

Es gibt jedoch auch Beführworter des Multi-Window Modus, da man mehrere Fenster leichter auf verschiedene Bildschirme verteilen kann.

Ich habe mir mal die Entwicklerversion (2.7) installiert und (vor allem den Single-Window Modus ) angesehen.

Installation

Zuerst müssend die build-utils, git sowie einige Abhängigkeiten installiert werden. Unter Ubuntu kann man dies mit dem folgenden Befehl erreichen:

sudo apt-get build-dep gimp libtool ruby git-core git-doc git-email

Als nächstes wird git konfiguriert. Dafür die folgenden beiden Befehle ausführen, wobei beim ersten Befehl der Name eingegeben wird und beim zweiten die Emailadresse:

git config --global user.name "Your Name"
git config --global user.email you@host

Nun werden die aktuellen Entwickerversionen von babl, gegl und gimp ausgecheckt:

git clone git://git.gnome.org/babl
git clone git://git.gnome.org/gegl
git clone git://git.gnome.org/gimp

Um eine bereits installiertes Gimp weiter benutzen zu können, wird die Entwicklerversion in das Verzeichnis /usr/local/gimp-git installiert.
Dafür wird dieses Verzeichnis angelegt und dort ein Verzeichnis share erstellt. Nun legt man die Datei /usr/local/gimp-git/share/config.site mit folgendem Inhalt an:

export PKG_CONFIG_PATH="/usr/local/gimp-git/lib/pkgconfig:$PKG_CONFIG_PATH"
export LD_LIBRARY_PATH="/usr/local/gimp-git/lib:$LD_LIBRARY_PATH"

Wenn es Probleme gibt, dass die neueste babl-Version nicht gefunden werden kann, können die beiden Befehle auch nochmal in der aktuellen Shell ausgeführt werden.

Die Leserechte müssen auch noch entsprechend gesetzt werden:

chmod -R oug+rx /usr/local/gimp-git
chmod oug-x /usr/local/gimp-git/share/config.site

Nun werden babl, gegl und schließlich gimp selbst kompiliert und installiert:

cd babl
./autogen.sh --prefix=/usr/local/gimp-git
make
sudo make install
 
cd ../gegl
./autogen.sh --prefix=/usr/local/gimp-git
make
sudo make install
 
cd gimp
./autogen.sh --prefix=/usr/local/gimp-git --disable-gtk-doc
make
sudo make install

Nun kann man gimp-2.7 mit folgendem Befehl starten:

/usr/local/gimp-git/bin/gimp-2.7

Ein Alias in der ~/.bashrc erleichtert den Aufruf:

alias gimp-git='/usr/local/gimp-git/bin/gimp-2.7'

Single-Window-Mode

Nachdem ich alle Menüs in den Einstellungen durchforstet habe und auch in einige Konfigurationsdateien geschaut habe, habe ich die Funktion für den Single-Window-Mode schließlich unter dem Menüpunkt “Fenster” gefunden.

Es sieht schon ziemlich schick aus. Auch wenn viele Kleinigkeiten noch nicht so richtig Funktionieren. Wenn die Dialoge an der Seite sind, reagieren sie manchmal nicht (oder nur teilweise). Abhilfe schaft auch manchmal den Modus wieder zurück zu wechseln und erneut in den Single-Window Modus zu wechseln. Versucht man einen Dialog unter den Werkzeugkasten (oder an eine andere Stelle an der Seite) zu platzieren, stürzt das ganze Programm mit einem segmentation fault ab.

Im Moment ist es noch sehr emfehlenswert, bei der Version 2.6 zu bleiben und die Entwicklerversion nur zum Ausprobieren zu nutzen. Dies gilt besonders für den Single-Window Modus, da dieser noch nicht sehr stabil läuft. Das wird sich aber sicherlich in der nächsten Zeit noch ändern.

[UPDATE]Mittlerweile funktioniert der Single-Window Modus recht gut und stabil, so dass man ihn nun verwenden kann. Man sollte jedoch im Hinterkopf behalten, dass sich das Programm noch im Entwicklungsstadium befindet und Fehler auftreten können.

Übrigens soll Gimp 2.8 frühestens Ende des Jahres (2010) erscheinen, wie man der Developer-Mailingliste entnehmen kann.[/UPDATE]

Den Screenshot in voller Auflösung habe ich hier verlinkt (am besten in einem nuen Tab oder Fenster öffnen).

Nachdem man die Dateien des Plugins nach ~/.vim/plugin/ kopiert hat, kann man die Befehle :VCSUpdate und :VCSCommitnutzen um die aktuelle Datei zu Updaten bzw. seine Änderungen zu committen. Dafür muss die Datei jedoch bereits unter Versionskontrolle stehen.
Beim Commit öffnet sich ein Splitscreen, in den man die Logmessage eintragen kann. Mittels :wq oder \cc wird diese übernommen. Um ohne Logmessage zu Committen, kann man das Kommando mit einem Ausrufezeichen aufrufen: :VCSCommit!.

Es gibt auch Abkürzungen für die Kommandos. So kann man statt :VCSCommit auch den Befehl \cc nutzen, der das gleiche bewirkt. Genauso kann man mit \cu updaten.

Auch die anderen Kommandos sind im Prinzip die SVN Kommandos mit vorrangestelltem VCS. In Klammern steht jeweils die Kurzvariante:

• :VCSAdd – (\ca) zum Hinzufügen von Dateien zum Repository
• :VCSDelete – (\cD) zum Löschen
• :VCSStatus – (\cs) um den Status der Datei anzuzeigen
• :VCSDiff – (\cd) um den Unterschied zur letzten Version anzuzgeigen
• :VCSLog – (\cl) zeigt die bereits getätigten commits mit ihren Logmessages an

Statt :VCSDiff kann man auch :VCSVimDiff (\cv) nutzen um die Unterschiede mittels Vimdiff zu betrachten.

Um ganze Verzeichnisse mit dem CVSCommand-Plugin zu verwalten, kann man die Dateibrower-Funktion des Vim nutzen und die entsprechenden Kommandos bei einem geöffneten Verzeichnis ausführen.

Es gibt natürlich noch weitere Kommandos und Einstellungsmöglichkeiten. Diese sind in der Hilfe näher beschrieben, die man mittels :h vcscommand aufrufen kann.

Zur Installation wird das Archiv surround.zip im Verzeichnis ~/.vim entpackt.

Grundsätzlich lehnt sich die Bedienung an das Konzept an, den Text zwischen Klammern, Anführungszeichen,… zu ändern so wie es im Artikel Vim Bewegungskommandos im Abschnitt “Spezielle Bewegungskommandos” beschrieben ist.

Text Umschließen
Die Syntax zum Umschließen von Text ist:
ys<BEWEGUNG><ZEICHEN>

Beispiele:

• ysis" – der aktuelle Satz wird mit doppelten Anführungszeichen umschlossen.
• ysiw<b> – versieht das aktuelle Wort mit mit dem HTML-Tag b, so dass es fett angezeigt wird.
• yss) – umschließt die aktuelle Zeile mit runden Klammern.
• ysi)" – umschließt den Text zwischen den Klammern mit doppelten Anführungszeichen.
• ysa") – umschließt den den Text zwischen den doppelten Anführungszeichen und die Anführungszeichen selbst mit runden Klammern.

Statt den Bewegungskommandos kann man auch im visuellen Modus den gewünschten Text markieren. Dann drückt man s gefolgt vom gewünschten Zeichen.
Beispiel: s" um den markierten Text mit doppelten Anführungszeichen zu umschließen.

Damit man es sich besser vorstellen kann hier ein konkretes Beispiel. Die folgende Zeile:

Dies ist eine Beispielzeile

wird durch yss" zu

"Dies ist eine Beispielzeile"

Liegt der Cursor auf dem Wort “eine”, so kann man mit ysiw) das Wort mit Klammern umschließen:

"Dies ist (eine) Beispielzeile"

Umschließung ändern
Um die Umschließung von Text zu ändern nutzt man folgende Syntax:
cs<AKTUELLES_ZEICHEN><NEUES_ZEICHEN>

Beispiele:

• cst" – ändert das XML/HTML-Tag zu doppelten Anführungszeichen.
• cs"' – ändert doppelte in einfache Anführungszeichen.
• cs)} – ändert runde in geschweifte Klammern.

Umschließung löschen
Die Syntax um eine Umschließung zu löschen ist:
ds<ZEICHEN>

Beispiele:

• ds] – löscht eckige Klammern.
• ds' – löscht einfache Anführungszeichen.
• dst – löscht XML/HTML-Tags.

Wiederholen
Leider funktioniert das Wiederholen des letzten Kommandos mit Punkt nicht mit dem Surround-Plugin. Jedoch kann man es mit dem Plugin repeat zum funktionieren bringen.
Dafür kopiert man die Datei repeat.vim in das Verzeichnis ~/.vim/autoload/. Nachdem man . (Punkt) gedrückt hat muss man jedoch das Zeichen, welches eingefügt werden soll wiederholen.

Abhilfe schafft ansonsten auch die Nutzung von Makros. Dabei können häufig genutzte Surroundings auch als Makro in die ~/.vimrc gespeichert werden.
Folgende Zeile definiert das Register k so, dass beim Aufruf des Makros k mittels @k das aktuelle Wort in runde Klammern eingeschlossen wird:

let @k="ysiw)"

Fauchi95 hat mich gefragt, ob man nicht ein Whois-Plugin schreiben könnte, da ist es mir wieder eingefallen

Die Bedienung ist so wie man es sich denkt. Man sendet dem Bot ein whois gefolgt von der gewünschten Domain und bekommt das Ergebnis zurück gesendet.

Beispiel:

whois zinformatik.de

Zum Installieren des Plugins kopiert man die Datei Whois.pm in das Verzeichnis plugins im Hauptverzeichnis des zBot und startet dann den Bot neu.

Download:
Whois.pm

Sobald das Plugin installiert ist (indem die Datei tasklist.vim nach ~/.vim/plugin/ kopiert wurde), kann man die TODO-Liste mit \t generieren und angezeigen.

Dabei öffnet sich ein horizontaler Splitscreen, in dem alle Vorkommen von TODO, XXX und FIXME sortiert nach Vorkommen und mit Angabe der Zeilennummer aufgeführt werden. Dabei wird auch der Rest der Zeile hinter dem Schlüsselwort angezeigt, so dass man auch sehen kann worum es bei einem TODO geht.

Wenn man mit j und k durch die Liste navigiert wird die entsprechende Textstelle im eigentlichen Text jeweils automatisch angesprungen. Drückt man Enter, so schließt sich der Splitscreen und man befindet sich an der Stelle des zuletzt ausgewählten TODOs im Text.

Die mit DONE gekennzeichneten Textstellen werden unter den noch offenen TODOs angezeigt. Ansonsten funktionieren sie genauso wie TODOs.

Nach jedem Speichervorgang kann die Liste mit \t neu generiert werden.

Ein mit POV-Ray generiertes Bild

Mit dem quelloffnen Raytracer POV-Ray kann man sehr realitätsnahe Bilder erzeugen. Anders als bei den meisten anderen 3D-Grafikprogrammen arbeitet man hier nicht mit einer graphischen Oberfläche und Maus sondern beschreibt die Objekte textbasiert über dessen Positionen in einem Koordinatensystem.

[UPDATE]Artikel nochmals überarbeitet und Beispiel hinzugefügt.[/UPDATE]

Was ist Raytracing?
Raytracing ist eine Methode um Computergenerierte Bilder zu erzeugen. Der Unterschied zum Rendering besteht darin, dass keine Gittermodelle mit Texturen belegt werden und die Farbe dann mittels des Lichtes berechnet wird sondern eine Strahlenverfolgung statt findet, wodurch viel realistischere Bilder entstehen. Leider ist dieses Verfahren auch wesentlich rechenintensiver. Dafür bekommt man Schatten und Spiegelungen quasi geschenkt, was mit Rendering relativ schwer zu realisieren ist. (Siehe auch: http://de.wikipedia.org/wiki/Raytracing)

Einen guten Eindruck, was POV-Ray leisten kann bekommt man in der Galerie der POV-Ray Homepage.

Download und Installation
POV-Ray steht unter einer eigenen Lizenz, die zwar das Einsehen des Quelltextes, aber nicht die veränderte Weitergabe im Sinne freier Software erlaubt (was sich aber bald ändern soll, siehe Kommentare).

Das Programm ist für alle gängigen Betriebssysteme verfügbar und kann sogar in einem Cluster (also auf mehreren PC’s gleichzeitig) verwendet werden.
[UPDATE]POV-Ray kann unter Ubuntu mittels sudo apt-get install povray installiert werden.
Ansonsten kann man die Binärdateien von der Homepage beziehen[/UPDATE]

Grundsätzliche Funktionsweise
In einer Scenenbeschreibungssprache werden alle Objekte, Lichtquellen und die Kamera an 3D-Positionen im Raum definiert (z.B. Kugel an Stelle x,y,z mit Radius r und Farbe rot). Daneben gibt es noch viele weitere Optionen um bestimmte Materialien zu simulieren. Daraus wird dann das Bild berechnet.

Zitat:

Der Qualität und dem Anspruch der gerenderten Bilder sind keine theoretischen Grenzen gesetzt;
in der Praxis ist die zur Verfügung stehende Rechen- oder Computer-Zeit der begrenzende Faktor.

Quelle: http://de.wikipedia.org/wiki/Povray

Interessant ist Povray durch seine Scenenbeschreibungssprache auch wegen der Automatisierbarkeit.
z.B. ist EAGLE ein Programm um elektronische Schaltungen zu entwerfen und daraus entsprechende Boardlayouts zu konstruieren. Mittels eines Scripts kann man sich die Platine zu einem fertigen Layout vor dem eigentlichen Bau mit POV-Ray Rendern lassen um sich ansehen zu können, wie es später aussehen wird. (Macht sich sehr gut in Ausarbeitungen oder um vorab etwas präsentieren zu können.)

Das Board-Layout eines USB<->UART Konverters

Das mit POV-Ray aus dem Board-Layout generierte Bild

Ein Foto der fertigen Platine (um 180° gedreht)

Übrigens ist der linke Teil meines Banners (oben auf der Seite) auch ein Teil einer mit POV-Ray gerenderten Platine. Der Rechte Teil ist ein Ausschnitt des EALGE Layouts, aus dem es generiert wurde.

Beispiel
Im folgenden Beispiel wird eine einfache Scene erstellt. Zuerst wird eine Datei mit Farbdefinitionen eingebunden, damit man nicht jede Farbe als RGB-Wert eingeben braucht. Danach wird eine Kamera definiert. Dabei gibt man die Position an, wo sie sich befinden soll und die Position, auf die die Kamera zeigen soll.
Als nächstes muss noch eine Lichtquelle definiert werden, damit man auch etwas sehen kann. Diese wird mit dem Schlüsselwort light_source eingeleitet und hat eine Position und eine Farbe. Nun können die einzelnen Objekte definiert werden.
Als Boden wird eine Ebene definiert, die schwarz-weiß kariert ist und waagerecht auf der Höhe -1 liegt. Die Koordinaten geben die Lage der Ebene an, die immer Senkrecht auf dem angegebenen Vektor liegt. Dahinter kann man ein Offset (der Abstand zum Nullpunkt), in diesem Fall also die Höhe angeben.
Die Farbe wird mit dem Schlüsselwort “pigment” angegeben. Da die Ebene Kariert sein soll nutzen wir hier die Option “checker” gefolgt von zwei Farbwerten.
Durch die Include-Anweisung am Anfang können hier die Namen der Farben verwendet werden. Ansonsten müsste man den RGB-Wert angeben.
Der Himmel wird durch ein “sky_sphere”-Objekt erzeugt, welches entlang der y-Achse (“gradient y”) von Hellblau nach Blau verläuft (“color_map”).
Nun kann man noch weitere Objekte auf der Ebene platzieren. Eine Kugel (sphere) besitzt einen Mittelpunkt und eine Durchmesser und natürlich auch eine Farbe.
Ein Kegel (cone) hat zwei Koordinaten, die den Mittelpunkte der beiden Enden entsprechen sowie je einen Durchmesser an jedem Ende.

Neben der Farbe kann auch noch die Oberflächenstruktur und -Politur definiert werden. Für die Struktur ist das Schlüsselwort “normal” zuständig, die Politur wird mittels “finish” angegeben. Im Beispiel wird der 2. Kugel eine reflektierende Politur gegeben, so dass sie die anderen Objekte spiegelt. (je höher der Reflektionswert, desto stärker die Spiegelung.

Nun der Code des Beispiels:

#include "colors.inc"
 
camera {    // Die Kamera
    location <2, 3, -6>
    look_at <0, 1, 2>
}
 
light_source { // Die Lichtquelle
    <3, 5, -4>
    color White
}
 
plane { // Eine Ebene
    <0, 1, 0>, -1
    pigment { checker color White, color Black }
} 
 
sky_sphere { // Der Himmel
    pigment {
        gradient y
        color_map { [0.0 color rgb <0.7,0.7,1.0>] [1.0 color blue 0.5] }
    }
}
 
sphere { // eine Kugel
    <-3, 1, 4>, 2
    pigment { color Yellow }
}  
 
cone{   // Ein Kegel
    <3,-1,3>,1,<2.5,4,4>,0
    pigment{color Green}
}
 
sphere { // Eine reflektierende Kugel
    <0, 2.5, 10>, 3
    finish{
        reflection {
            0.8       
        }
    }
}

Das Ergebnis des Beispiels

Sonstige Funktionen
POV-Ray kennt noch eine ganze Menge weiterer Objekte, die sich auch zusammenfassen lassen. Man kann auch – wie in der Mengenlehre – ein Objekt von einem anderen abziehen oder die Schnittmenge zweier Objekte berechnen (und anzeigen).
Auch bei den Farben und Oberflächenstrukturen bzw. -Polituren gibt es noch viele weitere Möglichkeiten und Optionen.

Die Objekte können skaliert (in der Größe geändert) rotiert und translatiert (verschoben) werden.
Es können auch Kontrollstrukturen wie bei Programmiersprachen genutzt werden. So kann man Variablen deklarieren, Schleifen und Verzweigungen nutzen sowie Funktionen (bei POV-Ray Makros genannt) definieren um automatisch eine Reihe von Objekten zu erzeugen und zu transformieren.

Man kann mit POV-Ray auch Animationen erstellen. Dafür werden per Script mehrere Bilder erstellt, wobei vor jedem Bild eine Variable verändert wird. Diese kann genutzt werden um die Kamera oder Objekte zu bewegen.
Hier einige Beispiele (auf Youtube gibt es noch jede Menge weitere)

Click here to view the embedded video.

Click here to view the embedded video.

Links

• http://www.povray.org – Offizielle Homepage von POV-Ray (englisch)
• http://hof.povray.org – Gallerie auf der Seite von POV-Ray. Sollte man sich in jedem Fall mal ansehen, auch wenn man sonst kein Interesse am Programm hat. (Die Bilder kann man durch einen Klick darauf vergrößert ansehen)
• http://de.wikibooks.org/wiki/Raytracing_mit_POV-Ray – Deutsches Buch über POV-Ray auf Wikibooks
• http://www.basti-info.de/pov-ray/inhalt.htm – Eine deutsche Einführung in POV-Ray
• http://www.f-lohmueller.de/pov_tut/pov__ger.htm POV-Ray – Tutorials auf deutsch
• http://de.wikipedia.org/wiki/Povray – Wikipedia Artikel zu POV-Ray
• http://www.oyonale.com/modeles.php?format=POV&lang=en – Einige freie Objekte für POV-Ray auf der Website von Gilles Tran

ls -lh | less

Die vim-User wird es freuen, dass viele Kommandos die gleichen wie bei vim sind oder ihnen zumindest ähneln.

Navigation
Navigieren kann man in less neben den Pfeiltasten wie in vim mit h,j,k und l. (Strg+)u und (Strg+)d sowie (Strg+)f und (Strg+)b haben die Funktion, halbe bzw. ganze Bildschirmseiten herunter und hoch zu springen. Die Strg-Taste ist dabei optional. Auch mit Space kann man einen Bildschirm herunter scrollen.
g springt zum Anfang und G zum Ende des Dokuments.

Man kann sich auch anzeigen lassen, welche Zeile die erste ungelesene im Text ist, wenn man mehr als eine Zeile hinunter scrollt. Diese wird dann markiert. So findet man schnell die Stelle wieder, an der man aufgehört hat zu lesen. Dazu startet man less mit der Option -W.

Less kennt auch Markierungen wie vim. Allerdings sind diese immer Dateiübergreifend und es können nur Kleinbuchstaben genutzt werden. Mit m{Marke} (wobei {Marke} ein Kleinbuchstabe ist) kann eine Zeile Markiert werden und mit ‘{Marke} zu ihr hingesprungen werden (‘ ist das Hochkomma mit Shift+#). Mit ” (zwei Hochkommata)kann man zwischen zwei Markierungen hin- und her springen.

Anzeigen von mehreren Dateien
Indem man less mehrere Dateinamen als Argumente übergibt, kann man sich auch viele Dateien anzeigen lassen. Zwischen den Dateien springt man mit :n (zur nächsten) und :p (zur vorherigen). Natürlich kann man auch die Markierungen nutzen um zwischen den Dateien zu springen. Um aus less heraus eine neue Datei zu öffnen, kann man :e <Dateiname> eingeben. Mit :x gelangt man zur ersten Datei, während man mit :d die aktuelle Datei schließt.

Suchen im Dokument
Die Suche bei less funktioniert wie bei vim mit /<Suchpattern>. Mit n und N kann man zum nächsten bzw. vorherigen Treffer springen. Um die bei der Suche Groß- und Kleinschreibung zu ignorieren startet man less mit der Option -i. Dies entspricht der intelligenten Suche, die Groß- Kleinschreibung nur dann beachtet, wenn im Suchbegriff auch Großbuchstaben vorkommen. -I entspricht dann einem wirklichen ignore-case.
Wie in vim wird mit ? in die entgegengesetzte Richtung gesucht.

Coole Funktionen
Less wäre nicht more wenn es nicht mehr gäbe.
Alle Aufrufoptionen (die, die mit - anfangen) lassen sich auch einfach bei laufendem Programm eingeben (einfach eintippen), während Kommandos beim Aufruf durch ein vorangestelltes + mitgegeben werden können (z.B. öffnet less +G <Dateiname> eine Datei und springt sofort ans Ende).

• Mit v öffnet man vim mit der aktuellen Datei. (Bzw. den in der Umgebungsvariablen EDITOR angegebenen Editor)
• Mit F wird ans Ende der Datei gesprungen und diese bei jeder Änderung aktualisiert. Damit kann man sehen, wenn etwas z.B. in Logdateien hinzukommt. Dies entspricht einem tail -f. Zurück zm normalen Modus kommt man mittles Strg+c
• Mit der Option -M gibt less mehr Informationen (Zeilennummer und Länge sowie relative Position im Dokument) aus.
• Die Funktion = gibt noch mehr Informationen aus.
• Die Option -e veranlasst less dazu sich zu beenden, sobald das Dateiende zwei mal erreicht wurde. Mit -E wird less schon beim ersten Erreichen des Dateiendes geschlossen.
• Sehr praktisch finde ich auch die Option -F, bei der sich less automatisch schließt, wenn der Text auf eine Bildschrimseite passt. So wird der Text ausgegeben und less dann beendet.
• Durch !<Kommando> kann man ein Shell-Kommando ausführen, wobei man die Variable % für den aktuellen Dateinamen nutzen kann.
• Mit s <Dateiname> wird (wenn man sich die Ausgabe eines Programms anzeigen lässt) die Ausgabe in der angegebenen Datei gespeichert.
• Durch die Option -R zeigt less auch die Farben an, wenn man ein grep oder ls mit der option –colors=always hinein piped.

Eigene Tastenkombinationen definieren
Less hat auch eine eigene Konfigurationsdatei: ~/.less mit der man eigene Keybindings definieren kann.
Diese wird im Format Keybinding Action angegeben, wobei jede Zeile nur ein Keybinding besitzen darf.
Beispiele und mögliche Keys und Aktionen findet man in der manpage zu lesskey.

Eigenen Prompt definieren
Statt der Option -M kann man sich auch einen eigenen Prompt mit der Option -P definieren. Dafür gibt es jede Menge Variablen und Abfragen, dass man z.B. nur dann den Dateinamen ausgibt, wenn auch eine Datei gelesen wird und nicht von STDIN. Hier ein Beispiel:

?f%f:Standard input

gibt den Dateinamen aus oder “Standard input” wenn ein Kommando in less gepiped wurde.
Die ganzen Variablen und Abfragen sind in der manpage dokumentiert.

Preprozessor-Funktionen
Ich möchte noch kurz erwähnen, dass man für less Funktionen definieren kann, die vor dem Öffnen eines bestimmten Dateityps ausgeführt werden. So kann man z.B. eine Datei zuerst entschlüsseln oder dekomprimieren, bevor man sie anzeigen lässt. Eine entsprechende Funktion, der vor dem Schließenausgeführt wird um z.B. temporäre Dateien zu löschen kann ebenfalls definiert werden.
Weitere Infos dazu gibt es in der manpage.

Weitere Funktionen und Informationen bekommt zu less man wie immer in der manpage.

export GPG_TTY=‘tty‘

Um die .bashrc neu einzulesen führt man nun

source ~/.bashrc

aus oder startet eine neue Konsole.

Wenn nun vim neu gestartet wird, werden Dateien mit der Endung .pgp, .gpg oder .asc automatisch verschlüsselt. Dabei wird keine viminfo oder Swapdatei angelegt.
Beim Anlegen einer Datei öffnet sich ein horizontaler Splitscreen, in den man die Empfänger schreiben kann. Sobald dieser geschlossen wird, wird die Liste der Empfänger übernommen. Beim Speichern wird die Datei nun für die angegebenen Empfänger verschlüsselt.
Öffnet man eine Datei, die man (oder jemand anderes) für sich verschlüsselt hat, so wird man nach dem Passwort seines GPG-Schlüssels gefragt. Danach wird die Datei geöffnet.

Man kann aber auch die symmetrische Verschlüsselung von GPG verwenden. Dafür fügt man der Datei ~/.vimrc folgende Zeile hinzu:

let g:GPGPreferSymmetric = 1

Wird nun eine Datei mit einer der oben genannten Endungen angelegt, wird man beim Speichern nach einem Passwort gefragt, um die Datei zu verschlüsseln. Öffnet man eine so gespeicherte Datei, wird man wiederrum nach dem Passwort gefragt. Bei jeder Speicherung muss dann jedoch das Passwort angegeben werden.