;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  -*- Emacs-Lisp -*-;;;;;;
;;;
;;;
;;; Beispielkonfiguration für den EMACS von
;;;
;;;  Klaus Wachtler
;;;  Breidingstr. 17
;;;  29614 Soltau
;;;  Tel. 05191/70 2 71, 0171/45 53 039
;;;  Fax: 05191/70 2 72
;;;  email: Klaus@Wachtler.de
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;           ///| |||\    || ||||    //
;;;          ////| |||\\   || ||||   //
;;;         ////|| ||||\\  || ||||  //
;;;        //// || |||| \\ || |||| //
;;;       ////==|| ||||  \\|| ||||//
;;;      ////   || ||||   \\| |||//
;;;     ////    || ||||    \| ||//
;;;                           |//
;;;         ||||    /|    //  //  ///| ||||=====//  ////=======
;;;         ||||   /||   //  //  ////| ||||    //  ////
;;;         ||||  //||  //  //  ////|| ||||   //  ////
;;;         |||| // || //  //  //// || ||||  //  ////
;;;         ||||//  ||//  //  ////==|| ||||=((  ((((=======
;;;         |||//   |//  //  ////   || ||||  \\  \\\\
;;;         |||/    |/  //  ////    || ||||   \\  \\\\=======
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Aenderungen:
;;;
;;; 05.04.1996 kw Ergaenzungen zu c-mode-common (C und C++), Korrektur
;;;               fuer diverse abbreviations
;;;
;;; 11.04.1996 kw bunte Syntax auch fuer C++
;;;
;;; 15.04.1996 kw Korrektur fuer LaTeX-em
;;;
;;; 07.06.1997 kw standard-display-european eingeschaltet
;;;
;;; 01.07.1997 kw Funktion pps definiert (gibt aktuellen Puffer mit
;;;               angehaengtem .ps als buntes PS aus)
;;;
;;; 07.10.1997 kw Ergaenzungen zu fortran-mode
;;;
;;; 26.11.1997 kw Ergaenzungen zu pascal-mode
;;;
;;; 17.05.1998 kw C-7 fuer geschweifte Klammern; C-8 fuer eckige
;;;
;;; 19.05.1998 kw C-cC-i fuer indent-region
;;;
;;; 18.08.1997 kw _ soll Teil eines C-Namens sein
;;;
;;; 28.10.1998 kw je ein neues Fenster beim Aufruf über
;;;               gnuclient/gnuclientw mit (setq gnuserv-frame nil)
;;;
;;; 16.11.1998 kw Etwas mehr kommentiert (für die FH-Studenten)
;;;
;;; 19.01.1999 kw copy-char-form-previous-line und
;;;               copy-word-form-previous-line eingefügt (kopieren ein
;;;               Zeichen/Wort aus der vorhergehenden Zeile)
;;;
;;; 14.03.1999 kw automatische Erkennung, ob NT.
;;;               Nur dann wird gnuclient geladen.
;;;
;;; 07.06.2000 kw C-c M-% an query-replace-regexp gebunden, perl mode
;;;
;;; 17.08.2000 kw ishl.el
;;;
;;; 21.11.2001 kw Tabs und schließende Leerzeichen anzeigen
;;;
;;; 24.11.2001 kw Doku um Prefix und narrow erweitert
;;;
;;; 03.12.2001 kw Korrektur von for- und class-Abkürzungen aufgepeppt
;;;
;;; 10.12.2001 kw Korrektur class-Abkürzung (generiert clone(),
;;;               ostream &operator<<(), und nimmt Rücksicht
;;;               auf static-Elemente)
;;;
;;; 28.12.2001 kw Noch ein paar Spielereien von http://www.dotemacs.de/
;;;               und http://www.dotfiles.com geklaut
;;;               (z.B. mouse-avoidance-mode)
;;;
;;; 23.01.2002 kw Summenberechnen eines markierten Rechtecks mit rect-sum,
;;;               Tastenbelegung kommentiert
;;;
;;; 18.02.2002 kw Die gesetzten Tastenbelegungen werden in *Messages*
;;;               ausgegeben; dann kann man schnell mal nachgucken.
;;;
;;; 01.05.2002 kw Editieren über ftp
;;;
;;; 29.06.2002 kw (toggle-uniquify-buffer-names)
;;;
;;; 10.07.2002 kw kleinere Ergänzungen, Korrekturen, getestet mit
;;;               EMACS 21.2 unter Windows 2000.
;;;
;;; 13.01.2005 kw Passive mode für ftp-Verbindungen
;;;
;;; 17.08.2010 kw Tippfehler korrigiert
;;;
;;; 23.10.2010 kw in file-coding-system-alist auch Dateiene,
;;;               deren Namen mit mutt beginnen, auf utf-8 gesetzt
;;;
;;; 
;;;
;;; 
;;;
;;; 
;;;
;;; nachtragen:
;;; http://ls6-www.cs.uni-dortmund.de/~grossjoh/emacs/tutorials.html
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
;
;
;               *****  *    *   ***    ***    ***
;               *      **  **  *   *  *   *  *   *
;               *      * ** *  *   *  *      *
;               ****   *    *  *****  *       ***   *****
;               *      *    *  *   *  *          *
;               *      *    *  *   *  *   *  *   *
;               *****  *    *  *   *   ***    ***
;
;
;      ***   ****    ***    ***   *   *  *   *  *   *  ****    ***
;     *   *  *   *  *   *  *   *  *   *  *  *   *   *  *   *  *   *
;     *      *   *  *   *  *      *   *  * *    *   *  *   *  *
;     *      ****   *****   ***   *****  **     *   *  ****    ***
;     *      * *    *   *      *  *   *  * *    *   *  * *        *
;     *   *  *  *   *   *  *   *  *   *  *  *   *   *  *  *   *   *
;      ***   *   *  *   *   ***   *   *  *   *  *****  *   *   ***
;
;
;
; Der EMACS ist im wesentlichen ein Editor, um Texte zu editieren.
; Dazu sind etliche Kommandos definiert, um beispielsweise Dateien zu laden,
; abzuspeichern, Textstellen zu suchen/ersetzen, etc.
;
; Der Emacs unterliegt der GPL (General Public License) der FSF (Free
; Software Foundation). Das heißt, daß er
; a) im Quelltext zur Verfügung steht
; b) nichts kostet
; c) frei verwendet und weitergegeben werden kann und soll (solange die
;    GPL eingehalten wird)
;
; Der EMACS kann auf allen gängigen Systemen (MS-DOS, Windows, NT, 95,
; Linux, alle Unix, VMS, Mac, Atari TOS/GEM) installiert werden.
;
; Je nach Umgebung kann er sowohl auf einfachen Terminals als auch in
; eine Fensteroberfläche eingebunden verwendet werden.
;
; Unter einer Fensteroberfläche existiert eine Menüleiste, über die man
; die wichtigtsen Befehle erreicht. Für erste Übungen kann man damit
; leben.
;
; Am effektivsten wird der EMACS aber über Tastaturkommandos gesteuert.
; Während die üblichen (druckbaren) Zeichen meistens als einzugebender
; Text interpretiert wird, bestehen die EMACS-Kommandos weitgehend aus
; Tastenkombinationen mit der Control-Taste und der Meta-Taste.
;
; Da diese Kommandos einer gewissen Gewöhnung benötigen, ist der Einstieg
; etwas zäh. Dafür muß man diese Kommandos nur einmal lernen, egal auf
; welchem System und unter welcher Oberfläche man damit
; arbeitet. Zumindest wenn man im Lauf seiner Karriere mehrmals die
; Betriebssystemumgebung wechselt, spart man sich sehr viel
; Eingewöhnungszeit. Zudem ist der EMACS verblüffend leistungsfähig, so
; daß man oft mehrere andere Programme damit ersetzen kann.
;
; Da der EMACS sehr weitgehend konfigurierbar ist, kann man auch
; spezielle Anpassungen so bauen, daß sie über alle Rechnergrenzen
; hinweg funktionieren.
;
; Die Control-Taste ist das, was auf der deutschen Tastatur mit "Strg"
; beschriftet ist.
; In der gesamten EMACS-Dokumentation werden Tastenkombinationen mit der
; Control-Taste mit den Zeichen "C-" vor dem zugehörigen Buchstaben
; bezeichnet. Beispiel:
;         C-x C-f         (öffnet eine Datei zum Editieren)
; Das ist so einzugeben: während die [Strg]-Taste gedrückt ist, muß man
; die [x]-Taste drücken, und dann (immer noch bei gedrückter
; [Strg]-Taste) die [f]-Taste. In diesem Beispiel erscheint dann in der
; untersten Zeile die Aufforderung, den gewünschten Dateinamen
; einzugeben.
;
; Man sollte im Auge behalten, daß bei einer Tastenfolge bei jeder
; einzelnen Taste vorgegeben ist, ob sie mit oder ohne [Ctrl] gedrückt
; werden muß. Deshalb sind C-x C-s (Speichern des aktuellen buffer) und
; C-x s (Speichern aller buffer) zwei interschiedliche Kommandos!
;
; Die Meta-Taste (in der Dokumentation mit "M-" bezeichnet) dagegen
; existiert als solche nicht auf einem einfachen
; Terminal; je nach verwendetem System ist dafür etwas anderes
; einzugeben. Auf fast jeder aktuellen Tastatur gibt es eine
; [Esc]-Taste. Anstatt der fiktiven Meta-Taste tippt man vor dem
; jeweilgen Zeichen dann einmal die [Esc]-Taste. Bei vielen Systemen ist
; zusätzlich die [Alt]-Taste als Meta-Taste konfiguriert.
; Beispielsweise kann man mit M-% das "Suchen und Ersetzen" starten.
; Dazu muß man dann entweder
; a) die [Esc]-Taste drücken, dann "%" (also [Shift]+[5]), oder
; b) -wenn es so eingerichtet ist- die [Alt]-Taste drücken, und gedrückt
;    lassen, dann die "%"-Taste (also [Shift]+[5]), dann die [Alt]-Taste
;    loslassen.
;
;
;
;      buffer, window, frame
;      #####################
;
;
; Wenn man mehrere Dateien gleichzeitig editieren will, muß man dazu den
; EMACS nur einmal auf dem Rechner laufen lassen. Jede Dateikopie, die
; im Speicher editiert wird, ist ein "buffer".
;
; Die Anzahl der Buffer ist dabei unabhängig von der Anzahl der
; sichtbaren Fenster. Das kommt daher, daß der EMACS ursprünglich für
; die Bedienung an Terminals gedacht war, wo es Fenster im Sinne von
; Windows/X-Windows nicht gibt.
; An einem Terminal hat man meistens dann nur einen buffer im Blick,
; obwohl der EMACS eventuell mehrere buffer geöffnet hat. Mit C-x b kann
; man dann von einem buffer zu einem anderen umschalten.
; Der Bildschirm sieht dann etwa so aus:
;
; +--------------------------------------------------------------+
; |#include <stdio.h>                                            |
; |_                                                             |
; |int main()                                                    |
; |{                                                             |
; |  int i;                                                      |
; |                                                              |
; |  for( i=0; i<10; i++ ) printf( "i ist %d\n", i );            |
; |                                                              |
; |  return 0;                                                   |
; |}                                                             |
; |                                                              |
; |                                                              |
; |                                                              |
; |                                                              |
; |                                                              |
; |                                                              |
; |                                                              |
; |                                                              |
; |                                                              |
; |                                                              |
; |                                                              |
; |                                                              |
; |-\** t.cpp         10:04  (C++ Abbrev)--L2--C1--20%-----------|
; |                                                              |
; +--------------------------------------------------------------+
;
; Der größte Bereich ist der zu editierende Text.
;
; Die vorletzte Zeile ist eine Statuszeile, in der einige Informationen
; ausgegeben werden:
; Die beiden Sternchen hinter dem "-\" zeigen an, daß der aktuelle
; buffer geändert wurde, und die Änderungen noch nicht in die zugehörige
; Datei zurückgeschrieben wurden (also der buffer noch nicht gespeichert
; ist).
; Dahinter steht der Name des buffers, das ist meistens der Name der
; entsprechenden Datei. Werden mehrere Dateien mit unterschiedlichen
; Pfaden, aber gleichen Namen geöffnet, dann werden ab der zweiten
; solchen Datei an den buffer-Namen noch "<2>", "<3>" etc. angehängt.
; Die restliche Statuszeile ist teilweise abhängig davon, wie der EMACS
; konfiguriert ist: Die Uhrzeit, dann in Klammern der aktuelle
; Hauptmodus (hier C++), evtl. gefolgt von Untermodi (hier Abbrev), dann
; Zeilen- und Spaltennummer, und eine prozentuale Angabe der Position im
; Text.
;
; Für jeden Modus können unabhängig von anderen Modi bestimmte
; Einstellungen vorgenommen werden. Beispielsweise unterscheiden sich
; der "fortran-mode" und der "c-mode" in der Syntax, nach der
; Einrückungen vorgenommen werden. Jetzt kann gleichzeitig ein buffer
; mit einem Fortran-Quelltext geöffnet sein, und ein anderer mit einem
; C-Quelltext. Solange man den einen buffer bearbeitet, verhält sich
; der EMACS anders, als nach dem Wechsel zu dem buffer mit dem
; C-Quelltext.
;
; Die letzte Zeile des Bildschirms, also die Zeile unter der
; Statuszeile, ist der sogenannte "mini buffer", der für
; Kommandoeingaben verwendet wird.
; Um ein Kommando aufzurufen, das nicht direkt über eine
; Tastenkombination erreichbar ist, muß man den Kommandonamen kennen.
; Beispelsweise kann man mit Kommandos wie "c-mode", "c++-mode",
; "text-mode" etc. zwischen den verschiedenen Hauptmodi wechseln.
;
; Ist man im mini buffer, hat man folgende Kommandos:
;   [Tab]-Taste:    vervollständigen, soweit möglich
;   [ ]-Taste:      nur ein Wort vervollständigen
;   [Ret]-Taste:    vervollständigen, und ausführen
;   [?]-Taste:      Möglichkeiten (zum Vervollständigen) anzeigen
;   M-p:            letzte Eingabe holen
;   M-n:            nächste Eingabe holen
; (und weitere).
;
; Um ein solches Kommando einzugeben, muß man vorher M-x drücken. Um
; also von irgendeinem Modus in den Textmodus zu wechseln, tippt man:
;      [Esc]-Taste [x]-Taste [t]-Taste [e]-Taste [x]-Taste [t]-Taste
;      [-]-Taste [m]-Taste [o]-Taste [d]-Taste [e]-Taste [Return]-Taste
; , oder kürzer geschrieben:
;      M-x text-mode
;
; Soviel zum Umgang mit einem Fenster.
;
; Leider werden die Bezeichnungen beim Umgang mit mehreren Fenstern
; etwas verwirrend. Da es den EMACS schon länger
; gibt, als die fensterorientierten Benutzeroberflächen, hatte damals
; niemand ein schlechtes Gewissen dabei, den Begriff "window" für etwas
; zu verwenden, was kein Fenster im Sinne von MS-Windows oder X-Windows
; ist. Vielmehr versteht der EMACS unter "window" einen Teil seines
; Bildschirms, also auf einem Terminal einen Teil der
; Bildschirmfläche. Verwendet man den EMACS auf einem System mit
; grafischer Benutzeroberfläche, dann entspricht der Terminalbildschirm
; einem Fenster der Benutzeroberfläche, und das kann nun mal im Sinne
; von EMACS in mehrere windows geteilt sein.
;
; Der gesamte Bildschirm eines Terminals, beziehungsweise ein Fenster im
; Sinne der Benutzeroberfläche, heißt für den EMACS "frame".
;
;
; Mit dem Kommando C-x 2 kann man den aktuellen "frame" in zwei (EMACS-)
; windows unterteilen. Auf einem Terminal könnte das so aussehen:
;
; +--------------------------------------------------------------+
; |#include <stdio.h>                                            |
; |_                                                             |
; |int main()                                                    |
; |{                                                             |
; |  int i;                                                      |
; |                                                              |
; |  for( i=0; i<10; i++ ) printf( "i ist %d\n", i );            |
; |                                                              |
; |  return 0;                                                   |
; |}                                                             |
; |                                                              |
; |-\** t.cpp         10:04  (C++ Abbrev)--L2--C1--20%-----------|
; |#include <stdio.h>                                            |
; |_                                                             |
; |int main()                                                    |
; |{                                                             |
; |  int i;                                                      |
; |                                                              |
; |  for( i=0; i<10; i++ ) printf( "i ist %d\n", i );            |
; |                                                              |
; |  return 0;                                                   |
; |}                                                             |
; |                                                              |
; |-\** t.cpp         10:04  (C++ Abbrev)--L2--C1--20%-----------|
; |                                                              |
; +--------------------------------------------------------------+
;
; Dadurch hat man zwei Ansichten auf ein und denselben buffer. Editiert
; man in einem der beiden (EMACS-) Fenster, dann wirkt sich das auch auf
; den Inhalt des anderen aus.
; Mit C-x o kann man zwischen den beiden (EMACS-) Fenstern wechseln, so
; daß man beispielsweise zwei Abschnitte einer Datei leicht im Wechsel
; bearbeiten kann. Je nach Bedarf kann man auch zwei verschiedene
; Dateien in die (EMACS-) Fenster laden, und so beim Editieren schnell
; zwischen den Dateien (besser gesagt: deren buffer) springen.
; (Unter einer grafischen Benutzeroberfläche kann man zum Wechseln
; des aktiven window auch einfach in das gewünschte klicken; dann
; wird dort der Cursor positioniert.)
;
; Mit C-x 1 kann man das aktuelle (EMACAS-) window zum einzigen in
; diesem frame machen (also auf maximale Größe bringen).
;
; Ein frame kann also einen oder mehrere (EMACS-) Fenster
; beinhalten. Zudem kann unter einer grafischen Benutzeroberfläche ein
; laufender EMACS auch beliebig viele frames (also Fenster im Sinne der
; Benutzeroberfläche) öffnen, in denen jeweils eines oder mehrere
; (EMACS-) Fenster zu sehen sind. In den (EMACS-) Fenstern können nun
; lauter unterschiedliche Datei-buffer erscheinen, oder solche buffer
; können auch mehrfach sichtbar sein.
;
; Soweit (EMACS-) Fenster und frames (Fenster im Sinne der Oberfläche)
; ähnliche Funktionen haben, sind auch die Kommandos ähnlich.
; (Emacs-) Fenster-Befehle lauten immer "C-x irgendwas", während die
; entsprechenden Befehle für frames "C-x 5 irgendwas" lauten.
; Beispiel:
;     C-x 2      teilt das aktuelle (EMACS-) Fenster in zwei auf, wobei
;                beide anfangs den gleichen buffer an derselben Stelle
;                darstellen.
;     C-x 5 2    öffnet ein neues frame, wobei das alte und das neue
;                frame anfangs den gleichen buffer an derselben Stelle
;                darstellen.
;
; Mit C-x o kann man zwischen den (Emacs-) Fenstern eines frames
; springen, mit C-x 5 o zwischen den frames.
;
; Mit C-x 0 kann man ein (EMACS-) Fenster schließen; der freigewordene
; Bildschirmbereich wird von dem/den anderen Fenster(n) belegt.
; C-x 5 0 schließt ein frame.
;
;
; Im folgenden Beispiel sind zwei frames offen. Der hintere frame
; (rechts unten, teilweise verdeckt) zeigt den buffer t.cpp; der Cursor
; steht hier gerade in Zeile 8 und Spalte 1.
; Das vordere frame dagegen ist in zwei (EMACS-) Fenster aufgeteilt. Das
; untere stellt ebenfalls den buffer t.cpp darf, steht aber gerade an
; einer anderen Stelle. Das obere Fenster des vorderen frames zeigt
; einen anderen buffer, nämlich test.txt:
;
; +--------------------------------------------------------------+
; | * test.txt_________________________________________________#X|
; | Buffers Files Tools Edit Search Help                         |
; +--------------------------------------------------------------+
; |Wuff, wuff, meine Name ist Rex!                             |^|
; |Wuff, wuff, meine Name ist Rex!                             | |
; |Wuff, wuff, meine Name ist Rex!                             | |
; |Wuff, wuff, meine Name ist Rex!                             | |
; |Wuff, wuff, meine Name ist Rex!_                            | |-----------+
; |                                                            | |_________#X|
; |                                                            | |           |
; |                                                            | |-----------+
; |                                                            |-|         |^|
; |                                                            | |         | |
; |                                                            |v|         | |
; |-\** test.txt      10:04  (Text Fill)---L5--32--100%--------|-|         | |
; |#include <stdio.h>                                          |^|         | |
; |_                                                           | |         | |
; |int main()                                                  | |         | |
; |{                                                           | |         | |
; |  int i;                                                    | |         | |
; |                                                            | |         | |
; |  for( i=0; i<10; i++ ) printf( "i ist %d\n", i );          | |         | |
; |                                                            | |         | |
; |  return 0;                                                 |-|         | |
; |}                                                           | |         | |
; |                                                            |v|         | |
; |-\** t.cpp         10:04  (C++ Abbrev)--L2--C1--20%---------|-|         | |
; |                                                            | |         | |
; +--------------------------------------------------------------+         | |
;             |                                                            | |
;             |                                                            |v|
;             |-\** t.cpp         10:04  (C++ Abbrev)--L8--C1--20%---------|-|
;             |                                                            | |
;             +--------------------------------------------------------------+
;
; Bewaffnet mit diesem Grundwissen sollte man die grundlegenden
; Kommandos auf der "EMACS Reference card" verwenden können.
; Diese ist hoffentlich bei jeder EMACS-Installation als
; Postscript-Datei (refcard.ps) mit dabei.
;
;
;      Selektieren
;      ###########
;
; Etwas gewöhnungsbedürftig ist das Markieren (Selektieren) von Text.
; Dazu geht man zum einen Ende des zu markierenden Bereichs. Dort drückt
; man C-Leertaste. Dann geht man mit dem Cursor an das andere Ende des
; Bereichs. Der Cursor ist immer ein Ende des selektierten
; Bereichs.
; Alternativ kann man je nach Benutzeroberfläche auch mit der Maus
; markieren, indem man die linke Taste gedrückt hält. Oder man klickt
; mit der linken Maustaste an das eine Ende des zu markierenden
; Bereichs, und mit der rechten an das andere Ende.
; Mit einem Klick mit der mittleren Maustaste (falls vorhanden) kann man
; den markierten Bereich an eine beliebigen Stelle kopieren.
;
; Die Stelle im Text, an der gerade eine Eingabe eingefügt wird (also
; üblicherweise "Cursor" genannt) heißt beim EMACS "point".
; Die Stelle, die man mit C-space markiert hat, heißt "mark".
; Der markierte Bereich (die "region") erstreckt sich also von mark
; zum point.
;
;
;      Makros
;      ######
;
; Man kann mit
;    C-x (
; eine Makroaufzeichnung starten. Dabei wird alles in einem Makro
; gemerkt, bis man
;    C-x )
; tippt. Dieses Makro kann dann jederzeit mit
;    C-x e
; ausgeführt werden.
;
; An ein bereits definiertes Makro kann man auch noch etwas anhängen mit
;    C-u C-x (
; Dadurch wird das bereits definierte Makro ausgeführt, und jede weitere
; Eingabe bis zum nächsten C-x ) aufgezeichnet und angehängt.
;
; Ganz praktisch ist gelegentlich das Kommando
;    M-x apply-macro-to-region-lines
; Damit wird ein aufgezeichnetes Makro auf jede Zeile des gerade
; markierten Bereichs angewandt.
;
;
;      Argumente:
;      ##########
;
; Manche Kommandos benötigen ein Argument. Das ist eine ganze Zahl, die
; man mit M- beziehungsweise nach einem [Esc], und vor dem eigentlichen
; Kommando eingeben kann.
;
; Die meisten Kommandos benötigen kein Argument, und verwenden ein
; trotzdem eingegebenes Argument als Wiederholungsfaktor.
; Beispielsweise kann man mit der Tastenfolge
;     M-1 2 #
; zwölfmal das Zeichen "#" einfügen.
;     M-2 5 C-x e
; führt das zuletzt aufgezeichnete Makro 25 mal aus.
;
; Dann gibt es weiterhin ein "prefix", das kein Argument mit einem
; konkreten Wert ist, aber trotzdem existieren kann.
; Dieses Präfix kann man durch Drücken von C-u vor dem eigentlichen
; Kommando eingeben. Manche Kommandos verhalten sich dann daraufhin
; anders; beispielsweise kann man in C-Programmen mit C-c C-c einen
; markierten BEreich auskommentieren, dagegegn mit C-u C-c C-c die
; Kommentarzeichen von einem auskommentierten Bereich wieder
; entfernen.
;
;
;      Narrow, widen
;      #############
;
; Man kann bei Bedarf die Sichtbarkeit aller Aktionen auf einen Teil
; eines buffers begrenzen.
; Dann werden alle Operationen wie Suchen, Ersetzen, jedes Umformatieren
; etc. nur in diesem begrenzten Teil stattfinden.
; Den buffer derart zu begrenzen heißt "narrow" (narrow-to-region, C-x n n,
; oder narrow-to-page C-x n p, oder narrow-to-defun C-x n d),
;
; Das Erweitern zurück auf den gesamten buffer heißt "widen" (widen,
; C-x n w).
;
; Bei narrow-to-region wird der aktuell als "region" markierte Teil als
; verbleibender Bereich verwendet, bei narrow-to-page der aktuelle
; Inhalt des Bildschirmfensters (meist ist dieses Kommando aber
; inaktiv). Bei narrow-to-defun ist es vom aktuellen Modus abhängig,
; welcher Bereich verwendet wird. Im lisp-mode ist es die umgebende
; Funktionsdefinition, in C oder C++ dagegen der äußerste umgebende
; Block, als der Rumpf der aktuellen Funktion oder der aktuellen Klasse,
; je nachdem wo der Cursor (in EMACS "point" genannt) gerade steht.
;
;
;      Die wichtigsten Kommandos auf einen Blick
;      #########################################
;
; Die folgende Tabelle ist i.w. ein Auszug aus refcard.ps.
;
; -------------+------------------------------------------------------------
;              |
;  C-z         | EMACS in den Hintergrund bringen/Icon
;              |
;  C-x C-c     | beenden (wenn noch Puffer offen sind, wird man gefragt,
;              | ob man sie nicht speichern möchte)
;              |
;  C-x C-f     | Datei öffnen (in neuen buffer einlesen)
;              |
;  C-x C-s     | buffer in der zugehörigen Datei speichern
;  C-x s       | alle buffer speichern
;  C-x C-w     | buffer unter neuem Namen speichern (save as...)
;              |
;  C-x i       | am Cursor eine andere Datei einfügen
;              |
;  C-x 0       | das aktuelle (EMACS-) window verschwindet, andere
;              | belegen den Platz im frame
;  C-x 1       | das aktuelle (EMACS-) window wird zum einzigen im frame,
;              | und erhält den ganzen Platz im frame.
;  C-x o       | zu einem anderen (EMACS-) window im gleichen frame springen
;              |
;  C-_         | Undo (mehrfach möglich, geht ziemlich weit zurück)
;              |
;  C-g         | ein begonnenes Kommando abbrechen
;              |
;  C-s         | inkrementelles Suchen vorwärts
;  C-r         | dto. rückwärts
;              |
;  C-M-s       | Suche nach regulärem Ausdruck vorwärts
;  C-M-r       | dto. rückwärts
;  M-p         | (bei der Eingabe des Suchstrings:) den letzten String nehmen
;  M-n         | dto. den nächsten
;              |
;  C-b         | ein Zeichen rückwärts/nach links (backward)
;  C-f         | ein Zeichen vorwärts/nach rechts (forward)
;  M-b         | ein Wort rückwärts/nach links
;  M-f         | ein Wort vorwärts/nach rechts
;  C-M-b       | eine Zeile rückwärts/nach oben
;  C-M-f       | eine Zeile vorwärts/nach unten
;              |
;  C-a         | zum Start der Zeile
;  C-e         | zum Ende der Zeile
;  M-a         | zum Anfang des Satzes/Ausdrucks
;  M-e         | zum Ende des Satzes/Ausdrucks
;  C-M-a       | zum Anfang des sexp (syntactical expression)
;  C-M-e       | zum Ende des sexp (syntactical expression)
;  M-<         | zum Anfang des buffer
;  M->         | zum Ende des buffer
;  C-v         | Seite vorwärts
;  M-v         | Seite rückwärts
;  C-l         | aktuelle Zeile mittig in Fenster, Bildschirm komplett
;              | neu aufbauen
;              |
;  C-d         | ein Zeichen löschen
;  M-d         | Wort löschen
;  M-0 C-k     | Zeile bis Cursor löschen
;  C-k         | Zeile ab Cursor löschen
;  C-M-k       | sexp löschen
;  M-k         | Satz/Ausdruck löschen
;  C-w         | markierten Bereich löschen und in Puffer (unter Windows:
;              | auch in Clipboard) kopieren
;  M-w         | markierten Bereich in Puffer (unter Windows: auch in
;              | Clipboard) kopieren
;  C-y         | letzten Inhalt aus dem Puffer wieder am Cursor einfügen
;              |
;  C-Leertaste | aktuelle Stelle als Blockanfang merken
;              |
;  C-x C-x     | Blockanfang und Cursor tauschen
;              |
;  M-%         | Suchen und ersetzen (wenn man dabei reguläre Ausdrücke
;              | verwenden will, muß man tippen:
;              |    M-x query-replace-regexp
;              | Bei jedem Vorkommen des zu ersetzenden Textes hat man
;              | folgende Möglichkeiten:
;              |  Leertaste: Ersetzen, und weitergehen
;              |  [,]-Taste: Ersetzen, nicht mehr weitergehen
;              |  [Del]-Taste: Nicht ersetzen, aber weitergehen
;              |  [!]-Taste:   Dieses, und alle weiteren ersetzen
;              |  [^]-Taste:   Das letzte Ersetzen rückgängig machen
;              |  [Return] :   Fertig
;              |
;  [Tab]-Taste | je nach Modus richtig einrücken
;  C-x [Tab]   | alle Zeilen im markierten Bereich um (Argument)
;              | Spalten nach rechts einrücken (wenn Argument>0)
;              | bzw. nach links.
;              |
;  M-u         | Das folgende Wort in Großbuchstaben verwandeln
;  M-l         | dto. in Kleinbuchstaben
;  M-c         | Den nächsten Buchstaben groß, Rest des Wortes klein
;  C-x u       | markierten Bereich in Großbuchstaben
;  C-x l       | dto. in Kleinbuchstaben
;              |
;  C-x b       | anderen buffer wählen
;  C-x C-b     | alle buffer in einem (EMACS-) window listen
;              | (Auswählen eines buffers mit mittlerer Maustaste)
;  C-x k       | buffer löschen
;              |
;  C-t         | zwei Zeichen vertauschen (das unter dem Cursor, und
;              | das davor).
;              | Wenn unter dem Cursor kein Zeichen ist, weil man am
;              | Ende der Zeile ist, dann halt die zwei Zeichen vor
;              | dem Cursor.
;  M-t         | Zwei Worte vertauschen
;  C-x C-t     | Zwei Zeilen vertauschen
;  C-M-t       | Zwei sexp vertauschen
;              |
;  C-x r k     | (markiertes) Rechteck löschen und merken
;  C-x r y     | gemerktes Rechteck an Cursor einfügen
;  C-x r r     | (markiertes) Rechteck in Register kopieren
;              | (Nach dem Befehl ist ein Zeichen anzugeben, das ist
;              | der Name des Registers)
;  C-x r i     | Inhalt des Registers einfügen (nach dem Befehl
;              | ist wieder das Zeichen des Registers beim Abspeichern
;              | anzugeben)
;              | NB: In Registern kann man nicht nur Rechtecke,
;              | sondern auch andere Dinge speichern (Fenster-
;              | konfigurationen, Textausschnitte, Cursorpositionen
;              | etc.; siehe Doku).
;  C-x r o     | Rechteck nach rechts schieben
;  C-x r c     | Rechteck löschen
;              |
;  C-x (       | Start einer Makroaufzeichnung
;  C-x )       | Ende der Makroaufzeichnung
;  C-x e       | Makro ausführen
;  C-u C-x e   | Makro ausführen, und weitere Kommandos aufzeichnen
;              | (bis wieder ein C-x ) kommt.
;              | Das neue Makro enthält alles aus dem bisherigen,
;              | plus das neu aufgezeichnete.
;              |
;              | Mit
;              |    M-x name-last-kbd-macro
;              | kann man einem Makro einen Namen geben.
;              | Mit
;              |    M-x insert-kbd-macro
;              | kann man im aktuellen buffer den LISP-Code zu
;              | einem Makro einfügen (z.b., um es dann auszuschneiden
;              | und in der Initialisierungsdatei zu hinterlegen).
;              | Ein benamstes Makro kann man mit
;              |     M-x name
;              | wieder ausführen.
;              |
;
;
;      FTP-Adressen
;      ############
;
; Als Dateiname (beispielsweise zum Öffnen einer Datei mit C-x C-f)
; kann man auch eine ftp-Adresse angeben, falls auf dem entsprechenden
; Rechner ein ftp-Server läuft und man eine Zugangsberechtigung hat.
; Wenn ich eben mal in einer HTML-Datei meiner Homepage, die von
; einem Provider gehostet wird, etas ändern will, dann kann ich diese
; Datei direkt vom EMACS aus öffnen:
;    C-x C-f /ftp31331@www.wachtler.de:/www.wachtler.de/index.html
; Das Schema einer solchen Datei ist:
;    /username@rechnername:/pfad/zur/datei
; Nach einem [Return] wird man nach dem Passwort gefragt, der EMACS holt
; sich die Datei per ftp, und man kann fröhlich darin editieren.
; Bei jedem Abspeichern wird der aktuelle Inhalt dann wieder per ftp
; zurückgeschrieben.
;
;
;      Debuggen
;      ########
;
; Mit M-x gdb kann man den gdb aufrufen zum Debuggen eines
; kompilierten Programms.
; Dazu wird ein neues Fenster geöffnet (kein frame!), in dem man die
; gdb-Kommandos eingeben kann (das ist das GUD-Fenster).
; Als Abkürzung kann man im GUD-Fenster einige Kommandos
; mit C-c... eingeben, oder mit C-x C-a... in jedem Fenster.
; Das was nach C-c bzw. nach C-x C-a kommt, ist jeweils gleich:
;
; -------------+------------------------------------------------------------
;              |
;  C-c C-l     | display last line referred to in another window
;  C-x C-a C-l |
;              |
;  C-c C-s     | step (zur nächsten Quelltextzeile gehen, ggf. in
;  C-x C-a C-s | einer aufgerufenen Funktion)
;              |
;  C-c C-n     | next (wie step, aber nur in der aktuellen Funktion
;  C-x C-a C-n | oder beim Aufrufer)
;              |
;  C-c C-i     | step instruction (einen Maschinenbefehl weitergehen)
;  C-x C-a C-i |
;              |
;  C-c C-r     | continue (laufe bis zum nächsten break point, oder
;  C-x C-a C-r | Signal, oder Programmende)
;              |
;  C-c C-d     | delete break point on current line
;  C-x C-a C-d |
;              |
;  C-c C-t     | set break point on current line
;  C-x C-a C-t |
;              |
;  C-c C-f     | finish (run program until selected stack frame
;  C-x C-a C-f | returns)
;              |
;  C-c C-<     | up (select next enclosing stack frame)
;  C-x C-a C-< |
;              |
;  C-c C->     | down (select next inner stack frame)
;  C-x C-a C-> |
;              |
;
; Zudem kann man mit C-<SPC> (also Ctrl und Leertaste) an der aktuellen
; Stelle einen break point setzen.
;
;
;      LISP
;      ####
;
; Etwas anspruchsvoller ist es, den EMACS gezielt anzupassen. Da der
; EMACS eigentlich nur ein LISP-Interpreter ist, der mit entsprechenden
; LISP-Programmen erst zum Editor wird, kann man eigene Anpassungen
; vornehmen, indem man LISP-Funktionen schreibt, und diese an passenden
; Stellen aufruft.
;
; Einige kleinere Anpassungen kann man direkt mit EMACS-Kommandos
; vornehmen (z.B. Definition von Makros, oder Ändern der
; Tastaturbelegung). Auf Dauer kommt man aber an einem Minimum
; LISP-Wissen nicht vorbei. Dies beginnt schon bei der
; Initialisierungsdatei, mit der jeder Benutzer sich "seinen" EMACS
; basteln kann. Diese Datei (auf Unix-Systemen .emacs, in der DOS-Welt
; _emacs) ist nichts anderes als LISP-Code.
; Die hier vorliegende Datei ist in Beispiel für eine solche
; Initialisierungsdatei.
;
;
;
;      Weitere Unterlagen
;      ##################
;
;
; a) GNU Emacs Manual (ca. 200 Seiten, über ftp: emacs-manual-6_0_dvi.gz)
; b) Einführung in EMACS LISP (ca. 250 Seiten, emacs-lisp-intro_1_05_tar.gz)
; c) EMACS LISP Referenz (ca. 900 Seiten, elisp-manual-20-2_5_tar.gz)
; d) NT-Emacs-FAQ
; e) info (online)
; f) Von O'Reilly gibt es ein Buch über den GNU-Emacs
; ... und tausend andere
;
; Das GNU Emacs Manual paßt zur nicht mehr aktuellen Version 19. Derzeit
; im Umlauf ist die Version 21. Der Inhalt des Buches ist nicht
; falsch, aber inzwischen etwas unvollständig.
;
;
; Bei neueren Versionen hat sich insbesondere die Anpassung an
; Benutzervorstellungen vereinfacht: Man kann Anpassungen teilweise vom
; EMACS direkt in der Initialisierungsdatei vornehmen zu lassen, ohne
; von Hand den LSIP-Code ändern zu müssen.
;
; Die jeweils aktuelle Version ist im EMACS selbst dokumentiert, in Form
; sogenannter info-Dateien. Diese können im EMACS direkt gelesen werden
; (C-h i), oder mit TeX in eine druckbare Form gebracht werden. Es gibt
; auch andere Programme, um die Dateien online anzuzeigen (info, xinfo,
; tkinfo, ...).
;
;
;
;      Zu den hier verwendeten LISP-Befehlen
;      #####################################
;
;
; Mit
;     (setq variablenname wert)
; kann man einer (evtl. neuen) Variable einen Wert zuweisen.
; Der Typ der Variable ergibt sich dabei aus der Zuweisung.
;
; Mit
;     (setq-default variablenname wert)
; kann man einer Variable, die in verschiedenen Modi (C, C++, Text, ...)
; vorkommen kann, einen Standarwert geben. Dieser Wert wird dann als
; Anfangswert genommen, wenn DANACH ein Puffer in einen anderen Modus
; übergeht (also beispielsweise eine neue Datei geladen wird).

