dmenuLauncher ist ein Programmstarter, der dmenu nutzt um ein Programm auszuwählen. Die Grundfunktionalität ist im Artikel Ein leichtgewichtiger Launcher mit dmenu und Perl beschrieben. Das Skript habe ich auf GitHub hochgeladen.

Das Script wurde um folgende Punkte erweitert:

• Ob ein Programm im Terminal gestartet werden soll wird nun mitgespeichert
• Es können optional auch Argumente für ein Programm gespeichert werden
• Es kann ein String definiert werden, der immer vor dem Befehl eingefügt wird
• Es gibt eine (englische) readme, in der alle Funktionen beschrieben sind

Starten im Terminal
Wird dem Programmaufruf ein ; angehängt, so wird damit zwischen “im Terminal ausführen” und “direkt ausführen” hin und hergeschaltet. Die jeweils letzte Einstellung wird für zukünftige Aufrufe gespeichert.

Beispiel: Ich gehe von davon aus, dass die pathfile gerade generiert wurde, also alle Programme immer direkt ausgeführt werden.

• firefox – führt firefox direkt aus
• firefox; – führt firefox im Terminal aus
• firefox – führt firefox im Terminal aus (weil dies beim obigen Aufruf für die Zukunft gespeichert wurde)
• firefox; – führt firefox direkt aus
• firefox – führt firefox direkt aus (weil dies beim obigen Aufruf für die Zukunft gespeichert wurde)

Möchte man wirklich ein ; an einen Befehl anhängen ohne die Option “Starten im Terminal” zu verändern, kann man dies mit einem \ escapen.

Also: programm\;

Speichern von Argumenten
Es gibt nun eine Konfigurationsvariable SAVE_ARGUMENTS. Ist diese auf 1 gesetzt, werden automatisch alle Argumente gespeichert. Das bedeutet, dass in der Liste der Programme, aus denen man wählen kann das entsprechende Programm einmal ohne Argumente und jeweils einmal mit Argument aufgeführt wird.

dmenuLauncher im vertikalen Modus mit Argumenten

Für jedes Argument eines Befehls wird auch die Anzahl der Aufrufe gespeichert, so dass häufig genutzte Argumente weiter vorne stehen.

Man kann die Variable SAVE_ARGUMENTS für einen Aufruf umschalten, indem man einen . an den Programmaufruf anhängt.

Beispiel: free -m.

• Ist die Variable SAVE_ARGUMENTS auf 1 gesetzt, so wird das Argument -m nicht gespeichert (ohne den . am Ende würde es gespeichert werden)
• Ist die Variable SAVE_ARGUMENTS auf 0 gesetzt, so wird das Argument -m gespeichert (ohne den . am Ende würde es nicht gespeichert werden)

Bei der Optimierung werden Programme, zu denen Argumente gespeichert sind grundsätzlich nicht entfernt.

Möchte man wirklich einen . an einen Befehl anhängen ohne die Option “Speichern von Argumenten” zu verändern, kann man ihn mit einem \ escapen.

Also: programm\.

Man kann . und ; nicht gleichzeitig bei einem Aufruf verwenden.

[UPDATE] Ich habe als Trenner für mehrere Argumente in der pathfile die Zeichenfolge ||| genutzt und zum Trennen der Argumente und der jeweiligen Anzahl der Aufrufe die Zeichenfolge |#|. Leerzeichen sind hier nicht möglich, da diese auch in den Argumenten vorkommen dürfen sollen. Falls jemand einen Fall kennt, wo diese Trenner problematisch wären oder grundsätzlich eine bessere Idee hat würde ich mich über einen entsprechenden Kommentar freuen [/UPDATE]

String vor dem Befehl
In der Variable BEFORE_COMMAND kann man einen String definieren, der vor dem Befehl eingefügt wird. Ein Anwendungszweck wäre das Wechseln ins Home-Verzeichnis, so dass alle Befehle im Home-Verzeichnis ausgeführt werden.
Dafür setzt man BEFORE_COMMAND auf "cd ~ && ". Dies ist auch die default Einstellung.

Natürlich kann man auch einen leeren String angeben, damit nichts vor dem eigentlichen Befehl eingefügt wird.

Die Readme
Die Readme findet man, wenn man die Datei dmenuLauncher.pl mit einem Texteditor öffnet.

Ich habe nun noch ein kleines Script – dmenuLauncher.pl – geschrieben, das die Programme nach Häufigkeit ihrer Aufrufe sortiert, damit die am häufigsten genutzten Programmen immer zuerst gewählt werden, wenn es eine Mehrdeutigkeit gibt.

Features:

• Kleines Perl-Script, dass nur bei Bedarf gestartet wird und sonst weder Prozessorzeit noch RAM benötigt
• Kann in den meisten Fenstermanagern über Tastenkombination gestartet werden
• Programmen können beim Aufruf Argumente übergeben werden
• Sortiert Programme nach Nutzungshäufigkeit
• Horizontale oder vertikale Anzeige der Programmliste
• Programme im Terminal öffnen
• Optimierung der Programmliste (löschen aller Programme mit geringer Aufrufsanzahl aus der Liste)
• Einfaches hinzufügen von Programmen, die nicht in der Liste sind

dmenuLauncher mit horizontaler Anzeige der am häufigsten aufgerufenen Programme

Das Script habe ich auf gitHub online gestellt. Das Programm dmenu kann unter Ubuntu über das Paket dwm-tools installiert werden. Also mit dem Befehl sudo apt-get install dwm-tools.

Die Datei dmenuLauncher.pl hat im oberen Teil einen Konfigurationsbereich. Ich habe auf eine externe Konfigurationsdatei verzichtet um diese nicht jedes Mal laden zu müssen.

Zuerst wird der Pfad zur path-Datei (in der die Liste der Programme mit ihrer jeweiligen Aufrufanzahl gespeichert wird) in der Variablen PATHFILE angegeben.

dmenu kann die Programme im Menü nebeneinander oder untereinander angezeigen. Dafür kann man dmenuLauncher.pl entweder mit der Option -h für horizontal (also nebeneinander) oder -v für vertical (also untereinander) aufrufen.

Den Standardmodus, der genutzt wird, wenn nichts angegeben wurde kann man über die Variable MODE steuern. Sie wird entweder auf horizontal oder vertical gesetzt.

dmenuLauncher mit vertikaler Anzeige der Programme mit "gnome" im Namen

Die Konfigurationsvariable NUMBER_OF_LINES gibt die Anzahl von anzuzeigenden Zeilen im vertical-Modus an.

In der Variablen TERMINAL wird der Befehl für den Terminalaufruf gespeichert. Der Platzhalter %COMMAND% wird durch das aufzurufende Kommando (mit Argumenten) ersetzt.

Nun kann durch den Aufruf dmenuLauncher.pl -u die path-Datei generiert werden. Nach dem Installieren oder Löschen von Programmen kann die Datei so auch aktualisiert werden.