; Mit
;     (global-set-key "Tastenkombination" 'funktionsname)
; kann man einer Tastenkombination einen Funktionsaufruf zuordnen.
; Diese Einstellung gilt dann für alle Modi, die nicht selbst diese
; Kombination übersteuern (daher "global").
; Der Apostroph vor dem Funktiosnanmen bewirkt, daß hier nicht die
; Funktion aufgerufen wird, und ihr Ergebnis an global-set-key
; übergeben würde.
; Da viele Erweiterungspakete für den Emacs existieren und ständig
; neue entstehen, sollte man etwas darauf achten, welche
; Tastenkombinationen man sich selbst definiert, um nicht mit bereits
; existierenden oder noch auftauchenden Kommandos zu kollidieren.
; Recht gefahrlos ist die Verwendung von Tastenkombinationen, die mit
; C-c (also Strg+c) beginnen. Denn diese sind für privaten Gebrauch
; reserviert.
; Wenn man also eigene Kommandos auf Tastatutkombinationen legen möchte,
; guckt man am besten nach, ob eine Wunschkombination noch frei ist, die
; mit C-c beginnt.
; Das kann man mit M-x describe-variable machen.
;
;
; Wenn der EMACS in einen neuen Modus wechselt (beispielsweise in
; den c-mode), dann werden alle Funktionen einer dafür vorgesehenen
; Liste abgearbeitet.
; Mit einem Aufruf von add-hook wird an eine solche Liste eine eigene
; Funktion angehängt.
; Für jeden Modus existiert eine solche Liste.
; Man könnte also mit
;     (add-hook 'c-mode-hook 'meine-funktion-fuer-c-mode)
; eine solche Funktion für den c-mode anhängen.
; Da für C und C++ viele Dinge gleich sind, gibt es einen
; c-mode-common-hook, der wowohl für c-mode als auch für c++-mode
; verwendet wird.
;
;
;
;                 Informationen und Literatur
;                 ###########################
;
; Zum EMACS gibt es natürlich Literatur bis zum Abwinken.
;
; Die wichtigsten Dokus sind:
;
;  - dieser Text :-))
;
;  - GNU-EMACS-Howto (im EMACS mit C-h F zu erreichen, oder
;    - beispielsweise von
;      ftp://ftp.uni-paderborn.de/pub/doc/FAQ/comp/emacs/)
;    - oder bei Linux gleich mit dabei
;
;  - GNU-EMACS FAQ for Windows 95/98/ME/NT/XP and 2000
;
;  - GNU EMACS Manual (Richard M. Stallman)
;    - http://www.gnu.org/manual/emacs/ps/emacs.ps.gz (Postscript)
;    - http://www.gnu.org/manual/emacs/index.html (HTML)
;    - oder bei Linux gleich mit dabei
;
;  - Emacs Lisp Reference Manual
;    - http://www.gnu.org/manual/elisp-manual-21-2.6/elisp.html (HTML)
;    - ftp://ftp.gnu.org/pub/gnu/emacs/elisp-manual-21-2.6.tar.gz (Info)
;    - oder bei Linux gleich mit dabei
;
;  - Programming in EMACS LISP
;    An Introduction
;    (elispint.ps beispielsweise)
;
;  - Die eingebauten Hilfen (C-h C-f für jede Funktion, C-h F für die
;    FAQ, C-h i oder M-x info zum Lesen von Dateien im Info-Format,
;    C-h v zum Anzeigen der Beschreibung und des Werts jeder Variable,
;    usw.)
;
;  - http://www.dotemacs.de/
;
;  - http://tiny-tools.sourceforge.net/emacs-keys.html
;
;  - http://www.dotfiles.com
;
;  - NT-EMACS: http://www.gnu.org/software/emacs/windows/ntemacs.html
;
;  - http://wonderworks.com/
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


; Meine momentane Tastenbelegung:
; F1       Vervollständigen eines angefangenen Worts
; F2       springt zwischen öffnender und schießender Klammer hin und her
; F3       fügt das Datum an der Cursorposition ein
; S-F3     wie F3, aber zusätzlich mit Uhrzeit
; F4       addiert alle Zahlen in einem markierten Rechteck
; F5       fügt "Mit freundlichen Grüßen, Klaus Wachtler" ein
; S-F5     fügt "Viele Grüße, Klaus Wachtler" ein
; F6       step instruction in gdb
; F7       step in gdb
; F8       next in gdb
; F9       cont in gdb
; F12      in C/C++: Einfügen von "->"
;          in TeX: markierten Bereich in ein \index{} hineinkopieren
; C-c C-i  markierten Bereich richtig einrücken (indent-region)
; C-7      Einfügen von "{}"
; C-8      Einfügen von "[]"
; M-,      ein Zeichen aus der Zeile drüber kopieren
; M-;      ein Wort aus der Zeile drüber kopieren
; C-c _    undo (weil das dafür vorgesehene C-_ unter Windows zumindest
;          früher nicht ging)

(global-set-key [f1] 'dabbrev-expand)
(message "F1 gesetzt: dynamische Abkuerzung einfuegen")

; load-path um einen Eintrag ergänzen, der ins Homeverzeichnis zeigt:
(setq load-path (cons "~/.elisp" load-path))


;;;;
;;;; Mit [F2] zwischen öffnenden und schließenden Klammern springen:
;;;;
;;
;; Here's my take on it:
;;
(defun joc-bounce-sexp ()
  "Will bounce between matching parens "[{(<" && ">)}]" just like % in vi"
  (interactive)
  (let ((prev-char (char-to-string (preceding-char)))
         (next-char (char-to-string (following-char)))
         )
    (cond ((string-match "[[{(<]" next-char) (forward-sexp 1))
           ((string-match "[]})>]" prev-char) (backward-sexp 1))
           (t (error "%s" "Not on a paren, brace, or bracket"))
           )
    )
  )
;; ----- bounce back & forth between matching parens, braces or brackets -----
(global-set-key [f2] 'joc-bounce-sexp)
(message "F2 gesetzt: zwischen oeffnender und schliessender Klammer springen")
;;
;; I'm not quite sure I'm using the word sexp right, but the function works....
;; Regards,
;; joe
;; joc@netaxs.com


;insert date into buffer
(defun insert-date ()
  "Insert date at point."
  (interactive)
  ;(insert (format-time-string "%a %b %e, %Y %l:%M %p"))
  (insert (format-time-string "%02e.%02m.%Y"))
  )

;insert date into buffer
(defun insert-date-time ()
  "Insert date at point."
  (interactive)
  ;(insert (format-time-string "%a %b %e, %Y %l:%M %p"))
  (insert (format-time-string "%02e.%02m.%Y %02H:%02M"))
  )

(global-set-key [f3] 'insert-date)
(message "F3 gesetzt: aktuelles Datum einfuegen")
(global-set-key [\S-f3] 'insert-date-time)
(message "S-F3 gesetzt: Datum und Uhrzeit einfuegen")


; Mit freundlichen Grüßen, Viele Grüße:
(defun insert-mfg ()
  "Insert: Mit freundlichen Grüßen, Klaus Wachtler"
  (interactive)
  (insert "Mit freundlichen Grüßen, Klaus Wachtler")
  )

(defun insert-viele-gruesse ()
  "Insert: Viele Grüße, Klaus Wachtler"
  (interactive)
  (insert "Viele Grüße, Klaus Wachtler")
  )

(global-set-key [f5] 'insert-mfg)
(message "F5 gesetzt: Mit freundlichen Grüßen")
(global-set-key [\S-f5] 'insert-viele-gruesse)
(message "S-F5 gesetzt: Viele Grüße")



(defun rect-sum() "Addiert alle Zahlen im markierten Rechteck,\ngibt die Summe als message aus,\nund speichert sie auch im kill-ring (zum Wiedereinfuegen)\n23.01.2002 Klaus Wachtler"
  (interactive)
  ( let( (r (extract-rectangle (mark) (point))) ; Rechteck nach r holen:
         woerter
         (summe 0)
         )
    ; In r steht jetzt eine Liste der einzelnen Zeilen des Rechtecks.
    ; Schleife über alle Zeilen des Rechtecks:
    (while r
      (setq woerter (split-string (car r))) ; Zeile zu Liste von Wörtern machen
      ; Schleife über die Wörter einer Zeile:
      (while woerter
        (setq summe (+ summe (string-to-number (car woerter)))) ; addieren
        (setq woerter (cdr woerter))   ; Liste um erstes Wort kürzen
        )
      (setq r (cdr r))  ; Liste um erste Zeile erleichtern
      )
    ; Summe im mini buffer und in den *Message*-buffer ausgeben:
    (message "Summe ist %s" summe)
    ; in kill-ring setzen (dann kann der String mit yank, z.B. C-y
    ; jederzeit wieder eingefügt werden):
    (kill-new (number-to-string summe))
    )
  )

(global-set-key [f4] 'rect-sum)
(message "F4 gesetzt: alle Zahlen im markierten Rechteck addieren")




(global-auto-revert-mode 1)    ; autorevert buffers if files change


;(auto-insert-mode 1)           ; bei neuen Dateien gleich ein Template laden
;(setq auto-insert-directory "~/.emacstemplates")

; Wenn ein buffer größer ist als dieser Wert, dann wird er nicht
; gemäß Syntaxregeln bunt eingefärbt (je nach mode)
(setq font-lock-maximum-size 1000000)


;;; >
;;; > To insert a time stamp, you want time-stamp.el.
;;; >
;;; > ; time stamp (Time-stamp: " " in first eight lines of file)
;;; >
;;; > (add-hook 'write-file-hooks 'time-stamp)
;;; > (setq time-stamp-active t)
;;; > (setq time-stamp-format "%02d %:b %:y %02H:%02M:%02S")
;;; >
;;; > So if your header text has the special time stamp text in the first 8
;;; > lines, you'll get a time stamp every time you write the file.
;;; >
;;; > I don't know how to add the current user name.


; time stamp (Time-stamp: " " in first eight lines of file)

(add-hook 'write-file-hooks 'time-stamp)
(setq time-stamp-active t)
(setq time-stamp-format "%02d.%02m.%02y %02H:%02M %f %u?%h")

; aus time-stamp.el:
; A string is used verbatim except for character sequences beginning with %:
;
; %:a  weekday name: `Monday'.            %#A gives uppercase: `MONDAY'
; %3a  abbreviated weekday: `Mon'.        %3A gives uppercase: `MON'
; %:b  month name: `January'.             %#B gives uppercase: `JANUARY'
; %3b  abbreviated month: `Jan'.          %3B gives uppercase: `JAN'
; %02d day of month
; %02H 24-hour clock hour
; %02I 12-hour clock hour
; %02m month number
; %02M minute
; %#p  `am' or `pm'.                      %P  gives uppercase: `AM' or `PM'
; %02S seconds
; %w   day number of week, Sunday is 0
; %02y 2-digit year: `97'                 %:y 4-digit year: `1997'
; %z   time zone name: `est'.             %Z  gives uppercase: `EST'
;
; Non-date items:
; %%   a literal percent character: `%'
; %f   file name without directory        %F  gives absolute pathname
; %s   system name
; %u   user's login name                  %U  user's full name
; %h   mail host name
;
; Decimal digits between the % and the type character specify the
; field width.  Strings are truncated on the right; years on the left.
; A leading zero causes numbers to be zero-filled.


(global-set-key [f6] 'gud-stepi)
(message "F6 gesetzt: gud step instruction (naechst. Maschinenbefehl)")
(global-set-key [f7] 'gud-step)
(message "F7 gesetzt: gud step (naechste Anw., ggf. in f())")
(global-set-key [f8] 'gud-next)
(message "F8 gesetzt: gud next (naechste Anw., f() ueberspringen)")
(global-set-key [f9] 'gud-cont)
(message "F9 gesetzt: gud continue")


; Unter Linux tritt manchmal folgendes Problem auf:
; Wenn man in einem xterm ein "su -" macht, dann wird zwar die TERM-Variable
; (TERM=xterm) an die neue shell weiterverebt, aber nicht die DISPLAY-Variable.
; Wenn man dann den EMACS aufruft, bewirkt ein Drücken der Backspace-Taste
; ein C-h, was wiederum als Prefix (für die Hilfefunktionen) interpretiert
; wird. In einem solchen Fall wird mit der folgenden Anpassung ein Umdefinieren
; erreicht. Die Hilfefunktionen sind dann nicht erreichbar (mit C-h), und
; stattdessen hat man wieder ein Backspace.


(defun Ctrl-h-als-DEL ()
  "Ctrl-h-als-DEL definiert die Tastaturtabelle so um, daß C-h nicht mehr als Prefix für Hilfe zählt, sondern Backspace ermöglicht"
  (keyboard-translate ?\C-h ?\C-?)
  (keyboard-translate ?\C-? ?\C-h)
  )

(if (and (string= (getenv "TERM") "xterm") (not (getenv "DISPLAY") ) )
    (Ctrl-h-als-DEL)
  )


;  ; ersetzt den Text unter dem Cursor (zwischen dem vorhergehenden und dem
;  ; nachfolgenden Leerzeichen) durch das aktuelle Datum.
;  ; geht nur unter Unix/Linux, nicht NT
;  (defun update-datum () "ersetzt das aktuelle Wort durch das aktuelle Datum"
;    (interactive)
;    (search-forward " ")
;    (backward-char)
;    (push-mark)
;    (set-mark (point))
;    (search-backward " ")
;    (forward-char)
;    (delete-region (mark) (point))
;    (pop-mark)
;    (shell-command "echo -n `date +%d.%m.%Y`" t )
;    )
;  
;  (global-set-key [f1] 'update-datum)





; mit C-c M-% startet ein Suchen und Ersetzen mit regulären Ausdrücken:
;(global-set-key "\C-c\M-%" 'query-replace-regexp)



; mit C-c i kann man den markierten Bereich gemäß aktueller
; Syntax einrücken lassen:
(global-set-key "\C-c\C-i" 'indent-region)
(message "C-c C-i gesetzt: markierten Block einruecken")

; zusammengehörige Klammernpaare anzeigen lassen:
(show-paren-mode t)



;; Maus mit Rad: Mit dem Rad rauf und runter blättern:

(defun scroll-up-half ()
  "Scroll up half a page."
  (interactive)
  (scroll-up (/ (window-height) 2))
)

(defun scroll-down-half ()
  "Scroll down half a page."
  (interactive)
  (scroll-down (/ (window-height) 2))
)
(global-set-key [(mouse-5)] 'scroll-up-half)
(global-set-key [(mouse-4)] 'scroll-down-half)


;; 03.10.2003 kw: scheint nicht mehr zu gehen unter akutellem Linux (Debian)
;; ;;; For imwheel
;; (setq imwheel-scroll-interval 3)
;; (defun imwheel-scroll-down-some-lines ()
;;   (interactive)
;;   (scroll-down imwheel-scroll-interval))
;; (defun imwheel-scroll-up-some-lines ()
;;   (interactive)
;;   (scroll-up imwheel-scroll-interval))
;; (global-set-key [?\M-\C-\)] 'imwheel-scroll-up-some-lines)
;; (global-set-key [?\M-\C-\(] 'imwheel-scroll-down-some-lines)
;; 
;; (define-key global-map [(control \))] 'imwheel-scroll-up-some-lines)
;; (define-key global-map [(control \()] 'imwheel-scroll-down-some-lines)
;;  ;;; end imwheel section


(defun c-deref-operator ()
  "Einfuegen eines deref-operators (->)"
  (interactive)
  (insert "->")
  )



; bei jedem Suchen mit C-s oder C-r springt der Cursor wie gehabt zum nächsten
; gefundenen Vorkommen. Zusätzlich werden die dann folgenden Vorkommen gleich
; farblich markiert.
; Benötigt die Datei ishl.el oder ishl.elc im lisp-Verzeichnis:
(require 'ishl)
(ishl-mode t)


; Falls der EMACS auch als IRC-Client fungieren soll: ERC
; (require 'erc)



;(require 'cc-mode)
;(modify-syntax-entry ?_ "w" c++-mode-syntax-table)

;(require 'c-mode)
;(modify-syntax-entry ?_ "w" c-mode-syntax-table)


; ich will keine TABs im Text haben (sonst stimmt beim Austausch mit anderen
; Editoren (DevStudio) die Formatierung nicht mehr).
;(setq-default indent-tabs-mode t)
(setq-default indent-tabs-mode nil)

(defun meine-ergaenzungen-zu-picture-mode()
  ;(setq-default indent-tabs-mode nil)
  ; ggf. weitere Anpassungen fuer picture-mode-common-hook
)

(add-hook 'picture-mode-common-hook 'meine-ergaenzungen-zu-picture-mode)


; Eine LISP-Funktion wird mit "defun" definiert:
;   ( defun funktionsname
;     ( parameterliste )
;     "beschreibender Text"
;     (interactive)
;     (Anweisung 1)
;     (Anweisung 2)
;     (Anweisung ...)
;     )
;
; Wenn man keine Parameterliste hat, dann läßt man die Klammern leer.
;
; Der beschreibende Text wird angezeigt, wenn der Benutzer
; M-x describe-function zu dieser Funktion aufruft.
;
; Durch das (interactive) kann man die Funktion als Benutzer direkt
; aufrufen.
;
; Die darauf folgenden Anweisungen werden in der angegebenen Reihenfolge
; ausgeführt.
;
; Die i.F. definierte Funktion geschweifte-klammern fügt ein paar
; geschweifter Klammern ein, und geht dann wieder mit dem Cursor ein
; Zeichen nach links, damit man zwischen den Klammern weiterschreiben kann.
;
; Aufrufen kann man eine LISP-Funktion in der Form:
;     (funktionsname parameter1 parameter2 ... )
;
;
(defun geschweifte-klammern ()
  "Einfuegen von geschweiften Klammern {}"
  (interactive)
  (insert "{}")
  (backward-char 1)
  )

(global-set-key "\C-c7" 'geschweifte-klammern)
(message "C-c 7 gesetzt: '{}' einfuegen")

(defun eckige-klammern () "Einfuegen von eckigen Klammern []"
(interactive)
  (insert "[]")
  (backward-char 1)
)

(global-set-key "\C-c8" 'eckige-klammern)
(message "C-c 8 gesetzt: '[]' einfuegen")

; kopiert aus der vorhergehenden Zeile ein Zeichen in die aktuelle:
(defun copy-char-from-previous-line()
  "kopiert ein Zeichen aus der letzten Zeile in die aktuelle Zeile"
  (interactive)
  (push-mark)                  ; merken, um danach die ursprüngliche
  (set-mark (point))           ; Stelle zu finden

  ; aus irgendwelchen kühlen Gründen wird manchmal nicht kopiert, wenn man
  ; wenn man am Zeilenende steht,
  ; sondern man springt stattdessen in die nächste
  ; Zeile. Wenn man vorher allerdings etwas schreibt, und wieder löscht, dann
  ; klappts.?!?
  ; Also etwas schreiben, und wieder löschen:
  (insert " ")
  (backward-delete-char 1)

  (push-mark)

  (previous-line 1)            ; eine Zeile hoch
  (set-mark (point))           ; Markierung setzen
  (forward-char 1)             ; ein Zeichen weiter
  (copy-region-as-kill         ; das markierte Zeichen in yank-Puffer kopieren
   (mark)
   (point)
   )

  (pop-mark)
  (exchange-point-and-mark)    ; ursprüngliche Stelle wiederfinden
  (pop-mark)
  (yank)                       ; das Zeichen aus dem Puffer einfügen
  )

(defun copy-word-from-previous-line()
  "kopiert ein Wort aus der letzten Zeile in die aktuelle Zeile"
  (interactive)
  (push-mark)                  ; merken, um danach die ursprüngliche
  (set-mark (point))           ; Stelle zu finden
  (push-mark)

  (previous-line 1)            ; eine Zeile hoch
  (set-mark (point))           ; Markierung setzen
  (forward-word 1)             ; ein Wort weiter
  (copy-region-as-kill         ; das markierte Wort in yank-Puffer kopieren
   (mark)
   (point)
   )

  (pop-mark)
  (exchange-point-and-mark)    ; ursprüngliche Stelle wiederfinden
  (pop-mark)
  (yank)                       ; das Wort aus dem Puffer einfügen
  )

(global-set-key "\M-," 'copy-char-from-previous-line)
(message "M-, gesetzt: ein Zeichen aus der Zeile drueber kopieren")
(global-set-key "\M-;" 'copy-word-from-previous-line)
(message "M-; gesetzt: ein Wort aus der Zeile drueber kopieren")

; \index{}-Befehl für LaTeX:
(defun latex-region-to-index ()
"latex-region-to-index kopiert region in einen \index{}-Befehl hinter der
region.
Beispiel: Wenn im Text:
      \"...was ist ein DBMS?...\"
das Wort \"DBMS\" markiert ist, dann macht die Funktion daraus:
      \"...was ist ein DBMS\\index{DBMS}?...\""
  (interactive)
  (copy-region-as-kill (mark) (point))
  (insert "\\index{")
  (yank)
  (insert "}")
)

;;; To use it, copy it to _emacs in a directory where emacs will
;;; search it. Were will emacs search it? If emacs installed in a
;;; directory named `bin', it will search _emacs in the parent
;;; directory, else it will search it in the directory it is installed
;;; in. Setting the environment variable `HOME' probably interferes
;;; with this scheme.


; standard-display-european is a compiled Lisp function in `disp-table.el'.
; (standard-display-european arg)
; 
; Semi-obsolete way to toggle display of ISO 8859 European characters.
; 
; This function is semi-obsolete; if you want to do your editing with
; unibyte characters, it is better to `set-language-environment' coupled
; with either the `--unibyte' option or the EMACS_UNIBYTE environment
; variable, or else customize `enable-multibyte-characters'.
; 
; With prefix argument, this command enables European character display
; if arg is positive, disables it otherwise.  Otherwise, it toggles
; European character display.
; 
; When this mode is enabled, characters in the range of 160 to 255
; display not as octal escapes, but as accented characters.  Codes 146
; and 160 display as apostrophe and space, even though they are not the
; ASCII codes for apostrophe and space.
; 
; Enabling European character display with this command noninteractively
; from Lisp code also selects Latin-1 as the language environment, and
; selects unibyte mode for all Emacs buffers (both existing buffers and
; those created subsequently).  This provides increased compatibility
; for users who call this function in `.emacs'.

; (standard-display-european 1)

;;;  1. 7.97 kw: Funktion pps:
;;; Damit kann man den emacs so aufrufen, daß er eine Datei in Postscript
;;; konvertiert, den PS-Code abspeichert, und sich dann beendet.
;;; Unter NT geht das so:   runemacs %1 -f pps --kill
;;; Unter Linux:            emacs -nw %1 -f pps --kill
(defun pps() "pps gibt den aktuellen Puffer in eine
PS-Datei aus.
Dateiname ist der Dateiname des Puffers mit angehaengtem .ps.
 1. 7.97 AnyWare Klaus Wachtler"
  (interactive)
  (ps-print-buffer (concat buffer-file-name ".ps" ) )
  )

(defun ppsc() "ppsc gibt den aktuellen Puffer mit Syntaxhighlighting in eine
PS-Datei aus.
Dateiname ist der Dateiname des Puffers mit angehaengtem .ps.
 1. 7.97 AnyWare Klaus Wachtler"
  (interactive)
  (ps-print-buffer-with-faces (concat buffer-file-name ".ps" ) )
  )


; Mit dem Paket gnuserv wird der EMACS zu einem Server, der durch Kommandos
; von außen fernbedienbar ist. Diese Kommandos kommen meist aus dem Programm
; gnuclient (oder unter Windows gnuclientw).
; Wenn man gnuclient aufruft, aber noch kein EMACS läuft, dann wird er
; halt gestartet, ansonsten wird der bereits laufende verwendet um die
; Kommandos auszuführen.
; Wenn man nun nie den EMACS aufruft, sondern zum Editieren nur noch
; gnuclient benutzt, dann muß EMACS nur noch einmal gestartet werden
; -> geht schneller, außerdem hat man dann immer aller buffer gleichzeitig
; im Zugriff.
(unless (fboundp 'temp-directory)
  (defun temp-directory ()
    "Return the pathname to the directory to use for temporary files.
On NT/MSDOS, this is obtained from the TEMP or TMP environment variables,
defaulting to the value of `temporary-file-directory' if they are both
undefined.  On Unix it is obtained from TMPDIR, with the value of
`temporary-file-directory' as the default."

    (if	(eq system-type 'windows-nt)
	(cond
	 ((getenv "TEMP"))
	 ((getenv "TMP"))
	 (t (directory-file-name temporary-file-directory)))
      (cond
	  ((getenv "TMPDIR"))
	  (t (directory-file-name temporary-file-directory))))))

  (require 'gnuserv-compat)
  (gnuserv-start)
  ;(setq gnuserv-frame nil)              ; jeweils ein neuer frame


;;; ;;; 14. 3.99 Klaus Wachtler: Unterscheidung zwischen Win95/NT einerseits,
;;; ;;; und X-Windows andererseits.
;;; ;;; Grund: das Paket gnuclientw kann und braucht man nur unter Windows
;;; ;;; laden.
;;; (defun meine-win32-anpassungen()
;;;   "macht Anpassungen an Win32"
;;;   (message "Anpassungen an Win32")
;;; 
;;; ; die folgenden will ich jetzt (13.06.2002) auch unter Unix haben;
;;; ; deshalb nach oben verschoben:
;;; ;  (require 'gnuserv)                    ; mit diesen beiden Zeilen
;;; ;  (gnuserv-start)                       ; kann man eine Verbindung von
;;;                                         ; VC++ 5.0 aus
;;;                                         ; herstellen.
;;;                                         ; Nötig sind die Pakete
;;;                                         ; gnuserv (für den EMACS)
;;;                                         ; und VisEmacs (für
;;;                                         ; DeveloperStudio).
;;; 
;;;   )
;;; 
;;; (defun meine-x-anpassungen()
;;;   "macht Anpassungen an X-Windows"
;;;   (message "Anpassungen an X-Windows")
;;;                                         ; ...
;;;   )
;;; 
;;; (if (string= "w32" window-system)
;;;     (meine-win32-anpassungen)
;;;   (if (string= "x" window-system)
;;;       (meine-x-anpassungen)
;;;     (message "kein X-Windows, kein Win32!")
;;;     )
;;;   )
;;; 
;;; 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Ergaenzungen 5.4.96 Klaus Wachtler:
;;;
;;; a) ob beim Suchen Gross-/Kleinschreibung unterschieden wird, ist
;;;    eigentlich egal. Aber wenn case-fold-search auf t steht, dann
;;;    klappen auch Ergaenzungen (M-/) nicht so recht. ZB. wird nach dem
;;;    Text: "AnyWare" das Wort "An" durch M-/ zu "Anyware" anstatt
;;;    "AnyWare" ergaenzt. So gehts besser (dann klappt's auch mit dem
;;;    Nachbarn):
(defun kw-ergaenzungen-zu-c-c++-mode()
  "Ergaenzungen zu c-mode:
a) schaltet Unterscheidung Gross-/Klein ein
b) schaltet abbrev-mode ein
5.4.96 kw"
  (local-set-key [f12] 'c-deref-operator)
  (message "F12 gesetzt: '->' einfuegen (nur C/C++)")

  ;if (0)          becomes        if (0)
  ;    {                          {
  ;       ;                           ;
  ;    }                          }
  (c-set-offset 'substatement-open 0)

  ;first arg of arglist to functions: tabbed in once
  ;(default was c-lineup-arglist-intro-after-paren)
  ;(c-set-offset 'arglist-intro '+)


  ;second line of arglist to functions: tabbed in once
  ;(default was c-lineup-arglist)
  ;(c-set-offset 'arglist-cont-nonempty '+)


  ;switch/case:  make each case line indent from switch
  (c-set-offset 'case-label '+)

  ;make open-braces after a case: statement indent to 0 (default was '+)
  (c-set-offset 'statement-case-open '+)

  ;make a #define be left-aligned 
  (setq c-electric-pound-behavior (quote (alignleft)))


  ; c-auto-state fügt selbständig LF ein (z.B. nach ';'),
  ; c-hungry-state löscht statt eines whitespace gleich alle:
  (c-toggle-hungry-state 1)
  ;(set-frame-height (selected-frame) 45)
  ;(set-frame-width (selected-frame) 72)
  ( setq case-fold-search nil )
  ( setq abbrev-mode t )
  ( setq c-auto-newline nil )
  ; die folgenden Zeilen, um mit filladapt Kommentare besser zu
  ; formatieren (benötigt filladapt.el/filladapt.elc von
  ; http://cc-mode.sourceforge.net/filladapt.php und klappt am besten mit
  ; cc-* http://download.sourceforge.net/cc-mode/cc-mode-5.28.tar.gz);
  '(require 'filladapt)
  ;(cc-setup-filladapt)
  '(filladapt-mode 1)

  ; und wenn das mit dem automatischen Formatieren in den Kommentaren
  ; schon so schön klappt, dann kann man das auch gleich laufend
  ; automatisch machen lassen:
  (auto-fill-mode t)
  )

(add-hook 'c-mode-common-hook 'kw-ergaenzungen-zu-c-c++-mode)
(add-hook 'cc-mode-hook 'kw-ergaenzungen-zu-c-c++-mode)


;(add-hook 'c-mode-common-hook 'kw-ergaenzungen-zu-gdb-mode)


;;;    (einfach mit (setq...) setzen reicht nicht, da case-fold-search
;;;    offenbar durch den c-mode danach noch uebersteuert wird.
;;;
;;; b) Bei kleinen Texten (Buffer<line-number-display-limit) sollen ruhig
;;;    Zeilennummern angezeigt werden:
(setq line-number-mode t)
;;;
;;; c) undo auf "C-c _" legen (von unix bin ich "C-_" gewohnt, aber das
;;;    so wohl nicht)
(global-set-key "\C-c_" 'undo)
(message "C-c _ gesetzt: undo")

;;;
;;; d) Abkuerzungen lesen:
(quietly-read-abbrev-file "~/.abbrev")
;;;
;;; d) unter diesem Namen werden ggf. neue/geaenderte Abkuerzungen
;;;    abgespeichert:
(setq abbrev-file-name "~/.abbrev")
;;;
;;; ich möchte neue Abkürzungen nicht automatisch speichern:
;;;
(setq save-abbrevs nil)
;;;
;;; e) fuer Latex-mode alles aehnlich und
;;;    fuer *.c2t den LaTeX-mode einschalten:
(defun kw-ergaenzungen-zu-latex-mode()
  "Ergaenzungen zu LaTeX-mode:
a) schaltet Unterscheidung Gross-/Klein ein
b) schaltet abbrev-mode ein
5.4.96 kw"
  ( setq case-fold-search nil )
  ( setq abbrev-mode t )
  ( reftex-mode t )
  ( local-set-key [f12] 'latex-region-to-index )
  ( local-set-key "\"" 'self-insert-command )
  (message "F12 gesetzt: '\\index{}' fuer markierten Block einfuegen (nur TeX)")
  )



(add-hook 'tex-mode-hook 'kw-ergaenzungen-zu-latex-mode)

(defun kw-ergaenzungen-zu-java-mode()
  "Ergaenzungen zu Java-mode:
a) schaltet Unterscheidung Gross-/Klein ein
b) schaltet abbrev-mode ein
 07.06.2000 kw"
  ( setq case-fold-search nil )
  ( setq abbrev-mode t )
  )

(defun kw-ergaenzungen-zu-perl-mode()
  "Ergaenzungen zu Perl-mode:
a) schaltet Unterscheidung Gross-/Klein ein
b) schaltet abbrev-mode ein
 07.06.2000 kw"
  ( setq case-fold-search nil )
  ( setq abbrev-mode t )
  ( font-lock-mode 1 )
  )

(add-hook 'perl-mode-hook 'kw-ergaenzungen-zu-perl-mode)

(defun kw-ergaenzungen-zu-makefile-mode()
  ( setq case-fold-search nil )
  ( setq abbrev-mode t )
  ( font-lock-mode 1 )
  )

(add-hook 'makefile-mode-hook 'kw-ergaenzungen-zu-makefile-mode )

(defun kw-ergaenzungen-zu-fortran-mode()
  ( setq case-fold-search nil )
  ( setq abbrev-mode t )
  ( setq fortran-check-all-num-for-matching-do )
  ( font-lock-mode 1 )
  )

(add-hook 'fortran-mode-hook 'kw-ergaenzungen-zu-fortran-mode )

(defun kw-ergaenzungen-zu-pascal-mode()
  ( setq case-fold-search nil )
  ( setq abbrev-mode t )
  ( font-lock-mode 1 )
  )

(add-hook 'pascal-mode-hook 'kw-ergaenzungen-zu-pascal-mode )

(defun kw-ergaenzungen-zu-sh-mode()
  ( setq case-fold-search nil )
  ( setq abbrev-mode t )
  ( font-lock-mode 1 )
  )

(add-hook 'sh-mode-hook 'kw-ergaenzungen-zu-sh-mode )

(setq auto-mode-alist (cons '("\\.c2t\\'" . latex-mode) auto-mode-alist))
;;;
;;; f) einige Funktionen, die einige Zeilen hoch gehen, mit Einruecken
;;;    wieder runter, und dann einige Zeichen nach rechts gehen.
;;;    Sinn der Uebung: Die Abkuerzungen lassen eine Funktion zu, die nach
;;;    dem Expandieren ausgefuehrt wird (leider ohne Argumente). Das kann
;;;    man dazu missbrauchen, nach dem Expandieren von "for" zu:
;;;      for(; ;  )
;;;      {
;;;
;;;      }
;;;    alles richtig einzuruecken und den Cursor/Point hinter "for(" zu
;;;    stellen.
;;;    Ohne weitere Massnahmen wuerden zwar die Zeichen der Abkuerzung eins
;;;    nach dem andern eingefuegt werden, aber a) findet kein automatisches
;;;    Einruecken statt, und b) steht der Einfuegepunkt danach immer hinter
;;;    den eingefuegten Zeichen. Fuer eine derartige Sonderbehandlung kann
;;;    man selber Funktionen wie die folgenden schreiben.
;;;    Leider muss man das fuer jede Abkurzung extra machen.
;;;    Wie? - In einem Text im richtigen major mode (z.B. C-mode) schreibt
;;;           man die volle Schreibweise der Abkuerzung, z.B.:
;;;             for(; ; )
;;;               {
;;;
;;;               }
;;;           und markiert den Bereich als Block.
;;;         - mit "M-0 C-x a l" definiert man den Block als abbreviation
;;;           des aktiven major modes
;;;         - und gibt dem Kind auf Nachfrage einen Namen (z.B. "for").
;;;         - beim Verlassen von EMACS wird man gefragt, ob man die neuen
;;;           Abkuerzungen speichern will, dabei "y" angeben.
;;;         - Die Datei mit den Abkuerzungen (hier .abbrev) mit
;;;           EMACS oeffnen und editieren. Alle neuen Abkuerzungen sind
;;;           in einer Tabelle der Form: ("Abkuerzung" "voller Text" nil 0)
;;;           wobei nil eine Funktion ist, die nach Einsetzen des vollen
;;;           Textes, aber vor Ausfuehren des Zeichens, das die Expansion
;;;           ausgeloest hat, aufgerufen wird. Standardmaessig ist das halt
;;;           nil, also nichts. Dieses nil ersetzt man durch einen eigenen
;;;           Funktionsnamen, z.B. abbrev-korrekt-for.
;;;           Abspeichern und Verlassen.
;;;         - Diese eigene Funktion muss man hier in _emacs dann noch
;;;           definieren: Mit EMACS die Datei _emacs oeffnen und
;;;           die Funktion eintragen: (defun abbrev-korrekt-for() ... )
(defun abbrev-korrekt-backzwei() "Korrektur fuer Abkuerzung (zwei char zurueck)"
  (backward-char 2)
  )
(defun abbrev-korrekt-backeins() "Korrektur fuer Abkuerzung (ein char zurueck)"
  (backward-char 1)
  )
(defun abbrev-pascal-begin() "Korrektur fuer begin-end-Abkuerzung"
  (previous-line 2)
  (beginning-of-line nil)
  (indent-according-to-mode)
  (next-line 2)
  (beginning-of-line nil)
  (indent-according-to-mode)
  (previous-line 1)
;  (indent-according-to-mode)
;  (backward-delete-char)
  )
(defun abbrev-korrekt-ifpp() "Korrektur fuer #if-Abkuerzung"
  (let ( bedingung
         )
    )
  (setq bedingung (read-from-minibuffer
                   "PP-Bedingung: " ""
                   nil
                   nil
                   'ppdef_history
           )
        )
  (insert " ")
  (insert bedingung)
  (insert "\n\n#endif /* if ")
  (insert bedingung)
  (insert " */\n")
  (previous-line 2)
  )
(defun abbrev-korrekt-ifepp() "Korrektur fuer #if-else-Abkuerzung"
  (let ( bedingung
         )
    )
  (setq bedingung (read-from-minibuffer
                   "PP-Bedingung: " ""
                   nil
                   nil
                   'ppdef_history
           )
        )
  (insert " ")
  (insert bedingung)
  (insert "\n\n#else /* if ")
  (insert bedingung)
  (insert " */\n")
  (insert "\n#endif /* if ")
  (insert bedingung)
  (insert " else ... */\n")
  (previous-line 4)
  )
(defun abbrev-korrekt-ifdef() "Korrektur fuer #ifdef-Abkuerzung"
  (let ( bedingung
         )
    )
  (setq bedingung (read-from-minibuffer
                   "PP-Bedingung: " ""
                   nil
                   nil
                   'ppdef_history
           )
        )
  (insert " ")
  (insert bedingung)
  (insert "\n\n#endif /* ifdef ")
  (insert bedingung)
  (insert " */\n")
  (previous-line 2)
  )
(defun abbrev-korrekt-ifdeb() "Korrektur fuer #ifndef-NDEBUG-Abkuerzung"
  (insert "\n\n#endif /* ifndef NDEBUG */")
  (previous-line 1)
  )
(defun abbrev-korrekt-ifndef() "Korrektur fuer #ifndef-Abkuerzung"
  (let ( bedingung
         )
    )
  (setq bedingung (read-from-minibuffer
                   "PP-Bedingung: " ""
                   nil
                   nil
                   'ppdef_history
           )
        )
  (insert " ")
  (insert bedingung)
  (insert "\n\n#endif /* ifndef ")
  (insert bedingung)
  (insert " */\n")
  (previous-line 2)
  )
(defun abbrev-korrekt-ifdefelse() "Korrektur fuer #ifdef/#ifndef-else-Abkuerzung"
  (let ( bedingung
         )
    )
  (setq bedingung (read-from-minibuffer
                   "PP-Bedingung: " ""
                   nil
                   nil
                   'ppdef_history
           )
        )
  (insert " ")
  (insert bedingung)
  (insert "\n\n#else /* #ifdef ")
  (insert bedingung)
  (insert " ... */\n")
  (insert "\n#endif /* #ifdef ")
  (insert bedingung)
  (insert " else ... */\n")
  (previous-line 4)
  )
(defun abbrev-korrekt-if() "Korrektur fuer if-Abkuerzung"
  (push-mark)
  (set-mark (point))
  (previous-line 3)
  (beginning-of-line nil)
  (indent-region (point) (mark) nil)
  (pop-mark)
  (end-of-line nil)
  (backward-char 2)
  )

(defun abbrev-java-korrekt-main() "Korrektur fuer main-Abkuerzung in Java"
  (push-mark)
  (set-mark (point)) ; alles richtig einrücken
  (previous-line 14)
  (beginning-of-line nil)
  (indent-region (point) (mark) nil)


  ;(set-mark (point)) ; alle "klassenname" durch den Dateinamen ersetzen
  ;(next-line 14)
  (replace-string "klassenname" (buffer-name) )
  (set-mark (point))
  (previous-line 13)
  (replace-regexp "[.]java" "" )
  (exchange-point-and-mark)
  (set-mark (point))
  ;(previous-line 13)
  (replace-string "Java" "java" )
  (replace-string "JAVA" "java" )
  (exchange-point-and-mark)
  (previous-line 3)
  (end-of-line nil)
  (backward-char 3)

  (pop-mark)
  ;(end-of-line nil)
  ;(backward-char 2)
  )


; nach dem Einfügen einer for-Schleife werden nacheinander Typ und Name des
; Schleifenzählers, die Endebedingung und die Reinitialisierung abgefragt.
; Jede dieser Eingaben bekommt einen eigenen History-Puffer:

(defvar
  ctype-history
  '("" "void *" "void" "bool" "char *" "const char*" "char" "signed char" "short" "int" "long int" "long long" "unsigned char" "unsigned short" "unsigned int" "unsigned long int" "unsigned long long" "size_t" "double" "string")
  "History für Datentypen (C/C++) in minibuffer"
  )
(defvar
  ppdef_history
  '("__linux__" "_WIN32" "__cplusplus" )
  "History für Präprozessor-Makros in minibuffer"
  )
(defvar
  cinit-history
  nil
  "History für Initialisierungen (C) in minibuffer"
  )
(defvar
  ccomp-history
  nil
  "History für Vergleiche (C) in minibuffer"
  )
(defvar
  ccond-history
  nil
  "History für Bedingungen (C) in minibuffer"
  )
(defvar
  creinit-history
  nil
  "History für Reinitialisierungen (C) in minibuffer"
  )

(defvar
  texbibitem-entry-history
  nil
  "History für bibitem-Entry (LaTeX) in minibuffer"
  )

(defvar
  texbibitem-cite-history
  nil
  "History für cite-Entry (LaTeX) in minibuffer"
  )

(defvar
  texbibitem-author-history
  nil
  "History für Verfasser-Entry (LaTeX) in minibuffer"
  )

(defvar
  texbibitem-title-history
  nil
  "History für Titel-Entry (LaTeX) in minibuffer"
  )

(defvar
  texbibitem-title-history
  nil
  "History für Titel-Entry (LaTeX) in minibuffer"
  )

(defvar
  texbibitem-verlag-history
  nil
  "History für Verlag-Entry (LaTeX) in minibuffer"
  )

; 12/2001 kw: erweitert auf Frage-Antwort
(defun abbrev-korrekt-forever() "Korrektur fuer for(;;)-Abkuerzung"
  (push-mark)
  (set-mark (point))
  (previous-line 3)
  (beginning-of-line nil)
  (indent-region (point) (mark) nil)
  (next-line 2)
  (indent-according-to-mode)
  )
(defun abbrev-korrekt-for() "Korrektur fuer for-Abkuerzung"
     (push-mark)
     (set-mark (point))
     (previous-line 3)
     (beginning-of-line nil)
     (indent-region (point) (mark) nil)
     (pop-mark)
     (forward-word 1)
     (forward-char 1)
     (insert " ")
     ( let( typ counter compare initialisierung reiinit )
       (setq typ (read-from-minibuffer "Typ: " "size_t" nil nil 'ctype-history))
       (if (not (equal typ "") ) (progn (insert typ) (insert " ") ) )
       (setq counter (read-from-minibuffer "Zaehler: " "i"))
       (setq initialisierung (read-from-minibuffer "Initialisierung: "
                                                   (concat counter "=0")
                                                   nil
                                                   nil
                                                   'cinit-history))
       (insert initialisierung)
       (forward-char 1)
       (forward-char 1)
       (setq compare(concat counter "<"))
       (setq compare (read-from-minibuffer "Bedingung: "
                                           compare
                                           nil
                                           nil
                                           'ccomp-history))
       (insert compare)
       (forward-char 1)
       (forward-char 1)
       (setq reiinit (read-from-minibuffer "Reinitialisierung: "
                                           (concat "++" counter)
                                           nil
                                           nil
                                           'creinit-history))
       (insert reiinit)
;       (delete-char 1)
       (next-line 3)
       (end-of-line)
       ;(insert " /* for( ")
       ;(insert typ)
       ;(insert " ")
       ;(insert initialisierung)
       ;(insert "; ")
       ;(insert compare)
       ;(insert "; ")
       ;(insert reiinit)
       ;(insert " ) */")
       (previous-line 1)
       (indent-according-to-mode)
       )
  )


; 04.04.2002 kw:
; ein bibitem in LaTeX einsetzen
; bibitem steht aus der abbreviation da, der Rest wird noch drangebastelt:
(defun abbrev-korrekt-latex-bibi() "Korrektur für bibitem"
  (backward-char 1)
  (let ( typ )
    (insert "[")
    (insert
     (read-from-minibuffer
      "Eintrag in []: " ""
      nil
      nil
      'texbibitem-entry-history
      )
     )
    (insert "]")
    (insert "{")
    (insert
     (read-from-minibuffer
      "Label fuer cite: " "bib:"
      nil
      nil
      'texbibitem-cite-history
      )
     )
    (insert "}\n")
    (insert "{")
    (insert
     (read-from-minibuffer
      "Verfasser: " ""
      nil
      nil
      'texbibitem-author-history
      )
     )
    (insert ":\\\\\n")
    (insert "{\\em ")
    (insert
     (read-from-minibuffer
      "Titel\\\\Untertitel: " ""
      nil
      nil
      'texbibitem-title-history
      )
     )
    (insert "}\\\\\n")
    (insert
     (read-from-minibuffer
      "ISBN-Nummer: " "ISBN "
      nil
      nil
      'texbibitem-cite-history
      )
     )
    (insert "}\n")
    )
)

; neu 10.12.2001 kw:
; Zum Einfügen einer neuen Klasse wird als abbreviation der Text
; "class\n{\n}; // " eingefügt (gemäß Datei .abbrev).
; Hier wird dann noch etwas ergänzt:
(defun abbrev-korrekt-class() "Korrektur fuer class-Abkuerzung"
  ; den eingefügten Teil markieren und richtig einrücken:
  (push-mark)
  (set-mark (point))
  (previous-line 2)
  (beginning-of-line nil)
  (indent-region (point) (mark) nil)
  (pop-mark)
  ; hinter "class" setzen:
  (forward-word 1)
  (insert " ")
  ; lokale Variablen:
  ( let( typ                            ; Name der neuen Klasse
         (ibase 0)                      ; Schleifenzähler Basisklassen
         deriv                          ; Art der Ableitung ("public" etc.)
         ( baseclass "?" )              ; Name einer Basisklasse
         ( baselist () )                ; Liste aller Basisklassen
         baselist-2                     ; Kopie der Liste aller Basiskl.
         (bashist '("private"           ; History für Ableitung
                    "protected"
                    "public"
                    )
                  )
         elem                           ; Name eines Elements
         type                           ; Typ eines Elements
         init                           ; Initialisierung eines Elements
         (ielem 0)                      ; Schleifenzähler Elemente
         ( private-name-list () )       ; Liste aller private-Elemente
         private-name-list-2            ; Kopie der Liste private-Elemente
         ( private-type-list () )       ; Typen aller private-Elemente
         private-type-list-2            ; Kopie der Typen private-Elemente
         ( private-init-list () )       ; Initialisierungen private-Elemente
         private-init-list-2            ; Kopie davon
         ( protected-name-list () )     ; Liste aller protected-Elemente
         protected-name-list-2          ; Kopie der Liste protected-Elemente
         ( protected-type-list () )     ; Typen aller protected-Elemente
         protected-type-list-2          ; Kopie der Typen protected-Elemente
         ( protected-init-list () )     ; Initialisierungen protected-Elemente
         protected-init-list-2          ; Kopie davon
         zeile                          ; temp. Speicher
         )
    ; Den Namen der neuen Klasse lesen:
    (setq typ
          (read-from-minibuffer
           "Klassenname: " "C"
           nil
           nil
           'ctype-history
           )
          )
    (insert typ)
    ;
    ; Liste der Basisklassen lesen:
    ;
    (setq baseclass "?")
    (setq ibase 0)
    (while (not (equal baseclass "") )
      (setq baseclass
            (read-from-minibuffer ( concat (int-to-string
                                            (+ ibase 1))
                                           ". Basisklasse (Ende mit Ret): ")
                                  ""
                                  nil
                                  nil
                                  'ctype-history))
      (unless (equal baseclass "")
        ; an Liste anhängen:
        (setq baselist (cons baseclass baselist))
        ;(setq baselist (append baseclass baselist))
        ; Art der Ableitung lesen:
        (setq deriv (read-from-minibuffer (concat "von "
                                                  baseclass
                                                  " ableiten: ")
                                          "public"
                                          nil
                                          nil
                                          'bashist))
        ; vor erste Basisklasse ":" setzen, sonst ","
        (if (equal ibase 0)
            (progn (insert "\n: ")
                   (indent-according-to-mode)
                   )
          (progn (insert ", ")
                 )
          )
        (insert deriv)
        (insert " ")
        (insert baseclass)
        ) ; (unless (equal baseclass "")...
      (setq ibase (+ ibase 1))
      ) ; Schleife über einzulesende Basisklassen
    ; Liste umdrehen:
    (setq baselist (nreverse baselist))
    ;
    ; Liste der private-Elemente, ihrer Typen und Initialisierungen lesen:
    ;
    (setq elem "?")
    (setq type "?")
    (setq init "?")
    (setq ielem 0)
    (while (not (equal elem "") )
      (setq elem
            (read-from-minibuffer
             ( concat (int-to-string
                       (+ ielem 1))
                      ". protected-Element (Ende mit Ret): ")
             ""
             nil
             nil
             nil
             )
            )
      (unless (equal elem "")
      ; an Liste anhängen:
      (setq protected-name-list (cons elem protected-name-list))
      ; Datentyp lesen:
      (setq type (read-from-minibuffer (concat "Datentyp von "
                                               elem
                                               ": ")
                                       ""
                                       nil
                                       nil
                                       'ctype-history
                                       )
            )
      ; an Liste anhängen:
      (setq protected-type-list (cons type protected-type-list))
      ; Initialisierung lesen:
      (setq init (read-from-minibuffer (concat "Initialisierung von "
                                               type
                                               " "
                                               elem
                                               " = ")
                                       (cond ((string-match ".*string" type)
                                              '( "\"\"" . 2 )
                                              )
                                             ((string-match ".*size_t" type)
                                              "0u"
                                              )
                                             ((string-match ".*unsigned.*" type)
                                              "0u"
                                              )
                                             ((string-match ".*int" type)
                                              "0"
                                              )
                                             ((string-match ".*double" type)
                                              "0.0"
                                              )
                                             ((string-match ".*float" type)
                                              "0.0"
                                              )
                                             ((string-match ".*bool" type)
                                              "false"
                                              )
                                             ((string-match ".*char" type)
                                              '("'?'" . 2)
                                              )
                                             ((string-match ".+\*" type)
                                              "NULL"
                                              )
                                             (t
                                              ""
                                              )
                                             )
                                       nil
                                       nil
                                       nil
                                       )
            )
      ; an Liste anhängen:
      (setq protected-init-list (cons init protected-init-list))
      ) ; (unless (equal elem "")...
      (setq ielem (+ ielem 1))
      ) ; Schleife über einzulesende protected-Elemente
    ; Listen umdrehen:
    (setq protected-name-list (nreverse protected-name-list))
    (setq protected-type-list (nreverse protected-type-list))
    (setq protected-init-list (nreverse protected-init-list))
    ;
    ; Liste der private-Elemente, ihrer Typen und Initialisierungen lesen:
    ;
    (setq elem "?")
    (setq type "?")
    (setq init "?")
    (setq ielem 0)
    (while (not (equal elem "") )
      (setq elem
            (read-from-minibuffer
             ( concat (int-to-string
                       (+ ielem 1))
                      ". private-Element (Ende mit Ret): ")
             ""
             nil
             nil
             nil
             )
            )
      (unless (equal elem "")
        ; an Liste anhängen:
        (setq private-name-list (cons elem private-name-list))
        ; Datentyp lesen:
        (setq type (read-from-minibuffer (concat "Datentyp von "
                                                 elem
                                                 ": ")
                                         ""
                                         nil
                                         nil
                                         'ctype-history
                                         )
              )
        ; an Liste anhängen:
        (setq private-type-list (cons type private-type-list))
        ; Initialisierung lesen:
        (setq init (read-from-minibuffer (concat "Initialisierung von "
                                                 type
                                                 " "
                                                 elem
                                                 " = ")
                                         (cond ((string-match ".*string" type)
                                                '( "\"\"" . 2 )
                                                )
                                               ((string-match ".*size_t" type)
                                                "0u"
                                                )
                                               ((string-match ".*unsigned.*" type)
                                                "0u"
                                                )
                                               ((string-match ".*int" type)
                                                "0"
                                                )
                                               ((string-match ".*double" type)
                                                "0.0"
                                                )
                                               ((string-match ".*float" type)
                                                "0.0"
                                                )
                                               ((string-match ".*bool" type)
                                                "false"
                                                )
                                               ((string-match ".*char" type)
                                                '("'?'" . 2)
                                                )
                                               ((string-match ".+\*" type)
                                                "NULL"
                                                )
                                               (t
                                                ""
                                                )
                                               )
                                         nil
                                         nil
                                         nil
                                         )
                  )
        ; an Liste anhängen:
        (setq private-init-list (cons init private-init-list))
        ) ; (unless (equal elem "")...
      (setq ielem (+ ielem 1))
      ) ; Schleife über einzulesende private-Elemente
    ; Listen umdrehen:
    (setq private-name-list (nreverse private-name-list))
    (setq private-type-list (nreverse private-type-list))
    (setq private-init-list (nreverse private-init-list))
    (next-line 1)
    ;
    ; protected-Teil:
    ;
    (insert "\npublic:")
    (indent-according-to-mode)
    (insert "\n\n")
    ;
    ; parameterloser Konstruktor
    ;
    (insert "// Konstruktor")
    (indent-according-to-mode)
    (insert "\n")
    (insert typ)
    (insert "()")
    (indent-according-to-mode)
    (setq ibase 0)
    (setq ielem 0)
    (when baselist
      ; Aufruf ctor der Basisklassen:
      (setq baselist-2 baselist)
      ( while baselist-2 ; Schleife über Basisklassen
        ; vor erste Klasse ":", sonst "," setzen:
        (if (equal (+ ibase ielem) 0)
            (progn (insert "\n: "))
          (progn (insert ",\n"))
          )
        (insert (car baselist-2))
        (insert "()" )
        (indent-according-to-mode)
        (setq baselist-2 (cdr baselist-2))
        (setq ibase (+ ibase 1))
        ) ; Schleife über Basisklassen
      ) ; (when baselist...
    (when protected-name-list
      (setq protected-name-list-2 protected-name-list )
      (setq protected-init-list-2 protected-init-list )
      (setq protected-type-list-2 protected-type-list )
      (while protected-name-list-2 ; Schleife über protected-Elemente
        (unless (string-match ".*static .+" (car protected-type-list-2))
          ; vor erste Initialisierung ":", sonst "," setzen:
          (if (equal (+ ibase ielem) 0)
              (progn (insert "\n: "))
            (progn (insert ",\n"))
            )
          (insert (car protected-name-list-2))
          (insert "( " )
          (insert (car protected-init-list-2) )
          (insert " )" )
          (indent-according-to-mode)
          (setq ielem (+ ielem 1))
          ) ; (unless (string-match ".*static .+" ...
        (setq protected-name-list-2 (cdr protected-name-list-2))
        (setq protected-init-list-2 (cdr protected-init-list-2))
        (setq protected-type-list-2 (cdr protected-type-list-2))
        ) ; Schleife über protected-Elemente
      ) ; (when protected-name-list
    (when private-name-list
      (setq private-name-list-2 private-name-list )
      (setq private-init-list-2 private-init-list )
      (setq private-type-list-2 private-type-list )
      (while private-name-list-2 ; Schleife über private-Elemente
        (unless (string-match ".*static .+" (car private-type-list-2))
          ; vor erste Initialisierung ":", sonst "," setzen:
          (if (equal (+ ibase ielem) 0)
              (progn (insert "\n: "))
            (progn (insert ",\n"))
            )
          (insert (car private-name-list-2))
          (insert "( " )
          (insert (car private-init-list-2) )
          (insert " )" )
          (indent-according-to-mode)
          (setq ielem (+ ielem 1))
          ); (unless (string-match ".*static .+" ...
        (setq private-name-list-2 (cdr private-name-list-2))
        (setq private-init-list-2 (cdr private-init-list-2))
        (setq private-type-list-2 (cdr private-type-list-2))
        ) ; Schleife über private-Elemente
      )
    (insert "\n{")
    (indent-according-to-mode)
    (insert "\n}")
    (indent-according-to-mode)
    (insert "\n\n")
    ;
    ; Copy-Konstruktor
    ;
    (insert "// copy-Konstruktor")
    (indent-according-to-mode)
    (insert "\n")
    (insert typ)
    (insert "( const ")
    (insert typ)
    (insert " &rechteSeite )")
    (indent-according-to-mode)
    (setq ibase 0)
    (setq ielem 0)
    (when baselist
      (setq baselist-2 baselist)
      (while baselist-2 ; Schleife über Basisklassen
        ; vor erste Klasse ":", sonst "," setzen:
        (if (equal (+ ibase ielem) 0)
            (progn (insert "\n: ")
                   (indent-according-to-mode)
                   )
          (progn (insert ",\n")
                 (indent-according-to-mode)
                 )
          )
        (insert (car baselist-2))
        (insert "( (")
        (insert (car baselist-2))
        (insert ")rechteSeite )")
        (indent-according-to-mode)
        (setq baselist-2 (cdr baselist-2))
        (setq ibase (+ ibase 1))
        ) ; Schleife über Basisklassen
      ) ; (when baselist...
    (when protected-name-list
      (setq protected-name-list-2 protected-name-list )
      (setq protected-type-list-2 protected-type-list )
      (while protected-name-list-2 ; Schleife über protected-Elemente
        (unless (string-match ".*static .+" (car protected-type-list-2))
          ; vor erste Initialisierung ":", sonst "," setzen:
          (if (equal (+ ibase ielem) 0)
              (progn (insert "\n: "))
            (progn (insert ",\n"))
            )
          (insert (car protected-name-list-2))
          (insert "( rechteSeite." )
          (insert (car protected-name-list-2) )
          (insert " )" )
          (indent-according-to-mode)
          (setq ielem (+ ielem 1))
          ) ; (unless (string-match ".*static .+"...
        (setq protected-name-list-2 (cdr protected-name-list-2))
        (setq protected-type-list-2 (cdr protected-type-list-2))
        ) ; Schleife über protected-Elemente
      ) ; (when protected-name-list...
    (when private-name-list
      (setq private-name-list-2 private-name-list )
      (setq private-type-list-2 private-type-list )
      (while private-name-list-2 ; Schleife über private-Elemente
        (unless (string-match ".*static .+" (car private-type-list-2))
          ; vor erste Initialisierung ":", sonst "," setzen:
          (if (equal (+ ibase ielem) 0)
              (progn (insert "\n: "))
            (progn (insert ",\n"))
            )
          (insert (car private-name-list-2))
          (insert "( rechteSeite." )
          (insert (car private-name-list-2) )
          (insert " )" )
          (indent-according-to-mode)
          (setq ielem (+ ielem 1))
          ) ; (unless (string-match ".*static .+"...
        (setq private-name-list-2 (cdr private-name-list-2))
        (setq private-type-list-2 (cdr private-type-list-2))
        ) ; Schleife über private-Elemente
      ) ; (when private-name-list...
    (insert "\n{")
    (indent-according-to-mode)
    (insert "\n}")
    (indent-according-to-mode)
    (insert "\n\n")
    ;
    ; Destruktor
    ;
    (insert "// Destruktor")
    (indent-according-to-mode)
    (insert "\nvirtual ~")
    (indent-according-to-mode)
    (insert typ)
    (insert "()")
    (insert "\n{")
    (indent-according-to-mode)
    (insert "\n}")
    (indent-according-to-mode)
    (insert "\n\n")
    ;
    ; operator=()
    ;
    (insert "// Zuweisung ")
    (insert typ)
    (insert " = ")
    (insert typ)
    (indent-according-to-mode)
    (insert "\n")
    (insert typ)
    (insert " & operator=( const ")
    (insert typ)
    (insert " &rechteSeite )")
    (indent-according-to-mode)
    (insert "\n{")
    (indent-according-to-mode)
    (setq ibase 0)
    (setq ielem 0)
    (when baselist
      (setq baselist-2 baselist)
      ( while baselist-2 ; Schleife über Basisklassen
        (insert "\n*(")
        (insert (car baselist-2))
        (insert "*)this = (")
        (insert (car baselist-2))
        (insert ")rechteSeite;")
        (indent-according-to-mode)
        (setq baselist-2 (cdr baselist-2))
        (setq ibase (+ ibase 1))
        ) ; Schleife über Basisklassen
      ) ; (when baselist...
    (when protected-name-list
      (setq protected-name-list-2 protected-name-list )
      (setq protected-type-list-2 protected-type-list )
      ( while protected-name-list-2 ; Schleife über protected-Elemente
        (unless (string-match ".*static .+" (car protected-type-list-2))
          (insert "\n")
          (insert (car protected-name-list-2))
          (insert " = rechteSeite." )
          (insert (car protected-name-list-2) )
          (insert ";" )
          (indent-according-to-mode)
          (setq ielem (+ ielem 1))
          ) ; (unless (string-match ".*static .+"...
        (setq protected-name-list-2 (cdr protected-name-list-2))
        (setq protected-type-list-2 (cdr protected-type-list-2))
        ) ; Schleife über protected-Elemente
      ) ; (when protected-name-list...
    (when private-name-list
      (setq private-name-list-2 private-name-list )
      (setq private-type-list-2 private-type-list )
      ( while private-name-list-2 ; Schleife über private-Elemente
        (unless (string-match ".*static .+" (car private-type-list-2))
          (insert "\n")
          (insert (car private-name-list-2))
          (insert " = rechteSeite." )
          (insert (car private-name-list-2) )
          (insert ";" )
          (indent-according-to-mode)
          (setq ielem (+ ielem 1))
          ) ; (unless (string-match ".*static .+"...
        (setq private-name-list-2 (cdr private-name-list-2))
        (setq private-type-list-2 (cdr private-type-list-2))
        )                               ; Schleife über private-Elemente
      ) ; (when private-name-list...
    (insert "\n\nreturn *this;")
    (indent-according-to-mode)
    (insert "\n}")
    (indent-according-to-mode)
    (insert "\n")
    (insert "\n")
    ;
    ; Ausgabe auf einen ostream:
    ;
    (insert "// Ausgabe auf einen ostream ")
    (indent-according-to-mode)
    (insert "\n")
    (insert "virtual void streamout( std::ostream & s ) const")
    (indent-according-to-mode)
    (insert "\n{")
    (indent-according-to-mode)
    (setq ibase 0)
    (setq ielem 0)
    ; Basisklassenelemente ausgeben:
    (when baselist
      (setq baselist-2 baselist)
      ( while baselist-2     ; Schleife über Basisklassen
        ; außer beim ersten Element ein Komma ausgeben:
        (if (not (equal (+ ibase ielem) 0))
            (progn
              (insert "\ns << \",\";" )
              (indent-according-to-mode)
              )
          )
        (insert "\n")
        (insert (car baselist-2))
        (insert "::streamout( s );")
        (indent-according-to-mode)
        (setq ibase (+ ibase 1))
        (setq baselist-2 (cdr baselist-2))
        (setq baselist-2 (cdr baselist-2))
        ) ; Schleife über Basisklassen
      ) ; (when baselist
    ; protected-Elemente ausgeben:
    (when protected-name-list
      (setq protected-name-list-2 protected-name-list )
      (setq protected-type-list-2 protected-type-list )
      ( while protected-name-list-2 ; Schleife über protected-Elemente
        (unless (string-match ".*static .+" (car protected-type-list-2))
          ; außer beim ersten Element ein Komma ausgeben:
          (unless (equal (+ ibase ielem) 0)
            (insert "\ns << \",\";" )
            (indent-according-to-mode)
            )
          (insert "\ns << " )
          (insert (car protected-name-list-2) )
          (insert ";" )
          (indent-according-to-mode)
          (setq ielem (+ ielem 1))
          ) ; (unless (string-match ".*static .+"...
        (setq protected-name-list-2 (cdr protected-name-list-2))
        (setq protected-type-list-2 (cdr protected-type-list-2))
        ) ; Schleife über protected-Elemente
      ) ; (when protected-name-list...
    ; protected-Elemente ausgeben:
    (when private-name-list
      (setq private-name-list-2 private-name-list )
      (setq private-type-list-2 private-type-list )
      ( while private-name-list-2 ; Schleife über private-Elemente
        (unless (string-match ".*static .+" (car private-type-list-2))
          ; außer beim ersten Element ein Komma ausgeben:
          (unless (equal (+ ibase ielem) 0)
            (insert "\ns << \",\";" )
            (indent-according-to-mode)
            )
          (insert "\ns << " )
          (insert (car private-name-list-2) )
          (insert ";" )
          (indent-according-to-mode)
          (setq ielem (+ ielem 1))
          ) ; (unless (string-match ".*static .+"...
        (setq private-name-list-2 (cdr private-name-list-2))
        (setq private-type-list-2 (cdr private-type-list-2))
        ) ; Schleife über private-Elemente
      ) ; (when private-name-list...
    (insert "\n}")
    (indent-according-to-mode)
    (insert "\n")
    (insert "\n")
    ;
    ; sich selbst klonen:
    ;
    (insert "// Kopie von sich selbst allokieren")
    (indent-according-to-mode)
    (insert "\n")
    (insert "virtual ")
    (insert typ)
    (insert " *clone() const")
    (indent-according-to-mode)
    (insert "\n{")
    (indent-according-to-mode)
    (insert "\nreturn new ")
    (insert typ)
    (insert "( *this; )")
    (indent-according-to-mode)
    (insert "\n}")
    (indent-according-to-mode)
    (insert "\n")
    (insert "\n")
    ;
    ;
    ; leeres Element vom eigenen Typ erzeugen:
    ;
    (insert "// leeres Element vom eigenen Typ erzeugen")
    (indent-according-to-mode)
    (insert "\n")
    (insert "static virtual ")
    (insert typ)
    (insert " *create()")
    (indent-according-to-mode)
    (insert "\n{")
    (indent-according-to-mode)
    (insert "\nreturn new ")
    (insert typ)
    (insert "();")
    (indent-according-to-mode)
    (insert "\n}")
    (indent-according-to-mode)
    (insert "\n")
    (insert "\n")
    ;
    ; protected-Teil:
    ;
    (insert "protected:")
    (indent-according-to-mode)
    (insert "\n")
    (when protected-name-list
      (setq protected-name-list-2 protected-name-list )
      (setq protected-type-list-2 protected-type-list )
      ( while protected-name-list-2 ; Schleife über protected-Elemente
        (insert "\n")
        (insert "// " )
        (indent-according-to-mode)
        (insert "\n" )
        (insert (car protected-type-list-2))
        (insert " " )
        (insert (car protected-name-list-2) )
        (insert ";" )
        (indent-according-to-mode)
        (insert "\n" )
        (setq ielem (+ ielem 1))
        (setq protected-name-list-2 (cdr protected-name-list-2))
        (setq protected-type-list-2 (cdr protected-type-list-2))
        ) ; Schleife über protected-Elemente
      ) ; (when protected-name-list
    ;
    ; private-Teil:
    ;
    (insert "\n\nprivate:")
    (indent-according-to-mode)
    (insert "\n")
    (when private-name-list
      (setq private-name-list-2 private-name-list )
      (setq private-type-list-2 private-type-list )
      ( while private-name-list-2 ; Schleife über private-Elemente
        (insert "\n")
        (insert "// " )
        (indent-according-to-mode)
        (insert "\n" )
        (insert (car private-type-list-2))
        (insert " " )
        (insert (car private-name-list-2) )
        (insert ";" )
        (indent-according-to-mode)
        (insert "\n" )
        (setq ielem (+ ielem 1))
        (setq private-name-list-2 (cdr private-name-list-2))
        (setq private-type-list-2 (cdr private-type-list-2))
        ) ; Schleife über private-Elemente
      ) ; (when private-name-list...
    (insert "\n")
    (next-line 1)
    (end-of-line)
    (insert typ)
    (insert "...")
    (end-of-line)
    (insert "\n\n// ggf. nach ")
    (insert typ)
    (insert ".cpp kopieren und inline entfernen, oder hier mit inline:")
    (indent-according-to-mode)
    (insert "\ninline std::ostream &operator<<( std::ostream &s, const ")
    (insert typ)
    (insert " &obj )")
    (indent-according-to-mode)
    (insert "\n{")
    (indent-according-to-mode)
    (insert "\n")
    (insert "obj.streamout( s );")
    (indent-according-to-mode)
    (insert "\nreturn s;")
    (indent-according-to-mode)
    (insert "\n}")
    (indent-according-to-mode)
    (insert "\n\n")
    ;
    ; Falls static-Elemente enthalten sind, dann werden diese
    ; getrennt initialisiert (außerhalb der Klasse):
    ;
    (when protected-name-list
      (setq protected-name-list-2 protected-name-list )
      (setq protected-init-list-2 protected-init-list )
      (setq protected-type-list-2 protected-type-list )
      (while protected-name-list-2 ; Schleife über protected-Elemente
        (when (string-match ".*static .+" (car protected-type-list-2))
          ; Für die globale Definition mit Initialisierung eines
          ; static-Klassenelements darf in der Definition außerhalb
          ; der Klasse das Schlüsselwort "static" nicht mehr wiederholt
          ; werden.
          ; Um das "static " zu entfernen, fällt mir nichts besseres ein,
          ; als den Typ (mit "static ") an dem `Trennzeichen' "static "
          ; aufzuteilen, und danach die eine oder zwei Teile in einer
          ; Schleife wieder zusammenzusetzen:
          (insert (progn (setq liste
                               (split-string
                                (car protected-type-list-2)
                                "static ") )
                         (setq zeile "")
                         (while (car liste)
                           (setq zeile (concat zeile (car liste)))
                           (setq liste (cdr liste))
                           )
                         zeile
                         ) ; (progn...
                  )
          (insert " " )
          (insert typ )
          (insert "::" )
          (insert (car protected-name-list-2))
          (insert " = " )
          (insert (car protected-init-list-2))
          (insert ";" )
          (indent-according-to-mode)
          ) ; (when (string-match ".*static .+" ...
        (setq protected-name-list-2 (cdr protected-name-list-2))
        (setq protected-init-list-2 (cdr protected-init-list-2))
        (setq protected-type-list-2 (cdr protected-type-list-2))
        ) ; Schleife über protected-Elemente
      ) ; (when protected-name-list
    (when private-name-list
      (setq private-name-list-2 private-name-list )
      (setq private-init-list-2 private-init-list )
      (setq private-type-list-2 private-type-list )
      (while private-name-list-2 ; Schleife über private-Elemente
        (when (string-match ".*static .+" (car private-type-list-2))
          (insert (progn (setq liste
                               (split-string
                                (car private-type-list-2)
                                "static ") )
                         (setq zeile "")
                         (while (car liste)
                           (setq zeile (concat zeile (car liste)))
                           (setq liste (cdr liste))
                           )
                         zeile
                         ) ; (progn...
                  )
          (insert " " )
          (insert typ )
          (insert "::" )
          (insert (car private-name-list-2))
          (insert " = " )
          (insert (car private-init-list-2))
          (insert ";" )
          (indent-according-to-mode)
          ) ; (when (string-match ".*static .+" ...
        (setq private-name-list-2 (cdr private-name-list-2))
        (setq private-init-list-2 (cdr private-init-list-2))
        (setq private-type-list-2 (cdr private-type-list-2))
        ) ; Schleife über private-Elemente
      ) ; (when private-name-list
    ) ; let...
  ) ; defun abbrev-korrekt-class()...


(defun abbrev-korrekt-while() "Korrektur fuer while-Abkuerzung"
  (push-mark)
  (set-mark (point))
  (previous-line 3)
  (beginning-of-line nil)
  (indent-region (point) (mark) nil)
  (pop-mark)
  (forward-word 1)
  (forward-char 1)
  )
(defun abbrev-korrekt-do() "Korrektur fuer do-Abkuerzung"
  (push-mark)
  (set-mark (point))
  (previous-line 4)
  (beginning-of-line nil)
  (indent-region (point) (mark) nil)
  (pop-mark)
  (next-line 4)
  (forward-word 1)
  (forward-char 1)
  )
(defun abbrev-korrekt-try() "Korrektur fuer try-Abkuerzung"
  (push-mark)
  (set-mark (point))
  (previous-line 20)
  (beginning-of-line nil)
  (indent-region (point) (mark) nil)
  (pop-mark)
  (next-line 3)
  (end-of-line nil)
  ;(backward-char 8)
  )
(defun abbrev-korrekt-switch() "Korrektur fuer switch-Abkuerzung"
  (push-mark)
  (set-mark (point))
  (previous-line 17)
  (beginning-of-line nil)
  (indent-region (point) (mark) nil)
  (pop-mark)
  (forward-word 1)
  (forward-char 1)
  )
(defun abbrev-korrekt-switch-n(n) "Korrektur fuer switch(n)-Abkuerzung"
  (push-mark)
  (set-mark (point))
  (previous-line (+ 5 (* 4 n)))
  (beginning-of-line nil)
  (indent-region (point) (mark) nil)
  (pop-mark)
  (forward-word 1)
  (forward-char 1)
  )
(defun abbrev-korrekt-switch1() "Korrektur fuer switch(1)-Abkuerzung"
  (abbrev-korrekt-switch-n 1)
  )
(defun abbrev-korrekt-switch2() "Korrektur fuer switch(2)-Abkuerzung"
  (abbrev-korrekt-switch-n 2)
  )
(defun abbrev-korrekt-switch3() "Korrektur fuer switch(3)-Abkuerzung"
  (abbrev-korrekt-switch-n 3)
  )
(defun abbrev-korrekt-switch4() "Korrektur fuer switch(4)-Abkuerzung"
  (abbrev-korrekt-switch-n 4)
  )
(defun abbrev-korrekt-switch5() "Korrektur fuer switch(5)-Abkuerzung"
  (abbrev-korrekt-switch-n 5)
  )
(defun abbrev-korrekt-switch6() "Korrektur fuer switch(6)-Abkuerzung"
  (abbrev-korrekt-switch-n 6)
  )
(defun abbrev-korrekt-switch7() "Korrektur fuer switch(7)-Abkuerzung"
  (abbrev-korrekt-switch-n 7)
  )
(defun abbrev-korrekt-switch8() "Korrektur fuer switch(8)-Abkuerzung"
  (abbrev-korrekt-switch-n 8)
  )
(defun abbrev-korrekt-switch9() "Korrektur fuer switch(9)-Abkuerzung"
  (abbrev-korrekt-switch-n 9)
  )
(defun abbrev-korrekt-switch10() "Korrektur fuer switch(10)-Abkuerzung"
  (abbrev-korrekt-switch-n 10)
  )
(defun abbrev-korrekt-cin() "Korrektur fuer cin-Abkuerzung"
  (indent-according-to-mode)
  (backward-char 1)
  )
(defun abbrev-korrekt-cout() "Korrektur fuer cout-Abkuerzung"
  (indent-according-to-mode)
  (backward-char 14)
  )
(defun abbrev-korrekt-dlog() "Korrektur fuer dlog-Abkuerzung"
  (indent-according-to-mode)
  (previous-line 1)
  (indent-according-to-mode)
  (previous-line 1)
  (indent-according-to-mode)
  (next-line 1)
  (end-of-line)
  (backward-char 14)
  )
(defun abbrev-korrekt-dprint() "Korrektur fuer dlog-Abkuerzung (C-Version)"
  (indent-according-to-mode)
  (previous-line 1)
  (indent-according-to-mode)
  (previous-line 1)
  (indent-according-to-mode)
  (next-line 1)
  (end-of-line)
  (backward-char 6)
  )
(defun abbrev-korrekt-latex-doc() "Korrektur fuer LaTeX-doc-Abkuerzung"
  (goto-char (point-min))
  (next-line 80)
  (forward-char 1)
  )
(defun abbrev-korrekt-latex-sec() "Korrektur fuer LaTeX-sec-Abkuerzung"
  (backward-char 1)
  )
(defun abbrev-korrekt-latex-em() "Korrektur fuer LaTeX-em-Abkuerzung"
  (backward-word 1)
  (forward-char 2)
  )
(defun abbrev-korrekt-latex-large() "Korrektur fuer LaTeX-large-Abkuerzung"
  (backward-word 1)
  (forward-char 5)
  )
(defun abbrev-korrekt-latex-huge() "Korrektur fuer LaTeX-huge-Abkuerzung"
  (backward-word 1)
  (forward-char 4)
  )
(defun abbrev-korrekt-latex-foot() "Korrektur fuer LaTeX-foot-Abkuerzung"
  (backward-word 1)
  (forward-char 12)
  )
(defun abbrev-korrekt-latex-script()
  "Korrektur fuer LaTeX-script-Abkuerzung"
  (backward-word 1)
  (forward-char 10)
  )
(defun abbrev-korrekt-latex-gfuss() "Korrektur fuer LaTeX-gfuss-Abkuerzung"
  (backward-char 2)
  )
(defun abbrev-korrekt-printf() "Korrektur fuer printf-Abkuerzung"
  (backward-char 5)
  )
(defun abbrev-korrekt-scanf() "Korrektur fuer scanf-Abkuerzung"
  (backward-char 7)
  )
(defun abbrev-korrekt-include() "Korrektur fuer include-Abkuerzung"
  (backward-char 4)
  )
                                                                            ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; First, lets pretend we want to edit text as a default
(setq default-major-mode 'text-mode)
(add-hook 'text-mode-hook 'turn-on-auto-fill)
(setq next-line-add-newlines nil)
(setq require-final-newline t)

;;; highlight matching parens. Never leave home without it.
(require 'paren)

;;; have a colorful day
;;; so wars bisher:
;(add-hook 'c-mode-hook 'turn-on-font-lock)
;;; aber unter C++ solls ja auch bunt sein (11.4.96 kw):
(add-hook 'c-mode-common-hook 'turn-on-font-lock)
;
(add-hook 'emacs-lisp-mode-hook 'turn-on-font-lock)
(add-hook 'tex-mode-hook 'turn-on-font-lock)

(transient-mark-mode t)
(setq visible-bell t)
(setq search-highlight t)
(setq query-replace-highlight t)

;;; useful info in the mode line
(display-time)
(setq display-time-24hr-format t)
(column-number-mode t)

;;; pc look-and-feel, either the first two
; (require 'pc-select)
; (pc-selection-mode)
;;; or this one
;(require 's-region)

(setq scroll-step 1)

;;; Set to `'tilde' or `'bak'.
;;; dired does not recognize .bak extensions!
(setq dos-backup-name-method 'tilde
)
;;; Work in 80x50 screen size, but switch back to 80x25
;;; before exiting and when suspending Emacs.
;(mode4350)
;
;(defun my-exit-stuff ()
;  "My own exit routine.  Currently just switches to the 25x80 mode."
;  (mode25))
;(add-hook 'kill-emacs-hook 'my-exit-stuff)
;
;(add-hook 'suspend-hook 'mode25)
;(add-hook 'suspend-resume-hook 'mode4350)

;;; enable this to to default to unix-type LF files
;;; instead of dos-style CR/LF
;(setq default-buffer-file-type t)

;;; alternatively, specify it for several file extensions
;(setq file-name-buffer-file-type-alist
;      (append '(
;               ("\\.el$" . t)
;               ("\\.\\(\\|c\\|cc\\|h\\)$" . t)
;               ("\\.\\(tex\\|sty\\)$" . t))
;              file-name-buffer-file-type-alist))


(setq user-full-name    "Klaus Wachtler")
; (setq user-login-name   "anyware")
; (setq system-name       "peecee")
(setq mail-host-address "wachtler.de")

;;; (overwrite-mode)



;(setq ps-top-margin 30)                ; 1 inch
(custom-set-variables
  ;; custom-set-variables was added by Custom.
  ;; If you edit it by hand, you could mess it up, so be careful.
  ;; Your init file should contain only one such instance.
  ;; If there is more than one, they won't work right.
 '(delete-selection-mode nil nil (delsel))
 '(file-coding-system-alist (quote (("\\.txt\\'" . utf-8) ("\\.tmp\\'" . utf-8) ("mutt.*" . utf-8) ("\\.dz\\'" no-conversion . no-conversion) ("\\.g?z\\(~\\|\\.~[0-9]+~\\)?\\'" no-conversion . no-conversion) ("\\.tgz\\'" no-conversion . no-conversion) ("\\.tbz\\'" no-conversion . no-conversion) ("\\.bz2\\(~\\|\\.~[0-9]+~\\)?\\'" no-conversion . no-conversion) ("\\.Z\\(~\\|\\.~[0-9]+~\\)?\\'" no-conversion . no-conversion) ("\\.elc\\'" emacs-mule . emacs-mule) ("\\.utf\\(-8\\)?\\'" . utf-8) ("\\(\\`\\|/\\)loaddefs.el\\'" raw-text . raw-text-unix) ("\\.tar\\'" no-conversion . no-conversion) ("\\.po[tx]?\\'\\|\\.po\\." . po-find-file-coding-system) ("\\.\\(tex\\|ltx\\|dtx\\|drv\\)\\'" . latexenc-find-file-coding-system) ("" undecided))))
 '(inhibit-startup-screen t)
 '(ispell-dictionary-alist (append ispell-dictionary-alist-1 ispell-dictionary-alist-2) t)
 '(printer-name (quote qms))
 '(ps-bottom-margin 52)
 '(ps-font-size (quote 10))
 '(ps-line-number t)
 '(ps-paper-type (quote a4))
 '(ps-printer-name (quote lpaw33))
 '(ps-top-margin 20)
 '(safe-local-variable-values (quote ((auto-fill-mode) (buffer-file-coding-system . mule-utf-8-unix))))
 '(scroll-bar-mode (quote right)))
(custom-set-faces
  ;; custom-set-faces was added by Custom.
  ;; If you edit it by hand, you could mess it up, so be careful.
  ;; Your init file should contain only one such instance.
  ;; If there is more than one, they won't work right.
 '(my-tab-face ((((class color)) (:background "Khaki"))) t)
 '(my-trailing-space-face ((((class color)) (:background "Gold"))) t))

;;; Editor behavior: color tabs

(add-hook 'font-lock-mode-hook
          (function
           (lambda ()
             (setq font-lock-keywords
                   (append font-lock-keywords
                           '(("\t+" (0 'my-tab-face t))
                             ("[ \t]+$" (0 'my-trailing-space-face t))))))))



;;; From: Tom Schutter <t.schutter@att.net>
;;; To: Jason Diamond <jason@injektilo.org>
;;; Cc: help-emacs-windows@gnu.org
;;; Subject: Re: [h-e-w] View Whitespace
;;;
;;; Jason Diamond wrote:
;;; >
;;; > Hi.
;;; >
;;; > Is there a Lisp function that toggles whether or not whitespace (horizontal
;;; > tabs, line feeds, carriage returns, and spaces) are "visible"?
;;; >
;;; > Thanks,
;;; > Jason.
;;;
;;; I don't know where I got this from, but it does tabs and trailing
;;; spaces.
;;;
;;; ;;; Editor behavior: color tabs
;;; (custom-set-faces
;;;  '(my-tab-face            ((((class color)) (:background "Khaki"))) t)
;;;  '(my-trailing-space-face ((((class color)) (:background "Gold"))) t))
;;; (add-hook 'font-lock-mode-hook
;;;           (function
;;;            (lambda ()
;;;              (setq font-lock-keywords
;;;                    (append font-lock-keywords
;;;                            '(("\t+" (0 'my-tab-face t))
;;;                              ("[ \t]+$" (0 'my-trailing-space-face
;;; t))))))))
;;;
;;; --
;;; Tom Schutter
;;; t.schutter@att.net
;;;



;;; From: Christian Mallwitz <c.mallwitz@intershop.de>
;;; To: "'ntemacs-users@cs.washington.edu'" <ntemacs-users@cs.washington.edu>
;;; Subject: RE: Trailing spaces
;;; Date: Wed, 20 Jun 2001 09:52:58 +0200
;;; X-Mailer: Internet Mail Service (5.5.2650.21)
;;; Precedence: bulk
;;; X-FAQ: http://www.gnu.org/software/emacs/windows/ntemacs.html
;;;
;;; Mike,
;;;
;;; I use this in my .emacs
;;;
;;; ;; special customization for coloring leading and trailing spaces
;;;
;;; (custom-set-faces
;;;  '(my-tab-face            ((((class color)) (:background "lavender blush")))
;;; t)
;;;  '(my-trailing-space-face ((((class color)) (:background "cornsilk"))) t))
;;;
;;; (add-hook 'font-lock-mode-hook
;;;   (function
;;;     (lambda ()
;;;       (setq font-lock-keywords
;;;             (append font-lock-keywords
;;;                     '(("\t+"     (0 'my-tab-face t))
;;;                       ("[ \t]+$" (0 'my-trailing-space-face t))))))))
;;;
;;; which you may treak for your purposes ...
;;; Bye
;;; Christian

;show ascii table
(defun ascii-table ()
  "Print the ascii table. Based on a defun by Alex Schroeder <asc@bsiag.com>"
  (interactive)
  (switch-to-buffer "*ASCII*")
  (erase-buffer)
  (insert (format "ASCII characters up to number %d.\n" 254))
  (let ((i 0))
    (while (< i 254)
      (setq i (+ i 1))
      (insert (format "%3d   0x%3x  %c\n" i i i))))
  (beginning-of-buffer))


; Mouse avoidance mode.
; Dadurch wird der Mauszeiger irgendwohin verschoben, wenn er dem
; Textcursor im Weg ist.
; So sieht man immer, was man schreibt.
; Und es sieht einfach cool aus.
(if window-system (mouse-avoidance-mode 'animate))


; So muß man nicht immer "yes" und "no" eingeben, ein einfaches
; "y" oder "n" genügt:
(fset 'yes-or-no-p 'y-or-n-p)


;; ; Mailcrypt
;; (load-library "mailcrypt")
;; (mc-setversion "gpg")                   ; use GPG as default
;; (autoload 'mc-install-write-mode "mailcrypt" nil t)
;; (autoload 'mc-install-read-mode "mailcrypt" nil t)
;; (add-hook 'mail-mode-hook 'mc-install-write-mode)
;;


;; The first time you save the state of the Emacs session, you must
;; do it manually, with the command M-x desktop-save. Once you have
;; done that, exiting Emacs will save the state again -- not only
;; the present Emacs session, but also subsequent sessions. You can
;; also save the state at any time, without exiting Emacs, by typing
;; M-x desktop-save again.
(load "desktop")
(desktop-load-default)
(desktop-read)


(setq ange-ftp-ftp-program-args '("-i" "-n" "-g" "-v" "-p"))

; Normalerweise wird ein buffer den selben Namen haben, wie die zugehörige
; Datei (aber ohne Pfadangabe).
; Lädt man eine zweite (dritte...) Datei mit demselben Namen aus einem
; anderen Verzeichnis, dann wird deren buffer zur Unterscheidung eine
; Zahl angehängt bekommen ("<2>", "<3>" etc.).
; Das kann man ändern; dann wird der Pfadname in den buffer-Namen
; mit aufgenommen anstatt einer Zahl.
;
; Mögliche Werte für uniquify-buffer-name-style:
;  forward        bar/mumble/name  quux/mumble/name
;  reverse        name\mumble\bar  name\mumble\quux
;  post-forward   name|bar/mumble  name|quux/mumble
;  post-forward-angle-brackets   name<bar/mumble>  name<quux/mumble>
;  nil            name  name<2>

(require 'uniquify)
(setq uniquify-buffer-name-style 'post-forward-angle-brackets)

; Anm.: In jedem Fall kann man mit C-x C-b eine Liste aller buffer
; zusammen mit den zugehörigen vollen Pfadnamen anzeigen lassen
; (und ggf. durch Anklicken mit der mittleren Maustaste dorthin
; springen).


; tool bars brauchen viel Platz, und machen mich auch nicht glücklicher.
; also weg damit:
(tool-bar-mode nil)

; Für ftp-Zugriff PASV verwenden

;  ; Tweaked by eraatikidotfi based on code from
;  ; http://mail.gnu.org/pipermail/help-gnu-emacs/2001-April/006468.html:
;  ;; From: Ehud Karni  ehudatunixdotsimonwieseldotcodotil
;  ;; Date: Wed, 18 Apr 2001 19:45:08 +0300
;  ;; Subject: Ange-ftp: passive mode transfers?
;
;  (defvar ange-ftp-hosts-no-pasv '("localhost")
;    "*List of hosts that do not need PASV (e.g. hosts within your firewall).
;  Used by `ange-ftp-set-passive'.")	; rephrased, added "*" // era
;
;  (defun ange-ftp-set-passive ()
;      "Function to send a PASV command to hosts not named in the variable
;  `ange-ft-hosts-no-pasv'. Intended to be called from the hook variable
;  `ange-ftp-process-startup-hook'."	; rephrased significantly // era
;    (if (not (member host ange-ftp-hosts-no-pasv))
;        (ange-ftp-raw-send-cmd proc "passive")))
;
;  (add-hook 'ange-ftp-process-startup-hook 'ange-ftp-set-passive)
;
; ---- language-env DON'T MODIFY THIS LINE!
; $Id: emacs,v 1.4 1998/02/20 18:35:26 leutloff Exp leutloff $

;;--- support european keys ------------------------------- 
(set-input-mode  (car (current-input-mode))
		 (nth 1 (current-input-mode))
		 0)
; `standard-display-european' is semi-obsolete and conflicts
; with multibyte characters. `set-language-environment' is
; a substitute.
; (standard-display-european t)

; don't use non-ascii (i.e. german umlauts) as word delimiter
(if (>= emacs-major-version 21)
    (progn
      (set-language-environment "Latin-9")
      (setq selection-coding-system 'compound-text-with-extensions)
    )
    (if (>= emacs-major-version 20)
        (set-language-environment "Latin-1")
        (require 'iso-syntax)))
(require 'disp-table)

;;--- redefine some keys ----------------------------------
;(global-set-key [backspace] 'backward-delete-char-untabify)
; the following line should not break delete char during incremental
; search - has this other disadvantages?
(global-set-key "\177" 'backward-delete-char-untabify)
(global-set-key [delete] 'delete-char)
(global-set-key [home] 'beginning-of-line)
(global-set-key [end] 'end-of-line)
;(global-set-key [C-home] 'beginning-of-buffer)
;(global-set-key [C-end] 'end-of-buffer)
; entries needed by XEmacs:
(global-set-key [(control home)] 'beginning-of-buffer)
(global-set-key [(control end)] 'end-of-buffer)
;;--- Names for calendar command -------------------------
(defvar calendar-day-name-array
  ["Son" "Mon" "Die" "Mit" "Don" "Fre" "Sam"])
(defvar calendar-month-name-array
  ["Januar" "Februar" "März" "April" "Mai" "Juni" 
   "Juli" "August" "September" "Oktober" "November" "Dezember"])
; ---- language-env end DON'T MODIFY THIS LINE!