Nachdem man dmenuLauncher.pl konfiguriert und die path-Datei (mit der Option -u) generiert hat, kann man eine Tastenkombination dafür einrichten. Bei GNOME unter System -> Einstellungen -> Tastenkombinationen auf den Button “Hinzufügen” klicken, als Namen “dmenuLauncher” und als Befehl den Pfad zur Perldatei (dmenuLauncher.pl) angeben. Nun gibt es in der Liste ganz unten einen neuen Eintrag. Klickt man auf das Feld “Tastenkombination”, so kann man die gewünschte Tastenkombination drücken (ich habe SHIFT+<Space> gewählt, die dann dem Script automatisch zugeordnet wird.

Nach dem Starten des Programms (also drücken der zugeordneten Tastenkombination oder per Terminal) öffnet sich nun das Menü und zeigt die Programmliste an. Nun fängt man an, den gewünschten Befehl einzutippen bis er markiert ist. Man kann auch die Pfeiltasten benutzen. Mit der Eingabetaste wird das gewählte Programm ausgeführt und dmenuLauncher geschlossen.

Drückt man nicht direkt die Eingabetaste sondern <Tab>, so wird der Befehl vervollständigt und man kann noch Argumente angeben.

Ob mit ohne ohne Argumente: Durch ein abschließendes Semikolon wird der Befehl im Terminal ausgeführt.

Ein paar Beispiele:

• firef<ENTER> öffnet Firefox
• firef<Tab> http://zinformatik.de<ENTER> öffnet firefox und geht auf die Seite “http://zinformatik.de”
• top;<ENTER> öffnet top in einem Terminal
• ls -lh ~;<ENTER> zeigt das Ergebnis von ls -lh ~ in einem Terminal an.

Da die ganze Liste von Programmen sehr groß ist, man jedoch meist nur einen sehr kleinen Teil nutzt gibt es die Möglichkeit die Liste der Programme zu optimieren. Durch den Aufruf von dmenuLauncher.pl -o werden alle Programme aus der Liste entfernt, die noch nie genutzt wurden. Ein weiteres Argument gibt die Anzahl der Aufrufe an, die ein Programm mindestens haben sollte. So werden durch dmenuLauncher.pl -o 3 alle Programm aus der Liste entfernt die weniger als 3 mal aufgerufen wurden.

Möchte man nach der Optimierung ein Programm aufrufen, das sich nicht mehr in der Liste befindet, so kann man es einfach komplett eingeben. Auch wenn es dann keine Auswahl gibt, wird das Programm ausgeführt und mit der Aufrufsanzahl 1 in die Liste gespeichert.
Um ein neues Programm in die Liste aufzunehmen braucht man es also nur einmal eingeben.

Mit dmenuLauncher habe ich also ein sehr kleines Programm, welches nur kurz läuft um mir die Auswahl eines Programms zu ermöglichen und danach sofort wieder beendet wird. Das Laden ist auch auf älteren Systemen kaum zu spüren, weil keine Bibliotheken geladen werden. Das bedeutet ich kann jedes häufiger genutzte Programm mit 3-4 Tastendrücken ohne irgendeine Verzögerung starten.

Damit das Plugin funktioniert muss das Paket exuberant-ctags installiert sein. Danach kann man die Datei taglist.vim ins
Pluginverzeichnis (~/.vim/plugin) kopieren.

Wenn nun eine Datei mit Quellcode geöffnet ist, kann man das Taglist Plugin durch den Befehl :TList aktivieren, woraufhin sich auf der rechten Seite der Splitscreen mit den Funktionen öffnet. Mit STRG+w w kann man zwischen den Splitscreens hin und her wechseln (Ich habe mir diese Tastenkombination auf + gelegt). Mit j und k kann man nun in den Funktionen hoch und runter scrollen. Drückt man bei der gewünschten Funktion ENTER, so springt der Cursor automatisch wieder auf den Quelltext an der Position, wo die gewählte Funktion beginnt.
Da sich beim Sprung zu einer Funktion die entsprechende Datei im aktuellen Buffer öffnet, empfiehlt es sich, Buffer statt Tabs zu verwenden.

Praktisch ist es, sich ein autocommand für Quelltexte zu erstellen, so dass die Taglist automatisch beim Öffnen von Quelltexten geladen wird.

Dafür wird eine Funktion benötigt, welche die Dateiendung überprüft und bei entsprechenden Endungen die Taglist öffnet. Das folgende Beispiel öffnet die Taglist für Java und Perl Dateien:

function OpenTlist()
    let myfile = expand("%")
    let myfiletype = expand("%:e")
    if myfiletype == "pl" || myfiletype == "java"
        Tlist
    end
endfunction

Nun noch das autocommand:

au BufRead * call OpenTlist()

Beides wird in die ~/.vimrc geschrieben.

Nun kann man sich in der ~/.vimrc noch ein Mapping anlegen um die Taglist mit z.B. F3 ein- und auszublenden:

map <F3> :TlistToggle<cr>

Wenn man Programmiert, dann schreibt man natürlich auch neue Funktionen. Diese werden von der Taglist leider nicht sofort erkannt. Daher ist es sinnvoll ein Mapping zu definieren um die Taglist zu updaten. Das folgende Mapping legt das Updaten der Taglist auf F4 (die Datei wird dabei direkt gespeichert):

map <F4> :w<cr>:TlistUpdate<cr>

:h befehlsname

eingibt. In der Hilfe gibt es dann auch Verweise um auf weiterführende Informationen zu gelangen. Man kann diesen “Links” folgen indem man mit dem Cursor auf den Verweis navigiert und Strg+] (Strg+AltGr+9) drückt. Mit Strg+t springt man wieder zurück.

Eine praktische Möglichkeit seine Notizen zu verwalten ist es nun, dafür eine eigenene Hilfeseite anzulegen. Das hört sich komplizierter an als es ist. Man legt eine Datei im Ordner ~/.vim/doc/ an, deren letze Zeile so aussieht:

" vim: filetype=help modifiable noreadonly

Durch den filetype-Befehl weiß Vim, dass es eine Hilfedatei ist. modifiable und noreadonly müssen gesetzt sein, damit man die Datei auch editieren kann (da dies für Hilfedateien per Default nicht möglich ist). Natürlich kann man auch noch weitere Optionen und Einstellungen vornehmen. Ich habe bei mir noch einige Optionen für Faltungen hinzugefügt:

" vim: filetype=help foldmethod=marker foldmarker={{{,}}} foldlevel=0 modifiable noreadonly commentstring=\ %s

Man kann (wenn man möchte) statt der Datei selbst auch einen symbolischen Link im Verzeichnis ~/.vim/doc/ platzieren, der auf die Notizen-Datei zeigt, wodurch Notizen und echte Hilfedateien etwas besser getrennt sind.

Nun braucht man noch Tags (die Ziele der Verweise) in der Datei. Diese werden von Sternchen umschlossen (z.B. *tag*). Die Verweise auf die Tags werden durch senkrechte Striche (Pipes) markiert (z.B. |tag|). Von |tag| kann man also mittels Strg+] auf die Textstelle gelangen, wo *tag* steht.

Hier mal eine kleine Beispieldatei:

Meine Notizen *znotizen*
 
 
Telefonliste *zphone* {{{
    mom: 555-676767-333
    dad: 555-767676-222
    work: 555-121212-999
 }}}
 
Vim Shortcuts *zvim* {{{
    mx      markieren mit x, siehe |mark|
    'x      springe zu Markierung x
    yy      kopiere Zeile
 }}}
 
Hier ein Link zur Telefonliste: |zphone|
 
 
" vim: filetype=help foldmethod=marker foldmarker={{{,}}} foldlevel=0 modifiable noreadonly commentstring=\ %s

Wenn man neue Tags eingefügt hat, muss man sie mit dem Befehl :helptags ~/.vim/doc/ bekannt machen. Nun kann mit mit :h znotizen die Datei öffnen wie eine Hilfeseite. Genauso kann man mit :h zphone die Hilfeseite öffnen, wobei man direkt bei den Telefonnummern landet. Es reicht nur einen Teil des Tags einzugeben, wenn dieser eindeutig ist, z.B. kann man :h zno eingeben statt den ganzen Tag :h znotizen auszuschreiben.

Um bei jedem Speichern der Notizen das helptags-Kommando automatisch auszuführen wird das folgende Autokommando empfohlen:

au BufWritePost ~/.vim/doc/* helptags ~/.vim/doc

Leider funktioniert es bei mir nicht, weswegen ich mir ein Mapping dafür definiert habe:

map <leader>ut :helptags ~/.vim/doc<CR>

Durch dieses Mapping kann man mittels \ut seine Tags aktualisieren (ut für update tags)

Es gibt auch Plugins, die einen bei der Verwaltung seiner Notizen im Hilfesystem unterstützen (siehe Links)

Links

• http://vim.wikia.com/wiki/Add_your_note_files_to_Vim_help – VimTip zum Thema
• http://vim.wikia.com/wiki/VimTip482 – ein weiterer VimTip dazu
• http://www.vim.org/scripts/script.php?script_id=828 – VimNotes Plugin zur Unterstützung bei der Verwaltung von Notizen mit dem Hilfesystem
• http://www.vim.org/scripts/script.php?script_id=293 – Universal Text Linking Plugin um alle Arten von Links in Vim einzufügen und aus Vim heraus aufzurufen

Beispiel:

#!/usr/bin/perl
 
use strict;
use warnings;
 
sub divide {
    my ($x,$y) = @_;
    return $x/$y;
}
 
sub printDivision {
    my ($x,$y) = @_;
    print "$x durch $y = ".divide($x,$y)."\n";
}
 
sub divideList {
    my $x = shift;
    my $listReference = shift;
    my @list = @{$listReference};
    foreach my $i(@list){
        printDivision($x,$i);
    }
}
 
 
my @divList1 = (22,7,16);
my @divList2 = (2,5,33,50,0,7,65);
divideList(100,\@divList1);
 
# do something else ...
 
divideList(100,\@divList2);

Zugegeben ist dies ein recht künstlich konstruiertes Beispiel, jedoch ist es nicht leicht ein möglichst einfaches und gleichzeitig realistisches Beispiel zu finden. Die Funktion divide dividiert zwei übergebene Zahlen ohne überprüfung, ob durch 0 dividiert wird. printDivision nutzt diese Funktion um das Ergebnis einer Division auszugeben. Die Funktion divideList bekommt eine Zahl und eine Referenz zu einer Liste übergeben, durch die die Zahl jeweils geteilt und das Ergebnis mit der Funktion printList ausgegeben werden soll. Schließlich wird die Funktion divideList erst mit einer Liste ohne 0 und dann mit einer Liste aufgerufen, in der eine 0 vorkommt.

Die Ausgabe des Programms ist:

100 durch 22 = 4.54545454545455
100 durch 7 = 14.2857142857143
100 durch 16 = 6.25
100 durch 2 = 50
100 durch 5 = 20
100 durch 33 = 3.03030303030303
100 durch 50 = 2
Illegal division by zero at ./test.pl line 8.

Wenn man die beiden Lisen jetzt nicht direkt so vor Augen hat (weil sie z.B. während des Ablaufs generiert werden), kann man schwer sagen, welcher Funktionsaufruf den Fehler verursacht hat. Man weiß nur, dass der Fehler in Zeile 8 lag. Auch wenn der Fehler abgefangen wird, kommen wir nicht an die Stelle, an der der falsche Parameter ins Spiel gekommen ist.

Ein Stacktrace kann da ein wenig Abhilfe schaffen. Nutzt man das Modul Carp, so kann man die Funktionen warn und die mit carp und croak überschreiben und bekommt nun zusätzlich einen Stacktrace. Dafür werden die beiden folgenden Zeilen an den Anfang des Programms eingefügt:

use Carp;
$SIG{__DIE__} = sub {croak shift;};

Die Ausgabe sieht nun so aus:

100 durch 5 = 20
100 durch 10 = 10
100 durch 33 = 3.03030303030303
100 durch 50 = 2
Illegal division by zero at ./test.pl line 9.
 at ./test_croak.pl line 5
        main::__ANON__('Illegal division by zero at ./test_croak.pl line 9.\x{a}') called at ./test.pl line 9
        main::divide(100, 0) called at ./test.pl line 15
        main::printDivision(100, 0) called at ./test.pl line 22
        main::divideList(100, 'ARRAY(0x87d6d28)') called at ./test.pl line 34

Bei einer Warnung kann das Programm zwar noch weiter ausgeführt werden, doch sind die Ergebnisse dann in der Regel falsch (vor allem wenn die Warnung wegen einer nicht initialisierten Variablen auftritt). Daher kann es sinnvoll sein die Funktion warn mit croak zu überschreiben, so dass das Programm auch bei einer Warnung abbricht.

Noch praktischer wäre es natürlich, wenn man nun noch die Elemente der Liste kennen würde, mit deren Referenz die Funktion divideList aufgerufen wurde.

Daher habe ich ein kleines Modul entwickelt (die Grundidee stammt aus einem Perl-Buch), welches noch etwas mehr kann. Das Modul DebugMessages gibt bei einem Fehler einen Stacktrace aus, wobei die aktuellen Parameter des Aufrufs mit ausgegeben werden. Auf Wunsch werden werden auch Inhalte von Listen und Hashes ausgegeben.
Zusätzlich wird der Quelltext mit ausgegeben und zwar ab n Zeilen über der Zeile, die den Fehler erzeugt hat bis n Zeilen danach. (Die Anzahl der Zeilen n kann beliebig gewählt werden). Die Zeile mit dem Fehler wird dabei markiert.

Das Modul kann folgendermaßen eingebunden werden:

use lib "path/to/module";
use DebugMessages exit_on_warning => 1, errors => 3, warnings => 3, level => 5, verbose => 1;

Die Pfadangabe "path/to/module" muss natürlich auf das Verzeichnis zeigen, in dem die Datei DebugMessages.pm liegt.

Die einzelnen Parameter haben dabei folgende Bedeutung:

• exit_on_warning: Wenn dieser Parameter 1 ist bricht das Programm schon bei einer Warnung ab. (Default ist 0)
• errors: Anzahl der Zeilen, die jeweils vor und nach der Zeile ausgegeben werden sollen, die einen Fehler produziert hat. -1 deaktiviert DebugMessages für Fehler. (Default ist 3)
• warnings: Anzahl der Zeilen, die jeweils vor und nach der Zeile ausgegeben werden sollen, die eine Warnung produziert hat. -1 deaktiviert Default für Warnungen. (Default ist 3)
• level: Anzahl der Rekursionslevel für den Stacktrace. (Default ist 3)
• verbose: 1 zeigt den Inhalt von Listen und Hasheses in kompakter Schreibweise an. 2 Zeigt den Inhalt ausführlich an. 0 deaktiviert das Ausgeben von Listeninhalten.

Die Fehlermeldung des obigen Beispiels sieht ist nun sehr ausführlich:

100 durch 22 = 4.54545454545455
100 durch 7 = 14.2857142857143
100 durch 16 = 6.25
100 durch 2 = 50
100 durch 5 = 20
100 durch 33 = 3.03030303030303
100 durch 50 = 2
 
Error: Illegal division by zero at ./test.pl line 11.
 
   0008:
   0009: sub divide {
   0010:     my ($x,$y) = @_;
 * 0011:     return $x/$y;
   0012: }
   0013:
   0014: sub divideAll {
 
-------------------------------------
Verbose output of parameters for call of main::divide
100
0
-------------------------------------
 
   main::divide(100,0) called at line 33 in file ./test.pl (package main):
     0030:
     0031: sub printDivision {
     0032:     my ($x,$y) = @_;
   * 0033:     print "$x durch $y = ".divide($x,$y)."\n";
     0034: }
     0035:
     0036: sub divideList {
 
-------------------------------------
Verbose output of parameters for call of main::printDivision
100
0
-------------------------------------
 
     main::printDivision(100,0) called at line 41 in file ./test.pl (package main):
       0038:     my $listReference = shift;
       0039:     my @list = @{$listReference};
       0040:     foreach my $i(@list){
     * 0041:         printDivision($x,$i);
       0042:     }
       0043: }  
       0044:
 
-------------------------------------
Verbose output of parameters for call of main::divideList
100
0..6  2 5 33 50 0 7 65
-------------------------------------
 
       main::divideList(100,ARRAY(0x9ff2528)) called at line 52 in file ./test.pl (package main):
         0049:
         0050: # do something else ...
         0051:  
       * 0052: divideList(100,\@divList2);

So kann man den Fehler über alle Funktionsaufrufe zurückverfolgen ohne in den Editor wechseln zu müssen. Man hat ja auch den Kontext des Quellcodes vor Augen.

Zusätzlich wurde noch eine kleine Verschönerung für die Ausgabe von Listen hinzugefügt. Mit eingebundenem Modul kann man Listen folgendermaßen ausgeben:

my @list = ("Hallo Welt", "a", "b",1,2,3);
print "[@list]\n";

Statt der normalen Ausgabe:

[Hallo Welt a b 1 2 3]

bei der man nicht erkennen kann, wie viele Elemente die Liste enthält, bekommt man mit eingebundenem DebugMessages Modul folgende Ausgabe:

[Hallo Welt] [a] [b] [1] [2] [3]

Das Modul DebugMessages habe ich bei GitHub hoch geladen. Die Adresse ist: http://github.com/zimon/DebugMessages

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).

Ein solches “Erinnerungsprogramm” kann man sich recht leicht selber basteln. Ich habe dafür das Linuxtool at mit dem Programm zenity, welches Dialoge darstellen kann, kombiniert.

at (bzw. der at-Daemon atd) ist auf den meisten Linuxdistributionen bereits vorhanden, kann sonst aber auch über die Paketverwaltung installiert werden. Zenity sollte bei den meisten Distributionen ebenfalls über die Paketverwaltung installierbar sein.
Unter Ubuntu installiert man zenity mit dem Befehl:

sudo apt-get install zenity

Mit at können Befehle zu einem festgelegten Zeitpunkt ausgeführt werden. Eine sehr schöne Einführung gibt es in der Ausgabe 10/2008 von freiesMagazin (eine Fortsetzung ist in der nachfolgenden Ausgabe enthalten, welche mich auch zu diesem “Programm” inspirierte, weil ich mit den dort vorgestellten Erinnerungs-Lösungen nicht zufrieden war).

Um mit zenity einen Dialog anzuzeigen kann man folgenden Befehl nutzen:

zenity --info --title="Titel des Dialogs" --text "Text, der angezeigt werden soll"

Damit dies von at angezeigt werden kann muss noch das Display angegeben werden:

zenity --info --title="Titel des Dialogs" --text "Text, der angezeigt werden soll" --display=:0

Diesen Befehl kann man nun in ein Bash- oder Perl-Script einfügen, wobei der Titel fest sein kann und der Text als Argument übergeben wird. Ich habe mich für Perl entschieden:

#!/usr/bin/perl
 
system("zenity --info --title=\"Erinnerung\" --text \"@ARGV\" --display=:0");

Dieses Script habe ich unter dem Namen r (für “remember”) im bin-Ordner meines Homeverzeichnisses gespeichert. Dieses muss natürlich im Pfad liegen, was durch folgende Zeile in der Datei ~/.bashrc erreicht werden kann:

export PATH=$PATH:/home/user/bin

“user” muss natürlich durch den entsprechenden Usernamen ersetzt werden. Nachdem man die ~/.bashrc mit dem Befehl

. ~/.bashrc

neu “geladen” hat kann man sich nun an Termine oder andere Dinge erinnern lassen.

Beispiele:
Um 14:30 Termin bei FooBar. Also um 14:15 erinnern:

at 14:15
r Termin bei FooBar in 15 Minuten
Strg+d

In einer halben Stunde ist eine Besprechung (5 min vorher erinnern):

at now +25min
r Besprechung
Strg+d

Es öffnet sich zur angegebenen Zeit ein Dialogfenster (egal, was man gerade macht – solange man sich in X befindet. Bei Spielen im Fullscreen habe ich es jedoch nicht getestet.), welches den Titel “Erinnerung” enthält und den angegebenen Text ausgibt. Das Fenster kann durch einen Klick auf “OK” wieder geschlossen werden.

at bietet noch viele weitere Möglichkeiten eine Zeit anzugeben. Diese werden im (ersten) oben verlinkten freiesMagazin-Artikel beschrieben.

Unter Vim gibt es die Möglichkeit, den Namen der aktuellen Datei als Titel für das Screenfenster zu benutzen.
Dafür braucht man nur die folgenden Zeilen zur ~/.vimrc hinzufügen:

if expand('$TERM') == 'screen'
augroup vim_screen
  autocmd!
  autocmd VimEnter,BufWinEnter,WinEnter *
    \ exec "silent! !echo -ne '\\ek" . expand('%:t') . "\\e\\\\'"
augroup END
endif

[UPDATE]Auf dem 256bit Blog beschreibt Christian Brabandt, wie man den Screen-Titel von Vim aus ohne autocommands und mit sehr vielen Einstellungen setzen kann.[/UPDATE]

Ansonsten finde ich es sehr praktisch, wenn in der Statusleiste das aktuelle Verzeichnis steht. Da der komplette Pfad meist sehr lang ist, können mit einem regulären Ausdruck alle Verzeichnisse bis auf das letzte jeweils mit ihren Anfangsbuchstaben abgekürzt werden:

s/(\w).*?\//$1\//g

So wird /home/zimon/.vim/plugin zu /h/z/.v/plugin abgekürzt.

Wem das immer noch zu lang ist, der kann aus dem Namen des letzten Verzeichnisses auch noch die Vokale heraus nehmen (ähnlich wie es dillo in seinen Tabs macht):

s/(\w).*?\//$1\//g; my $end; $x=~s/\/(.)(?:[aeiou]|([^aeiou\/])(?{$end.=$^N}))*\s*$/\/$1$end/

Damit wird /home/zimon/.vim/plugin zu /h/z/.v/plgn

Um in der Bash den Screen-Titel automatisch zu setzen, kann man folgenden Code zu seiner ~/.bashrc hinzufügen. Hier wurde der erste reguläre Ausdruck genutzt (man kann ihn natürlich auch durch den anderen Ausdruck ersetzen, wenn man möchte):

function precmd {
    case "$TERM" in
        screen)
        wd=`perl -e '$x=shift; $x=~ s/(\w).*?\//$1\//g; print $x;' "$PWD"`
        echo -ne "\033k$wd\033\\"
        ;;
    esac
}
PROMPT_COMMAND=precmd

Für zsh User gibt es hier den Code für die ~/.zshrc. In diesem Beispiel wurde der zweite reguläre Ausdruck genutzt:

function precmd {
    if [[ "$TERM" == "screen" ]]; then
    local wd=`perl -e '$x=shift; $ x=~ s/(\w).*?\//$1\//g; my $end; $x=~s/\/(.)(?:[aeiou]|([^aeiou\/])(?{$end.=$^N}))*\s*$/\/$1$end/; print $x;' "$PWD"`
	PR_STITLE=$'%{\ek'$wd$'\e\\%}'
    fi
}

Vielen Dank an Ploppor für den zsh Code und sonstige zahlreiche Unterstützung in letzter Zeit.

Es tut mir leid, dass ich in letzter Zeit nichts geschrieben habe, aber meine Diplomarbeit lässt mir einfach keine Zeit.

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.