Emacs
Notizen erstellt mit Org-Mode

In der Liste kann mit S-links/rechts das Listensymbol geändert werden.

- Bindestrich
- weiteres

• Bindestrich
• weiteres

Zwischen zwei Listen muss ein Nicht-Listen-Text stehen, damit die Listensymboländerung funktioniert. Ansonsten nimmt org-mode an, dass die Listen zusammen gehören.

+ Pluszeichen
+ weiteres

• Pluszeichen
• weiteres

Einträge innerhalb einer Liste können mit M-hoch/runter versetzt werden.

1) Nummerierung Klammer
2) weiteres

1. Nummerierung Klammer
2. weiteres

Die Einrücktiefe kann mit M-links/rechts verändert werden.

1. Nummerierung Punkt
2. weiteres

1. Nummerierung Punkt
2. weiteres

Für einen neuen Eintrag, wie gehabt, ist M-RET zuständig.

Bei nummerierten Listen wird mit den oben genannten Listenkommandos die Nummerierung richtig gesetzt. Eine Alphabetische Liste wird leider nicht unterstützt. Beim Exportieren werden Bindestriche und Pluszeichen sowie die beiden Arten der Nummerierung jeweils identisch umgewandelt.

- Namensliste :: Vor den Namen ist ein Listenzeichen zu setzen.
- Noch :: Ein Eintrag, diesmal etwas länger, um den Zeilenumbruch zu
          zeigen, der bei dieser Listenart eine Einrückung vornimmt.

Namensliste

Vor den Namen ist ein Listenzeichen zu setzen.

Noch

Ein Eintrag, diesmal etwas länger, um den Zeilenumbruch zu zeigen, der bei dieser Listenart eine Einrückung vornimmt.

Auch Listen, in denen der Anfang hervorgehoben ist, sind möglich. Dafür ist zwischen den Listenzeichen und dem Ende der Hervorhebung ein doppelter Doppelpunkt zu setzen (::). Es sind aber nur die einfachen Listenzeichen möglich, mit Nummerierung funktioniert das nicht.

Ein markierten Bereich kann mit C-c | in eine Tabelle umgewandelt werden. Dabei werden Kommas als Trenner genommen. Falls keine Kommas vorhanden sind, werden Leerzeichen oder Tabs als Trenner erkannt. Es ist immer nur ein Trennzeichen gültig, dabei gilt die Reihenfolge der Gültigkeit: Komma, Leerzeichen, Tabulator.

Eine neue Linie kann mit C-c - unter der aktuellen eingefügt werden.

Auf Tupel wird referenziert mit $Zeile$Spalte. Relativ referenzieren zur Spalte in der aktuellen Zeile geht mit $n, wobei n auch negativ sein kann. Wenn n gleich 0 ist, ist die momentane Spalte gemeint. $< zeigt auf die erste Spalte, und $> auf die letzte. $>>> zeigt dabei auf die drittletzte Spalte. Bei den relativen Referenzen auf Zeilen wird ein @ statt eines $ benutzt, ansonsten ist das Verhalten gleich dem bei den Spalten. Einen Bereich gibt man mit .. an, bsw. Spalte 2 bis 5 mit $2..$5. Konstanten können mit

#+CONSTANTS: irgendeinWert=12

definiert werden. Dabei ist die Konstante nur für die aktuelle Datei gültig. Um sie sofort zu aktivieren, muss auf ihr ein C-c C-c ausgeführt werden.

Sobald in einem Tupel mit = begonnen wird, folgt darauf eine Formel. Wenn der Tupel verlassen wird, wird die Formel ausgewertet, und durch das Ergebnis ersetzt. Unter der Tabelle wird die zuletzt genutzte Formel gesetzt. Ansehen und anpassen der genutzten Formel ist dann über C-c = möglich.

Um verschiedene Formeln zu nutzen, können diese unter die Tabelle geschrieben werden. Mit einem C-c C-c auf der Formel wird diese dann ausgeführt.

Die Summe einer Spalte kann schnell mit C-c + errechnet werden, wobei der Cursor in der letzten (leeren) Zeile in der entsprechenden Spalte stehen muss.

Hinter einer Formel kann mit Hilfe eines printf ähnlichen Kommandos die Ausgabe gesteuert werden. Um die Nachkommastellen auf zwei zu begrenzen bsw. mit ;%.2f.

#+TBLFM: $4=$2+$3::@5$3=vsum(@2..@4)
#+TBLFM: @>$2=vsum(@2..@4)
#+TBLFM: @>$4=@2*@3*@4/$irgendeinWert;%.2f

Hier mal der Versuch, im org-mode auf andere Dateien zu verweisen.

Eine andere org-mode Datei: sub main org. Mit RET oder C-c C-o, während der Cursor auf dem Link liegt, wird ein weiteres Fenster mit der Datei geöffnet. Der Fokus liegt dann in jener Datei. Falls die Zieldatei noch nicht existiert wird sie angelegt. Der Pfad muss immer mit angegeben werden, für den momentanen Pfad mit „./“.

Für den Export in ein anderes Dateiformat (html, LaTeX, etc.) gilt zu beachten, dass nur der aktuelle Puffer exportiert wird, nicht aber die verlinkten Dateien.

Einzelne Überschriften, inklusive ihres Inhalts, können in die Archivdatei verschoben werden. Die Archivdatei ist i.d.R. ./<dateiname>_archive. In diesem Fall also ./main.org_archive.

Code Blöcke im org-mode können (für mich) zwei Dinge, die das Leben stark vereinfachen. Zum Einen sorgen sie für eine bestimmte Formatierung beim Exportieren, und zum Anderen kann in ihnen Code ausgeführt werden.

Org-mode kennt verschiedene Code Blöcke, die einfach mit einem <, gefolgt von einem Code Block Identifier und TAB erzeugt werden können.

Damit der Block #+BEGIN_SRC nicht ausgeführt wird, wird hinter dem Eintrag :eval no eingetragen.

Das sind Pakete, die mit org-mode schon mit geliefert werden. Sie sind gegebenenfalls noch zu aktivieren. Der Code der entsprechenden Pakete muss in Code-Blöcke eingebettet sein. Dieser Block wird dann mit C-c C-c, oder aber evtl. durch exportieren, ausgeführt. Damit die Code Abschnitte beim Exportieren nicht einfach so ausgeführt werden, trägt man am Anfang der Datei

# -*- org-confirm-babel-evaluate: t -*-

ein, oder stellt das via Customize ein. Dies sollte zwar der default Wert sein - aber sicher ist sicher.

Das org Paket bietet unter anderem auch die Möglichkeit die Datei nach html zu exportieren. Die Steuerung des Aussehens wird dabei im Kopf mit verschiedenen Optionen gesetzt. Dabei kann das Einstellen des Aussehens über eine CSS Datei geschehen. Das Einbinden dieser CSS Datei (bei mir stylesheet.css) erfolgt dann wie folgt.

#+HTML_HEAD: <link rel="stylesheet" type="text/css" href="stylesheet.css" />

Beispiel einer stylesheet Datei.

Um die org-mode Datei nach PDF zu exportieren reicht ein C-c C-e l p. Das funktioniert auch soweit hervorragend. Hier notiere ich meine Einstellungen, damit das Gute noch ein bisschen besser wird. ;-)

Dieses Dokument soll als Report von einer von mir erstellen LaTeX Header Datei erstellt werden, daher kommt in den Header der Datei folgende Einstellung.

• #+LATEX_CLASS: akreport

Ein Quellcodeblock wird mit

#+BEGIN_SRC emacs-lisp -n -r

#+END_SRC

gesetzt. Die Flags bedeuten dabei:

-n

zur Nummerierung der Codezeilen.

-r

damit auf die Codezeilen referenziert werden kann.

-k

zeigt die Referenzen im Code an

:eval no

Code wird nicht evaluiert

:var

Liste von key=value Variablen, die dem Source-Code übergeben werden.

:results

output um alle Ausgaben des Codes auszugeben

:exports

code, results, both or none

Für weiter Informationen siehe org.html#var.

Nun sollen die Quellcodeblöcke auch mit Farbe formatiert werden. Dafür nutze ich die org-latex Einstellungen.

Erst einmal muss org-latex-default-packages-alist gesetzt werden. Für die LaTeX Umgebung listings zum Quellcode setzen sind die Pakete xcolor (Zeile 17) und listings (Zeile 18) einzutragen.

Aktiviert wird das Paket listings mit der Zeile 20.

Die Sprachen, die listings setzen soll, werden in Zeile 22 aufgelistet. Der erste Eintrag ist der Schalter in der #+BEGIN_SRC Umgebung, der zweite ist die Sprache, die listings benutzen soll.

Wie listings den Code formatieren soll, wird mit den Einstellungen in Zeile 47 definiert.

 1:    '(org-latex-default-packages-alist
 2:       (quote
 3:        (("utf8" "inputenc" t)
 4:         ("T1" "fontenc" t)
 5:         ("" "fixltx2e" nil)
 6:         ("" "graphicx" t)
 7:         ("" "grffile" t)
 8:         ("" "longtable" t)
 9:         ("" "wrapfig" nil)
10:         ("" "rotating" nil)
11:         ("normalem" "ulem" t)
12:         ("" "amsmath" t)
13:         ("" "textcomp" t)
14:         ("" "amssymb" t)
15:         ("" "capt-of" nil)
16:         ("" "hyperref" nil)
17:         ("" "xcolor" t)
18:         ("" "listings" t))))
19: 
20:   '(org-latex-listings t)
21: 
22:   '(org-latex-listings-langs
23:     (quote
24:      ((emacs-lisp "Lisp")
25:       (lisp "Lisp")
26:       (clojure "Lisp")
27:       (c "C")
28:       (cc "C++")
29:       (fortran "fortran")
30:       (perl "Perl")
31:       (cperl "Perl")
32:       (python "Python")
33:       (ruby "Ruby")
34:       (html "css")
35:       (html "HTML")
36:       (xml "XML")
37:       (tex "TeX")
38:       (latex "[LaTeX]TeX")
39:       (shell-script "bash")
40:       (gnuplot "Gnuplot")
41:       (ocaml "Caml")
42:       (caml "Caml")
43:       (sql "SQL")
44:       (sqlite "sql")
45:       (makefile "make"))))
46: 
47:   '(org-latex-listings-options
48:     (quote
49:      (("basicstyle" "\\small\\ttfamily")
50:       ("keywordstyle" "\\color{blue}\\bfseries")
51:       ("commentstyle" "\\small\\color{darkgray}\\rmfamily")
52:       ("stringstyle" "\\small\\ttfamily")
53:       ("breaklines" "true")
54:       ("breakatwhitespace" "true")
55:       ("showspaces" "false")
56:       ("numberstyle" "\\scriptsize")
57:       ("postbreak" "\\space")
58:       ("frame" "single"))))))

Siehe python-n-org-mode.org.

Eine schöne Beschreibung dessen, was mit der org-mode Agenda möglich ist, findet sich unter Org Mode - Organize Your Life In Plain Text!

Die für meine Arbeitsablauf wichtigsten Tastaturkürzel sind:

Mit dem Kommando M-x imenu-list wird ein Fenster mit den Überschriften Innerhalb einer org-mode Datei angezeigt.

Siehe Paketbeschreibung zu imenu-list.

Um einen Abschnitt zu formatieren gibt man den Befehl M-q ein. Dadurch wird ein Zeilenumbruch spätestens in der 70ten Spalte eingefügt, und alle anderen Zeilenumbrüche des Absatzes entfernt. Desweiteren werden alle Leerzeichen nach einem Leerzeichen gelöscht, mit Ausnahme von doppelten Leerzeichen nach einem Satz. Falls nach einem Punkt nur ein Leerzeichen kommt, werden daraus keine zwei Leerzeichen gemacht, schließlich kann emacs nicht wissen, ob es sich wirklich um ein Satzende handelt, oder um eine Abkürzung.

Man kann die Rechtschreibprüfung am Wort nutzen, in dem am Ende des Wortes M-$ betätigt. Richtig gut ist der Modus Flyspell, der Wörter, die er als falsch erkennt, rot-fett-unterstrichen markiert.

Wenn mehrere Fenster geöffnet sind, kann mit C-x { das aktuelle Fenster horizental kleiner, und mit C-x } das aktuelle Fenster horizental größer gemacht werden. Mit den Kürzeln wird der Befehl shrink-window-horizontally oder enlarge-window-horizontally aufgerufen. Mit M-x balance-windows-area werden die Fenster wieder ausgeglichen, m.a.W. also in den Ursprungszustand gebracht.

Tipp: Um einen Befehl zu wiederholen kann C-x z eingegeben werden. Ein weiteres z wiederholt dann den letzten wiederholten Befehl. Um ein Fenster also schrittweise um 5 Schritte zu verkleinern, gibt man

C-x { C-x z z z z

ein.

delete-trailing-whitespace

entfernt alle Leerzeichen am Ende jeder Zeile, entweder im ganzen Puffer oder im markierten Bereich

whitespace-mode

zeigt alle Leerzeichen an, siehe auch WhiteSpace

Emacs bringt ab Werk schon Möglichkeiten mit, um das Kommentieren im Code zu vereinfachen.

Falls für den Modus noch keine Kommtaranfang- und Kommentarendezeichen definiert sind, wird beim ersten Kommentieren im Puffer nach den Kommentarzeichen gefragt, und diese werden ab dann bis zum Schließen des Puffers genutzt. Um es dauerhaft für einen Modus zu defnieren setzt man comment-start und comment-end in der Modus-Datei.

(setq comment-start "#"
      comment-end   "")

Der Dired Puffer ist ein mächtiges Werkzeug, um Dateien zu löschen/umbenennen/erzeugen. Eine schnelle Einführung findet sich unter ergoemacs. Um den Puffer zu öffnen gibt man entweder M-x dired oder C-x d ein. Zusätzlich habe ich noch andere Dired Pakete geladen, bsw. Dired+.

Wenn beim Anlegen einer Datei vorher der Befehl epa-encrypt-file ausgeführt wird, wird zweimal nach einen Passwort gefragt. Nachdem man beidemale das selbe eingegeben hat, wird die Datei mit der zusätzlichen Endung gpg angelegt. Diese ist jetzt verschlüsset, und kann nur noch geöffnet werden, nachdem man das Passwort eingegeben hat. Immer wenn die Datei geändert wird, wird erneut zweimal nach ein Passwort gefragt. Dieses Passwort sollte man sich merken, da ansonsten die Daten in der Datei verschlüsselt bleiben.

Um zu verhindern, dass eine verschlüsselte Datei entschlüsselt im Backup Verzeichnis liegt, habe ich eine Lösung hier.

Lösung für das Tilde-Problem: C-AGr-\

Jetzt erscheint in der Statuszeile ganz links ein „m“. Als nächstes zweimal AGr-~ eingeben und dann SPC. Noch einmal C-AGr-\ um diesen Eingabemodus wieder zu verlassen.

Tja, wenn ich das doch nur wüsste. Alles rumprobieren hat bisher noch gar nichts gebracht. ~ Hier gibt man C-x 8 AGr-~ SPC ein, und schon ist die ~ drin. Ein einfaches AGr-~ SPC reicht aber schon, wie schön.

Dieses Paket ersetzt das Standard undo Verhalten von Emacs. Der alte undo Befehl C-_ funktioniert wie gewohnt. Zusätzlich gibt es jetzt den redo Befehl M-_ und die Möglichkeit, sich den Änderungsbaum mit C-x u anzusehen, und dort einen Stand auszuwählen. Das undo-tree Fenster verlässt man dann mit q.

Mit M-x ido-mode wird der Modus aktiviert. Wenn jetzt C-x b eingegeben wird, erscheint die Pufferliste in kurzform im Echofeld. Wenn man einen Teil eines Puffernames eingibt, wird die Liste dementsprechend kleiner.

Dieses Packet musste nachträglich installiert werden. Das Einrichten geht nur durch anpassen der .emacs Datei.

Nach Eingabe von C-x C-a erscheint die Aufforderung, einen Buchstaben einzugeben. Diesen sucht das Packet dann am Anfang der Wörter im aktuellem Puffer. Wenn nur ein Auftreten gefunden wurde, springt der Cursor direkt dort hin. Bei mehrfachem Auftreten werden die entsprechenden Wörter mit einem Buchstaben markiert. Die Eingabe des Buchstaben lässt den C:ursor dann dort hin springen. Groß- und Kleinschreibung wird dabei ignoriert.

;; ace-jump-mode settings
(autoload
  'ace-jump-mode
  "ace-jump-mode"
  "Emacs quick move minor mode"
  t)
;; you can select the key you prefer to
(define-key global-map (kbd "C-x C-a") 'ace-jump-mode)

Das Paket multiple-cursors ermöglicht es, dass mehrere Markierungen oder ein bestimmtes Wort ein eigenen Cursor zugeordnet bekommt. Dadurch kann dann an diesen Cursorn gleichzeitig das identische eingegeben werden.

Steht der Cursor am Anfang einer Zeile, können die vorherigen/nachfolgende Zeilen mit C-< / C-> markiert werden. Das Verhalten ist nützlich, um einen Bereich auszukommentieren.

Video auf Youtube.

;; multiple-cursors
(require 'multiple-cursors)
(global-set-key (kbd "C-S-c C-S-c") 'mc/edit-lines)
(global-set-key (kbd "C->") 'mc/mark-next-like-this)
(global-set-key (kbd "C-<") 'mc/mark-previous-like-this)
(global-set-key (kbd "C-c C-<") 'mc/mark-all-like-this)

• http://www.emacswiki.org/emacs/Yasnippet
• http://www.emacswiki.org/emacs-de/YasnippetDeutsch

Man beachte das &-Zeichen in der Tabelle. Das Zeichen ist tatsächlich auch einzugeben.

Wenn ein neues Snippet angelegt wird, gibt man am Ende der Bearbeitung C-c C-c ein. Nachdem die folgenden Fragen beantwortet wurden, steht das Snippet auch schon zur Verfügung.

Sprungmarken werden mit $<n> gesetzt. Wobei <n> = 0 die letzte Sprungmarke ist. Mit Tab springt man dann von Marke zu Marke, und kann direkt etwas eingeben. Beim Konstrukt ${<n>:ein Text} steht bei der Sprungmarke schon der vorgegebene Text.

;; yasnippet
(require 'yasnippet)
(yas-global-mode 1)

Gestartet wird der Modus mit M-x icy-mode.

• Es erweitert die Ausgaben beim Auto-Completion.
• Bei M-x werden nach Eingabe von TAB in einem Extrafenster alle möglichen Kommandos angezeigt.
• Beim Öffnen von Dateien und Puffern arbeitet Icicles ebenfalls. Ob ich es besser finde als den Ido-Mode weiß ich aber noch nicht.
• Bei den Bookmarks arbeitet Icicles ebenfalls.

Den automatischen Start habe ich in der .emacs Datei wieder auskommentiert, da es mir so schien, als ob es sich mit dem Helm Paket beist.

;; (require 'icicles)
;;  (icy-mode 1)

Gestartet wird der Modus mit M-x auto-complete-mode.

Nachdem der Modus gestartet wurde, wird beim Schreiben ständig versucht, das aktuelle Wort zu vervollständigen. Falls es nur ein Wort im aktuellem Puffer gibt, welches passt, kann mit ein TAB das Wort direkt vervollständigt werden. Bei mehreren Möglichkeiten öffnet sich ein Popup-Fenster.

Praktisch ist auch, dass beim Eingeben eines Pfades auto-complete automatisch die möglichen Dateien/Ordner zur Auswahl stellt.

Ich habe zusätzlich zum Hauptpaket das Paket ac-abbrev geladen. Somit steht der Liste der Auto-Complete Möglichkeiten auch der Inhalt der Abkürzungsdatei zur Verfügung. Weitere Pakete für verschiedenste Anwendungsmöglichkeiten existieren zwar, sind für mich aber z.Z. noch nicht von Bedeutung.

Mit M-x customize-group RET auto-complete RET kommt man zu den Einstellungen. Dort habe ich global-auto-complete-mode aktiviert, und bei AC Modes den org-mode hinzugefügt.

https://github.com/auto-complete/auto-complete

(require 'auto-complete)
(require 'auto-complete-config)
(ac-config-default)

Dieses Paket, eine Erweiterung des built-in Register, ermöglicht es, dass alle Register nach dem Kommando M-x register-list in einem separaten Fenster angezeigt werden. Wenn der Cursor auf dem Registerzeichen steht, bringt ein RET darauf einen an die entsprechende Stelle, oder kopiert den Inhalt in den Killring, je nach Typ des Register.

Mit ’d’ können Register in der Liste zum Löschen markiert werden. Das betätigen von ’x’ führt das Löschen dann aus.

;; package register-list
(require 'register-list)
;; own keystrokes for register working
(global-set-key (kbd "C-x C-l") 'register-list)
(global-set-key (kbd "C-x C-p") 'point-to-register)
(global-set-key (kbd "C-x C-j") 'jump-to-register)
(global-set-key (kbd "C-x C-r") 'copy-to-register)
(global-set-key (kbd "C-x C-i") 'insert-register)

Dieses Paket ermöglicht es, den Inhalt zwischen zwei Trennzeichen (FROM:, TO:) zu löschen. Dabei werden die beiden Trennzeichen ebenfalls gelöscht. Diese beiden Trennzeichen können auch identisch sein, müssen es aber nicht. Die Trennzeichen werden dabei für FROM: vor dem Cursorpunkt und für TO: nach dem Cursorpunkt gesucht.

• Wenn für FROM: kein Zeichen eingegeben wird, wird von TO: bis Pufferanfang gelöscht.
• Wenn für TO: kein Zeichen eingegeben wird, wird von FROM: bis Pufferende gelöscht.
• Wenn weder für FROM:, noch für TO: ein Zeichen eingegeben wird, wird der ganze Pufferinhalt gelöscht.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; delete the stuff within delimiters ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(require 'delim-kill)

Das Paket goto-chg ermöglicht es, zu den letzten Änderungen in einem Puffer zu springen.

Als Tastaturkürzel habe ich bei mir

C .

für den Sprung zur letzten Änderung, und

C ,

für das entgegengesetzte Springen eingestellt.

(require 'goto-chg)

(global-set-key [(control ?.)] 'goto-last-change)
(global-set-key [(control ?,)] 'goto-last-change-reverse)

dot-mode vi like

Wenn M-x dot-mode aktiviert wurde, wiederholt der Befehl

C .

die letzten Eingaben/Kommandos. Goto-chg funktioniert dann nicht, da ich den selben Keystroke benutze.

(require 'dot-mode)
(add-hook 'find-file-hooks 'dot-mode-on)

Das Programm silversearcher-ag ermöglicht es sehr schnell in Dateien nach einen String zu suchen. Es arbeitet ähnlich wie grep oder ack-grep. Das Emacs Paket ag ermöglicht es mit dem Kommando M-x ag silversearcher-ag auszuführen und das Ergebnis in einem Unterfenster auszugeben. Weiter Informationen finden sich auf der Homepage https://github.com/Wilfred/ag.el.

Die Homepage des silversearcher-ag Projekts ist https://github.com/ggreer/the_silver_searcher.

Mit dem Paket evil-search-highlight-persist ist permanentes Highlight des letzten Suchstrings möglich. Das Highlight kann dann mit C-x SPC wieder ausgeschaltet werden.

Hinweis

Da ich mittlerweile das Paket phi-search benutze, funktioniert das mit der Tastenkombination C-s, C-r und M-% leider nicht mehr.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Permanentes Highlight des letzten Suchstrings ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(require 'evil-search-highlight-persist)
(global-evil-search-highlight-persist t)

Das Emacs Paket helm ist ein Paket, welches die Handhabung von Emacs stark beeinflusst. Eine sehr gute Einführung findet sich unter helm-intro.

Die Einstellungen, die ich dort übernommen habe sind:

;;;;;;;;;;
;; helm ;;
;;;;;;;;;;
(require 'helm-config)
; rebind tab to run persistent action
(define-key helm-map (kbd "<tab>") 'helm-execute-persistent-action)
; make TAB works in terminal
(define-key helm-map (kbd "C-i") 'helm-execute-persistent-action)
; list actions using C-z
(define-key helm-map (kbd "C-z") 'helm-select-action)

(global-set-key (kbd "M-x") 'helm-M-x)

(global-set-key (kbd "C-:") 'ac-complete-with-helm)
(define-key ac-complete-mode-map (kbd "C-:") 'ac-complete-with-helm)

;; C-c C-b wird im org-mode von der Funktion "vorherige Überschrift
;; auf selber Höhe" überschrieben, besser Kürzel C-c h b nutzen
(global-set-key (kbd "C-c h b") 'helm-bookmarks)
(global-set-key (kbd "M-y") 'helm-show-kill-ring)
(global-set-key (kbd "C-x b") 'helm-mini)
(global-set-key (kbd "C-x C-f") 'helm-find-files)
(global-set-key (kbd "C-c h o") 'helm-occur)
(global-set-key (kbd "C-h SPC") 'helm-all-mark-rings)
(global-set-key (kbd "C-c h x") 'helm-register)
;; Damit es zu den Register Kommandos passt, noch einmal mit anderen
;; Keystroke
(global-set-key (kbd "C-x C-h") 'helm-register)
;; Position in Register 1 schreiben
(global-set-key (kbd "C-x C-1") '(lambda () (interactive) (point-to-register ?1)))
;; (global-set-key [f7] '(lambda () (interactive) (register-to-point ?1)))

Das Paket helm-c-yasnippet stellt Kommandos bereit, mit denen Schlüsselwörter aus Yasnippet Helm-typisch ausgewählt werden können. Zum einfachen Aufruf wurde das Kürzel C-c y auf das Kommando helm-yas-complete gelegt.

(global-set-key (kbd "C-c y") 'helm-yas-complete)

Mit Hilfe des Projectile Pakets und des Helm Pakets können Projektordner einfach angesprungen und dort einzelne Dateien ausgewählt werden. Damit das funktioniert muss im entsprechenden Ordner eine leere Datei .proctectile angelegt werden, und das Projectile Paket in diesen Ordner einmal genutzt werden. Danach ist es dem System bekannt, und kann ausgewählt werden. Eine gute Einführung findet sich auf der helm-projectile Seite.

;; mit customize gesetzt
 '(projectile-completion-system (quote helm))
 '(projectile-global-mode t)

;;;;;;;;;;;;;;;;;;;;;
;; helm projectile ;;
;;;;;;;;;;;;;;;;;;;;;
(setq helm-projectile-sources-list
    '(helm-source-projectile-projects
      helm-source-projectile-files-list))
(setq projectile-switch-project-action 'helm-projectile-find-file)
(setq projectile-switch-project-action 'helm-projectile)

Das Paket neotree ist vergleichbar mit dem Vim Paket nerdtree. Das ein- und ausblenden des Dateimanagers habe ich auf die Taste F12 gelegt.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; neotree mit F12 togglen ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(global-set-key (kbd "<f12>") 'neotree-toggle)

Mit Hilfe dieses Paketes kann innerhalb von Emacs mit Hilfe von Google übersetzt werden. Meine Einstellungen habe ich dabei so gewählt, dass mit C-c t das Wort unter dem Cursor oder der markierte Teil übersetzt wird, und mit C-c T das zu Übersetzende eingegeben werden kann. Die Auswahl der Quell- und Zielsprache habe ich dabei fest auf „von Englisch nach Deutsch“ eingestellt. Die Übersetzung erscheint dabei als Popup-Fenster am Cursorpunkt.

;; Einstellungen via M-x customize
 '(google-translate-default-source-language "en")
 '(google-translate-default-target-language "de")
 '(google-translate-output-destination (quote popup))
 '(google-translate-show-phonetic t)

;;;;;;;;;;;;;;;;;;;;;;;;
;; google translation ;;
;;;;;;;;;;;;;;;;;;;;;;;;
(require 'google-translate)
(require 'google-translate-default-ui)
(global-set-key "\C-ct" 'google-translate-at-point)
(global-set-key "\C-cT" 'google-translate-query-translate)

Das Paket swiper gibt einen Überblick während einer regexp Suche in einem Puffer. In M-x customize habe ich „Swiper Completion Method“ auf „Helm“ gesetzt. Als Keystroke setzte ich in der .emacs Datei C-c s. Danach kann man ein oder mehrere Suchmuster eingeben, und die gefunden Zeilen werden helm-artig gelistet. Diese Einträge können dann mit Pfeil-auf/ab oder C-n/p angewählt werden. Im Originalpuffer wird dann sogleich diese Zeile angesprungen. Mit RET wird die markierte Zeile angesprungen, und swiper wird beendet.

Emacs Swiper Youtube Video

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; swiper - use pattern as regexp and list it ;;
;; my standard method is swiper-helm          ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(require 'swiper)
(global-set-key (kbd "C-c s") 'swiper-helm)
;; (global-set-key (kbd "C-c s") 'swiper) ;; falls swiper--helm nicht funktioniert

Dieses Paket kann bei mehreren Fenstern hilfreich sein. Wenn im aktiven Fenster der Keystroke C-x C-z eingegeben wird, wird dieses Fenster auf die volle Framegröße gebracht, und die Menüleiste verändert ihre Farbe. Nach einen nochmaligen C-x C-z werden wieder aller Fenster wie vorher angezeigt.

(require 'zoom-window)
(global-set-key (kbd "C-x C-z") 'zoom-window-zoom)
(setq zoom-window-mode-line-color "Cyan")

Das Paket ermöglicht es die erste Nummer in der aktuellen Zeile, vom Cursor aus gesehen zu inkrementieren/dekrementieren.

(require 'evil-numbers)
(global-set-key (kbd "C-+") 'evil-numbers/inc-at-pt)
(global-set-key (kbd "C--") 'evil-numbers/dec-at-pt)

Mit Hilfe des Pakets wn-mode ist es möglich zwischen den Fenstern mit M-1 bis M-0 zu wechseln.

Das Paket switch-window ermöglicht es, die Nummer der Fenster in den Fenstern füllend anzuzeigen, und durch betätigen der Nummer das Fenster anzuspringen. Ein Bild davon kann man sich hier machen.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; wn mode to switch to other windows via M-1 ... M-0 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(wn-mode)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; switch-window set to keystroke M-s M-w ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(require 'switch-window)
(global-set-key (kbd "M-s M-w") 'switch-window)

Das Paket comment-dwim-2 verbessert das built-in Kommentieren von Emacs. In der Zeile/Region einfach M-; eingeben, und schon wird die Zeile/Region kommentiert. Beim nochmaligen ausführen wird entkommentiert, und an Ende der Zeile ein Kommentarzeichen eingefügt. Wenn eine drittes mal der Befehl ausgeführt wird, werden die Kommentarzeichen gelöscht.

Ansehen kann man sich das Verhalten hier.

(global-set-key (kbd "M-;") 'comment-dwim-2)

Das Paket bm unterstützt sichtbare Lesezeichen innerhalb eines Puffers. Es ist nicht mit dem built-in bookmark zu verwechseln, sondern dient dazu, innerhalb eines Puffers mit einfachen Tastaturkürzeln Lesezeichen zu setzen/löschen und sie in der Reihenfolge, in der sie gesetzt worden sind, anzuspringen.

In den Einstellungen habe ich die permanente Speicherung der Lesezeichen aktiviert. Dafür war es notwendig, den Code aus der Beschreibung des Paketes in die .emacs Datei zu übernehmen.

Das anspringen der Lesezeichen über mehrere Puffer ist nicht aktiviert. Somit bleiben die Lesezeichen zwar erhalten, aber für die Auswahl eines Puffers ist weiterhin das bookmark-built-in zuständig.

Damit helm und bm zusammen arbeiten, habe ich zusätzlich das Paket helm-bm geladen. Das von mir eingestellte Tastaturkürzel C-c b überschreibt dabei das alte Verhalten, alle offenen org-mode Puffer aufzulisten. Die Lesezeichen der offenen Puffer zu listen und anspringen zu können, erscheint mir aber als wichtiger.

Die Tastaturkürzel habe ich vom Autor übernommen.

Auch die Maus kann benutzt werden, um am linken Rand (fringe) Lesezeichen zu setzen/löschen und anzuspringen.

;; M$ Visual Studio key setup.
(global-set-key (kbd "<C-f2>") 'bm-toggle)
(global-set-key (kbd "<f2>") 'bm-next)
(global-set-key (kbd "<S-f2>") 'bm-previous)

;; Click on fringe to toggle
;; bookmarks, and use mouse wheel to
;; move between them.
(global-set-key (kbd "<left-fringe> <mouse-5>") 'bm-next-mouse)
(global-set-key (kbd "<left-fringe> <mouse-4>") 'bm-previous-mouse)
(global-set-key (kbd "<left-fringe> <mouse-1>") 'bm-toggle-mouse)

;; This is necessary to activate presistent bookmarks.

;; Make sure the repository is loaded as early as possible
(setq bm-restore-repository-on-load t)
(require 'bm) ; this line is really really necessary

;; Loading the repository from file when on start up.
(add-hook' after-init-hook 'bm-repository-load)

;; Restoring bookmarks when on file find.
(add-hook 'find-file-hooks 'bm-buffer-restore)

;; Saving bookmark data on killing a buffer
(add-hook 'kill-buffer-hook 'bm-buffer-save)

;; Saving the repository to file when on exit.
;; kill-buffer-hook is not called when Emacs is killed, so we
;; must save all bookmarks first.
(add-hook 'kill-emacs-hook '(lambda nil
(bm-buffer-save-all)
(bm-repository-save)))

;; Update bookmark repository when saving the file.
(add-hook 'after-save-hook 'bm-buffer-save)

;; Restore bookmarks when buffer is reverted.
(add-hook 'after-revert-hook 'bm-buffer-restore)

;;;;;;;;;;;;;;;;;;;;;;;;;;
;; helm and bm together ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;
;; overwrites the org-mode command to list all active org buffers
(global-set-key (kbd "C-c b") 'helm-bm)

Das Paket mwim setzt den Cursor an das Ende oder den Anfang einer Zeile, so wie es gemeint ist. Ich habe es auf die Standard Keystrokes C-a und C-e gelegt.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; mwim - move where I mean ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(autoload 'mwim-beginning-of-code-or-line "mwim" nil t)
(autoload 'mwim-beginning-of-line-or-code "mwim" nil t)
(autoload 'mwim-end-of-code-or-line "mwim" nil t)
(autoload 'mwim-end-of-line-or-code "mwim" nil t)
(global-set-key (kbd "C-a") 'mwim-beginning-of-code-or-line)
(global-set-key (kbd "C-e") 'mwim-end-of-code-or-line)

Das Paket smooth-scrolling lässt den Cursor beim Scrollen mit C-n und C-p weicher scrollen. In der .emacs Datei habe ich nur den Aufruf

(require 'smooth-scrolling)

stehen. Die weiteren Einstellungen kann man dann mit M-x customize erledigen.

Das Paket nicht mit smooth-scroll verwechseln.

Um das Paket navi-mode zu nutzen, müssen die drei Pakete

1. navi-mode
2. outshine
3. outorg

installiert werden. Danach noch in der .emacs Datei

(require 'navi-mode)

eintragen, und los kann es gehen.

Das Paket stellt einen read-only Puffer zur Verfügung, der ähnlich wie occur funktioniert, nur das die Suchbegriffe vorgegeben werden. Gedacht ist das Plugin für org-mode Dateien. Damit steht dem Autor die Dokumentenstruktur als extra Seite zur Verfügung, um schnell und einfach durch das Dokument zu navigieren, ohne die Übersicht zu verlieren.

Mit M-s n wird das Fenster geöffnet und/oder aktualisiert. Dabei wird der aktivierte Cursor in das jeweils andere Fenster aktiviert.

Im navi-mode Fenster wird mit den Tasten 1 … 8 der Level bestimmt, der angezeigt wird. Bei org-mode Dateien entspricht dies der Anzahl der Sterne vor einer Überschrift.

Bei navi-mode sind desweiteren einige Schlüsselwörter vordefiniert, nach denen es sucht. Für die eigenen Bedürfnisse können diese angepasst und erweitert werden.

Eine weiter Beschreibung findet sich unter http://orgmode.org/worg/org-tutorials/org-outside-org.html

Mittlerweile habe ich navi mode durch imenu-list ersetzt!

Dieses Paket elmacro stellt die Fähigkeiten zu Verfügung, die letzten Kommandos oder das letzte Makro in emacs-lisp Code auszugeben. Damit es schon beim Start aktiviert ist, gibt man in der .emasc Datei

(elmacro-mode 1)

ein. Damit stehen die Kommandos

• elmacro-show-last-commands
• elmacro-show-last-macro

zu Verfügung.

Mit imenu können Funktionen in einer Code Datei direkt angesprungen werden. Das Paket imenu-list fügt dieser Funktion die Fähigkeit hinzu, diese Funktionen als Liste in einen Extra Fenster aufzulisten.

Gestartet wird imenu-list mit

M-x imenu-list-minor-mode

Innerhalb des Listenpuffers IList wird mit RET die Funktion direkt angeprungen. Mit SPC wird die Funktion im Code Puffer angezeigt, der Cursor aber bleibt im imenu-list Fenster.

Gerade im org-mode ist imenu-list recht nützlich, um die Dateistruktur in einem extra Fenster zu sehen. Für den schnellen Zugriff habe ich das Kommando auf die F9 Taste gelegt. Dieses Fenster kann mit q wieder geschlossen werden.

(global-set-key (kbd "<f9>") 'imenu-list)

Das Paket discover stellt ein Kontextmenü bereit, welches bei komplizierteren Emacs Kommandos aufpoppen, und somit eine Auswahl zur Vervollständigung des Kommandos, unterstützen soll. Bisher unterstützt es dired, register und isearch. Da ich register und isearch durch andere Kommandos und Pakete meinen Bedürfnissen schon angepasst habe, funktioniert discover nur noch bei dired und occur. Da ich dired selten bewusst nutze, ist dieses Paket genau dort eine große Hilfe. Innerhalb eines dired Puffers wird mit der Eingabe eines ? das Kontextmenü geöffnet, und schon sehe ich eine Auswahl der möglichen Folgekommandos.

In der .emacs Datei muss nach der Installation noch

(require 'discover)
;; (global-discover-mode 1)

eingetragen werden, um es global zu aktivieren.

Da es sich nicht unbedingt mit allen Einstellungen, und Arbeitsabläufen, die ich mir zusammengestellt habe, verträgt, ist es bei mir allerdings deaktiviert.

Mit dem Paket cycbuf kann durch die Puffer gewechselt werden, wobei dabei jeweils temporär die Liste der Puffer angezeigt wird. Da die vordefinierten Keystrokes sich mit dem org-mode beißen, habe ich sie meinen Bedürfnissen angepasst. Mit C-c C-left geht es direkt zum vorherigen Puffer in der Pufferliste, und mit C-c C-right in den nächsten Puffer. Die Pufferliste bleibt solange bestehen, bis eine andere Tastatureingabe erfolgt.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; cycbuf to cycle smooth through buffers ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(require 'cycbuf)
;; The keys, which are defined in cycbuf-init are:
;;  meta right         cycbuf-switch-to-next-buffer
;;  meta left          cycbuf-switch-to-previous-buffer
;;  meta super right   cycbuf-switch-to-next-buffer-no-timeout
;;  meta super left    cycbuf-switch-to-previous-buffer-no-timeout

;; The pre-defined keys are already used by org-mode, so.
;; (add-hook 'after-init-hook 'cycbuf-init)
(global-set-key (kbd "C-c <C-left>")  'cycbuf-switch-to-previous-buffer-no-timeout)
(global-set-key (kbd "C-c <C-right>") 'cycbuf-switch-to-next-buffer-no-timeout)

Das Paket zop-to-char ist eine Erweiterung für das Emacs built-in zap-to-char. Im Gegensatz zum Original löscht es nicht automatisch den Text zwischen den Cursorpunkt und dem nächsten Auftreten des eingegeben Zeichens, sondern markiert diesen Bereich und zeigt im Minipuffer die möglichen Folgekommandos an. Während man im zop-to-char Modus ist, können auch andere - oder dasselbe - Zeichen eingegeben werden, und die Markierung springt dann zum nächsten Auftreten des zuletzt eingegebenen Zeichens. Wenn man dasselbe Zeichen immer wieder als nächste „Sprungmarke“ benutzen will, reicht auch ein <right>, zurück kann man dann mit <left>.

Der Teil, der gelöscht wird, wird im Kill-Ring gespeichert.

Emacs zop-to-char Youtube Video

Wie vom Paketauthor vorgeschlagen, habe ich in der .emacs Datei das zap-to-char Kommando M-z <char> auf zop-to-char gelegt.

  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;; zop-to-char,                            ;;
  ;; a replacement of zap-to-char M-z <char> ;;
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (global-set-key [remap zap-to-char] 'zop-to-char)

Das Paket csv-mode erleichtert den Umgang mit zeichenseparierten Werten. Der Standardtrenner ist „,“. In den meisten Fällen benutze ich allerdings das „;“ als Trenner. Dies kann man in den Einstellungen (customize) anpassen.

Entgegen dem Vorschlag des Pakets lade ich das Paket nicht automatisch, sondern nur über das Kommando M-x csv-mode. Danach wird der Trenner farblich hervorgehoben. Sehr schön ist auch, dass damit das Kommando csv-align-fields zur Verfügung steht. Damit werden die Spalten visuell getrennt, was die Lesbarkeit stark verbessern kann. Das Kommando M-x csv-unalign-fields macht dies dann wieder rückgängig.

Die wichtigsten Kommandos sind mit Keystrokes belegt.

Das Paket guide-key zeigt die weiteren möglichen Kommandos auf den Anfang eines Kommandos im Minipuffer an. Dies kann insbesondere bei eher selten genutzten Keystrokes hilfreich sein. Bei mir habe ich nur den Mode eingeschaltet und die guide-key-sequence auf t gesetzt. Für weitere Möglichkeiten sei auf die Homepage von guide-key verwiesen.

Das Paket show-marks listet die Marken innerhalb des Puffers auf. Mit hoch-runter können die markierten Zeilen direkt angesprungen werden. Mit q verlässt man das show-marks Fenster und schließt es. Der Unterschied zum Kommando helm-mark-ring ist, dass bei helm die gewählte Zeile mit RET angesprungen, und dass helm Fenster geschlossen wird. Bei show-marks jedoch wird die Zeile direkt angesprungen. Das ist praktisch um im Puffer durch die markierten Zeilen zu springen.

(global-set-key (kbd "C-c m") 'show-marks)

Das Paket clipmon hat zwei Funktionen, die ganz nützlich sein können.

Wenn der clipmon-mode aktiv ist, werden Texte, die außerhalb von Emacs in den Zwischenspeicher kommen, auch in den Kill-Ring von Emacs abgelegt. Alleine dies finde ich gerade unter Windows nützlich, da dort ein vernünftiges Clipboard fehlt.

Wenn clipmon-autoinsert aktiviert wird, werden die Texte, die außerhalb von Emacs in den Zwischenspeicher kommen, direkt in den Puffer geschrieben.

Alle möglichen Einstellungen können mit

M-x customize-group RET clipmon

gemacht werden.

Wenn das Paket engine-mode aktiviert ist, kann aus Emacs heraus eine Suchanfrage direkt im Browser gestartet werden. Damit erspart man sich ein paar Schritte, wenn man gerade am emacsen ist. ;-)

Da ich den Standard Prefix-Tastaturkürzel schon bei sparse org-agenda nutze, habe ich in der engine-mode.el die Zeile

• (engine/set-keymap-prefix (kbd "C-c /"))

auskommentiert. In der .emacs Datei fügte ich Dafür

• (engine/set-keymap-prefix (kbd "C-c e"))

ein. Schade das der Entwickler des Pakets den Tastaturkürzel fest in den Code programmiert hat.

Meine eingestellten Suchmaschinen, die über einen Buchstaben nach Eingabe des Prefix-Tastaturkürzels ausgewählt werden können, sind:

d

duckduckgo.com

g

google.de

w

de.wikipedia.org

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; engine-mode                                               ;;
;; To start search in browser out of emacs.                  ;;
;; I have comment out the line                               ;;
;; ;; (engine/set-keymap-prefix (kbd "C-c /"))               ;;
;; because of I need the keystroke to sparse the org-agenda. ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(require 'engine-mode)
(engine-mode t)
;; use Emacs' built-in eww browser:
;; (setq engine/browser-function 'eww-browse-url)

(engine/set-keymap-prefix (kbd "C-c e"))

(defengine duckduckgo
  "https://duckduckgo.com/?q=%s"
  :keybinding "d")

(defengine google
  "http://www.google.de/search?ie=utf-8&oe=utf-8&q=%s"
  :keybinding "g")

(defengine wikipedia
  "http://www.wikipedia.org/search-redirect.php?language=de&go=Go&search=%s"
  :keybinding "w"
  :docstring "Searchin' the wikis.")

(defengine youtube
  "https://www.youtube.com/results?search_query=%s"
  :keybinding "y")

Der Text als Präsentation.

Das Paket bookmark+ erweitert das built-in bookmark um Funktionen.

In der .emacs Datei muss (require ’bookmark+) eingetragen werden!

Mit dem Paket sunshine kann eine Wettervorhersage von openweathermap auf Emacs gezaubert werden. Dafür muss man sich erst einmal auf openweathermap anmelden und sich eine appid holen. Den Ort der Wettervorhersage gibt man dann, für Deutschland, als Postleitzahl und der Länderkennung DE an.

Für das schnelle Öffnen habe ich den Aufruf auf die Taste F8 gelegt. Schließen kann man das Fenster mit q.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; sunshine, weather forecast                ;;
;; xxxx                                      ;;
;; xxxxxxxxxx                                ;;
;; xxxxxxxxxx                                ;;
;; API key: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(require 'sunshine)
(setq sunshine-location "88161,DE")
;; (setq sunshine-location "49762,DE")
(setq sunshine-appid "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
(setq sunshine-units (quote metric))
(setq sunshine-show-icons t)
(global-set-key (kbd "<f8>") 'sunshine-forecast)

Mit Hilfe des Pakets elpa-mirror werden die installierten Pakete in ein Verzeichnis kopiert. Dieses Verzeichnis kann als Repository angegeben werden. Dies ist nützlich, wenn man die Pakete auf einen anderen System in Emacs einbinden möchte.

Zum Erstellen des Verzeichnisses führt man das Kommando M-x elpamr-create-mirror-for-installed aus. Initial muss man das Zielverzeichnis einmal angeben, welches schon vorher existieren muss.

In der .emacs Datei gibt man das selbst angelegte Paketverzeichnis als Paketarchiv an und startet dann M-x package-list-packages.

(setq package-archives '(("myelpa" . "~/myelpa")))

Mit dem Paket highlight-thing wird das Wort unter dem Cursor im Puffer gehighlightet.

(require 'highlight-thing)
(global-highlight-thing-mode)

Das Paket cycle-resize stellt Funktionen zur Verfügung, mit dem das aktuelle Fenster (wenn denn auch mehrere zu Verfügung stehen) einfach und schnell in seiner vertikalen oder horizontalen Größe verstellt werden kann. Die vorgegebenene Werte sind 80% – 50% – 20% – 50% des Rahmens.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; cycle-resize, resize splitted windows ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(require 'cycle-resize)
(global-set-key (kbd "C-M-v") 'cycle-resize-window-vertically)
(global-set-key (kbd "C-M-h") 'cycle-resize-window-horizontally)
;; default values are 80 -- 50 -- 20 -- 50
;; (setq cycle-resize-steps '(80 50 20 50))

Das Paket auto-yasnippet ermöglicht es, dass während des Schreibens ein Schnippsel erstellt, und ausgeführt werden kann. Dies ist erst einmal auf ein Schnippsel beschränkt, allerdings kann das aktuelle Schnippsel schnell und einfach als yasnippet Schnippsel gespeichert, und so auch später weiter genutzt werden. Dafür wird das Kommando aya-persist-snippet bereitgestellt.

In meiner .emacs Datei sind nicht die vorgeschlagenden keybindings eingestellt, sondern M-C-w für das Erstellen, und M-C-y für das Ausführen.

(global-set-key (kbd "M-C-w") #'aya-create)
(global-set-key (kbd "M-C-y") #'aya-expand)

Während des Schreibens wird vor den Austauschausdrücken ein ~ vorangestellt.

Dies ist ein ~auto-yasnippet Beispiel.

Sollte der Ausdruck Teil eines Wortes sein, wird der Ausdruck in Backticks eingerahmt.

Eisenbahn`gleis'anlage.

Falls sich ein Ausdruck wiederholt, wird beim Schreiben die Wiederholung zeitgleich ebenfalls editiert.

Dies ist ein ~auto-yasnippet Beispiel.
Das Paket ~auto-yasnippet kann tolle Sachen machen.

Beim Erstellen eines auto-yasnippet Schnippsels wird entweder die aktuelle Zeile verwendet, oder die markierte Region.

Mit Hilfe des Pakets org-bullets werden die Sterne in den Kapitelüberschriften durch utf-8 Zeichen (bullets) ersetzt.

Damit es beim Start einer org-mode Datei gleich mitgeladen wird, muss in der .emacs Datei das folgende eingetragen werden.

(require 'org-bullets)
(add-hook 'org-mode-hook (lambda () (org-bullets-mode 1)))

Gerade für Python Code habe ich lange nach ein Paket gesucht, das elegant Code-Blöcke einklappt. Das m.M.n. beste dafür ist das Paket yafolding. Da es in Abhängigkeit der Einrückung arbeitet ist es für Python Code geradezu prädestiniert.

Um es im python-mode gleich zu aktivieren habe ich folgendes in die .emacs Datei eingetragen.

(add-hook 'python-mode-hook
          (lambda () (yafolding-mode)))

(define-key yafolding-mode-map (kbd "C-c <C-M-return>") 'yafolding-toggle-all)
(define-key yafolding-mode-map (kbd "C-c <C-S-return>") 'yafolding-hide-parent-element)
(define-key yafolding-mode-map (kbd "C-c <C-return>") 'yafolding-toggle-element)

Dieses Paket org-bookmark-heading ermöglicht bookmarks auf den Header in einer org-mode Datei. Dafür werden keine neuen Keystrokes benötigt, es muss nur der Cursor auf dem Header (nicht die *) stehen, während man, wie gewohnt, ein bookmark anlegt.

Das Verfahren „one time pad encrypt“ verschlüsselt einen Text mit einen Schlüssel, der die Länge des Textes haben sollte. In Emacs kann dies mit dem Paket one-time-pad-encrypt erledigt werden. Der zu verschlüsselnde Text muss dafür markiert werden, und der Befehl one-time-pad-encrypt ausgeführt werden. Für das Entschlüsseln wird der selbe Befehl genutzt.

Das Paket helm-org-rifle ist für das Suchen in org-Dateien hilfreich. Meine Einstellungen in der .emacs Datei sind:

  (global-set-key (kbd "C-c r r") 'helm-org-rifle)
  (global-set-key (kbd "C-c r b") 'helm-org-rifle-current-buffer)
  (global-set-key (kbd "C-c r d") 'helm-org-rifle-directories)
  (global-set-key (kbd "C-c r f") 'helm-org-rifle-files)

helm-org-rifle

Zeigt die Ergebnisse aller offenen org-mode Puffer

helm-org-rifle-current-buffer

Zeigt die Ergebnisse des aktuellen Puffers

helm-org-rifle-directories

Zeigt die Ergebnisse aus gewählten Verzeichnissen.

helm-org-rifle-files

Zeigt die Ergebnisse aus gewählten Dateien.

Das Paket yankpad ermöglicht es, dass man Text strukturiert in eine definierte org-mode Datei ablegt. Diese Texte können später dann einfach eingefügt werden. Schön ist es auch, dass man die Texte wie bei Yasnippet mit Sprungmarken und vordefinierten Auswahltexten anlegen kann. Eine ausführliche Anleitung findet sich auch auf der Homepage des Pakets.

Hier mal ein Beispiel

  * Beispiel
   ** Text
  Die ist ein Text mit ${1:Sprungmarke} und Auswahltext ${2:$$(yas-choose-value`("Bla" "Blub"))}.

Damit ich das ganze auch über Keystrokes nutzen kann, habe ich folgendes in die .emacs Datei geschrieben.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; yankpad                                            ;;
;; https://github.com/Kungsgeten/yankpad ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(setq yankpad-file "~/orgnotes/yankpad.org")

(global-set-key (kbd "C-x C-y C-y") 'yankpad-insert)
(global-set-key (kbd "C-x C-y C-c") 'yankpad-set-category)

Die Pakete werden mit Hilfe des Pakets use-package aufgerufen.

(unless (package-installed-p 'use-package)
    (package-refresh-contents)
    (package-install 'use-package))

Kann benutzt werden, um Pakete nur einmal auszuprobieren.

(use-package try
    :ensure t)

Wenn der Cursor innerhalb eines Bereichs liegt, bsw. durch Klammern eingegrenzt, kann mit dem Kommando er/expand-region die Markierung auf den Bereich erweitert werden. Wird das Kommando wiederholt, vergrößert sich der markierte Bereich. Mit er/contract-region setzt man die Markierung schrittweise wieder zurück.

  (use-package expand-region
    :bind
    (("C-;"   . er/expand-region)
     ("C-M-;" . er/contract-region)))

There are three commands: `embrace-add’, `embrace-change’ and `embrace-delete’ that can add, change, and delete surrounding pairs respectively. You can bind these commands to your favorite key bindings.

There is also a dispatch command `embrace-commander’. After invoking `embrace-commander’, you can hit:

• `a’ for `embrace-add’
• `c’ for `embrace-change’
• `d’ for `embrace-delete’

  (use-package embrace
    :bind
    (("C-(" . embrace-commander)))

To enable emojify mode globally use `global-emojify-mode’. :) :-) ;-) :D

  (use-package emojify
    :ensure t
    :init
    (global-emojify-mode 1)
    :config
  )

Das Paket ob-async ermöglicht es, dass während ein org-mode Code-Block arbeitet, man weiterhin im Puffer editieren kann. Dafür muss dann die Option :async in der #BEGIN_SRC Zeile eingetragen werden.

  (use-package ob-async
    :init
    :config
    (add-to-list 'org-ctrl-c-ctrl-c-hook 'ob-async-org-babel-execute-src-block)
  )

ivy-yasnippet

Das Paket orgalist ermöglicht das Nutzen von Listen (Todos etc.) in Nicht-Org-Dateien.

Mit Hilfe des Pakets fill-function-arguments kann man bsw. Listen oder Dictionaries (Python) zeilenweise zu formatieren. Damit der Aufruf des Kommandos fill-function-arguments-dwim auch wie gewünscht funktioniert muss der Cursor innerhalb der Klammern stehen.

Beispiel von-nach:

f = [ 1,  2, 3, 4, 5 ]

f = [
 1,
 2,
 3,
 4,
 5
]

d = { 'a' : 2, 'b' : 4, 'c' : 8}

d = {
 'a' : 2,
 'b' : 4,
 'c' : 8
}

Da es mich stört, bei yes-or-no Abfragen jedesmal das ganze Wort einzutippen, habe ich folgende Zeile meiner .emacs Datei hinzugefügt. Jetzt reicht ein einfachen y oder n.

(fset 'yes-or-no-p 'y-or-n-p)

Package to show LaTeX Code as it is compiled – WYSIWYG.

Damit org-mode Dateien beim Export nach LaTeX – PDF ein einheitliches Format erhalten, habe ich mir eine LaTeX Header Template Datei geschrieben, die dann in der org-mode Datei genutzt werden kann.

Die LaTeX Header Template Datei wird mit #+LATEX_CLASS eingebunden. Die Variablen können dann mit #+LATEX_HEADER angepasst werden.

Der Anfang dieser org-mode Datei sieht dann folgendermaßen aus.

#+LATEX_CLASS: akreport
#+LATEX_HEADER: \setauthor{Andreas Kruse}
# #+LATEX_HEADER: \setauthoraddress{<whatever>}
# #+LATEX_HEADER: \setauthortel{<whatever>}
# #+LATEX_HEADER: \setauthormobile{<whatever>}
#+LATEX_HEADER: \setauthoremail{leak@online.ms}
# #+LATEX_HEADER: \setauthorurl{<whatever>}
#+LATEX_HEADER: \setleftfoot{\akrauthor}

#+TITLE: Emacs Notizen
#+AUTHOR: Andreas Kruse
#+STARTUP: indent content hidestars
#+DATE: {{{modification-time(%d.%m.%Y)}}}
#+EMAIL: leak@online.ms

Damit die LaTeX Klasse für org-mode bekannt ist, muss sie in den Emacs Einstellungen eingefügt werden. Unter Org Latex Classes fügt man dafür eine neue Klasse ein, eventuell so wie folgt.

 LaTeX class: akreport
 LaTeX header: \input{/home/andreas/orgnotes/templates/akreport.tex}
 Levels:
 INS DEL Choice: Value Menu Heading:
               numbered: \chapter{%s}
             unnumbered: \chapter*{%s}
 INS DEL Choice: Value Menu Heading:
               numbered: \section{%s}
             unnumbered: \section*{%s}
 INS DEL Choice: Value Menu Heading:
               numbered: \subsection{%s}
             unnumbered: \subsection*{%s}
 INS DEL Choice: Value Menu Heading:
               numbered: \subsubsection{%s}
             unnumbered: \subsubsection*{%s}
 INS DEL Choice: Value Menu Heading:
               numbered: \fourthsection{%s}
             unnumbered: \fourthsection*{%s}
 INS DEL Choice: Value Menu Heading:
               numbered: \fifthsection{%s}
             unnumbered: \fifthsection*{%s}

html {
    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
    font-size: 120%;
    max-width: 800px;
    margin: 20px;
    background-color: #363636;
    background-image: url(./images/emacs_gnu_logo.png)
}

a:link {
    color:#00b0b0;
}
a:visited {
    color:#00b0b0;
}
a:active {
    color:#00b0b0;
}

.title {
    text-align: left;
    font-size: 150%;
    margin-top: 20px;
    padding-bottom: 0.5em;
    border-bottom: 1px solid;
}
h2 {
    font-size: 130%;
}
h3 {
    font-size: 120%;
}

#table-of-contents {
    font-size: 9pt;
    position: fixed;
    right: 0em;
    top: 0em;
    background: #363636;
    -webkit-box-shadow: 0 0 1em #777777;
    -moz-box-shadow: 0 0 1em #777777;
    -webkit-border-bottom-left-radius: 5px;
    -moz-border-radius-bottomleft: 5px;
    text-align: right;
    /* ensure doesn't flow off the screen when expanded */
    max-height: 80%;
    overflow: auto;
    z-index: 200;
}

#table-of-contents h2 {
    font-size: 9pt;
    max-width: 8em;
    font-weight: normal;
    padding-left: 0.5em;
    padding-top: 0.05em;
    padding-bottom: 0.05em;
}

#table-of-contents ul {
    margin-left: 14pt;
    margin-bottom: 10pt;
    padding: 0
}

#table-of-contents li {
    padding: 0;
    margin: 1px;
    list-style: none;
}

#table-of-contents ul>:first-child {
    color: blue;
}

#table-of-contents #text-table-of-contents {
    display: none;
    text-align: left;
}

#table-of-contents:hover #text-table-of-contents {
    display: block;
    padding: 0.5em;
    margin-top: -1.5em;
}

div.figure {
    padding: 0.5em;
}
div.figure p {
    text-align: center;
    font-style: italic;
}
#postamble {
    font-size: 90%;
    border-top: 1px solid;
    margin-top: 20px;
}

Zurück zur Beschreibung.

Diese Funktion habe ich unter Acronym mode for Emacs, erstellt von John Kitchin, gefunden. Es wird der Minor Mode Acronym Mode (AM) erstellt, der die Definition eines Acronyms im Text findet und speichert. Bei dem erneuten Auftauchen des Acronyms wird, wenn der Mauscursor auf ihm liegt, ein Tooltipp mit der Definition des Acronyms eingeblendet. Falls man ohne Maus arbeitet, reicht ein „C-h .“, während der Cursor auf dem Acronym ist, um den Tooltipp im Minipuffer anzuzeigen.

Falls die Fehlermeldung

• add-to-list: Symbol's function definition is void: button-lock-set-button
  

erscheint, fehlt das benötigte Paket button-lock. Dieses Paket muss dann auch vorher aktiviert sein.

(require 'button-lock)
(global-button-lock-mode 1)

(make-variable-buffer-local
  (defvar *acronym-buttons* '()
    "List of acronym buttons."))

(require 'rx)

(defun my/highlight-acronyms ()
  (save-excursion
    (let ((case-fold-search nil))
      (goto-char (point-min))
      (while (re-search-forward "(\\([A-Z]+\\))" nil t)
        (when flyspell-mode
          (flyspell-delete-region-overlays
           (match-beginning 1)
           (match-end 1)))
        (let* ((acronym (match-string 1))
               (p (point))
               (definition
                 (save-excursion
                   (goto-char (match-beginning 1))
                   (backward-word (length acronym))
                   (buffer-substring (point) p))))
          (add-to-list '*acronym-buttons*
                       (button-lock-set-button
                        (rx word-start (eval (match-string 1)) word-end)
                        nil
                        :help-echo definition)))))))

(defun my/refresh-acronyms ()
  "Refresh acronym tooltips in buffer."
  (dolist (button *acronym-buttons*)
     (button-lock-unset-button button))
  (setq *acronym-buttons* '()))

(defun my/remove-acronym-buttons ()
  (dolist (button *acronym-buttons*)
    (button-lock-unset-button button))
  (setq *acronym-buttons* '()))

(defun my/write-acronyms-at-point ()
  "Write the found acronyms in current buffer at point."
  (interactive)
  (my/refresh-acronyms)
  (dolist (button *acronym-buttons*)
    (insert button "\n")))

;;;###autoload
(define-minor-mode acronym-mode
  "Put definitions on acronyms."
  :lighter " AM"
  (if acronym-mode
      (my/highlight-acronyms)
    (my/remove-acronym-buttons)))

(provide 'acronym-mode)

Test des Acronym Minor Modes. Der Acronym Mode wird, wenn aktiviert, mit AM angezeigt.

Bei bestimmten Dateien oder Dateitypen kann es sein, dass das automatische Anlegen einer Backup-Datei nicht erwünscht ist. Dies gilt insbesondere für verschlüsselte Dateien wie bei gpg (siehe epa-encrypt-file). Eine Lösung habe ich auf der Seite von Anirudh Sasikumar gefunden.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; sensitive mode to prevent backup file at sensitive files ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-minor-mode sensitive-mode
  "For sensitive files like password lists.
It disables backup creation and auto saving.

With no argument, this command toggles the mode.
Non-null prefix argument turns on the mode.
Null prefix argument turns off the mode."
  ;; The initial value.
  nil
  ;; The indicator for the mode line.
  " Sensitive"
  ;; The minor mode bindings.
  nil
  (if (symbol-value sensitive-mode)
      (progn
    ;; disable backups
    (set (make-local-variable 'backup-inhibited) t)
    ;; disable auto-save
    (if auto-save-default
        (auto-save-mode -1)))
    ;resort to default value of backup-inhibited
    (kill-local-variable 'backup-inhibited)
    ;resort to default auto save setting
    (if auto-save-default
        (auto-save-mode 1))))

(setq auto-mode-alist
 (append '(("\\.gpg$" . sensitive-mode))
               auto-mode-alist))

Um mir das Leben etwas zu erleichtern, habe ich mir in die .emacs Datei einige Funktionen hineingeschrieben, die das vorhandene elpa-mirror Zielverzeichnis erst leert, bevor es mit dem aktuellen Stand gefüllt wird. Danach packe ich das ganze noch in eine zip Datei, um sie dann einfacher verteilen zu können.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Damit ich einfacher ein elpa-mirror anlegen kann. ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defcustom my/elpa-mirror-directory "/home/andreas/orgnotes/elpa-mirror"
  "Absolute path to the directory for ~elpamr-create-mirror-for-installed~."
  :type  '(string)
  :group 'elpa-mirror)

(defun my/delete-elpa-mirror-files ()
  "Removes all files in my elpa-mirror directory."
  (make-directory my/elpa-mirror-directory t)
  (setq fileslist (directory-files my/elpa-mirror-directory t "^[^.]" t))
  (while (car fileslist)
      (delete-file (car fileslist))
      (setq fileslist (cdr fileslist))))

(defun my/zip-dir-elpa-mirror ()
  "Zip the elpa-mirror directory to \".../elpa-mirror.zip\".  If
zip file already exists, it will be deleted."
  (setq zip-command "cd /home/andreas/orgnotes/ && rm -f /home/andreas/Downloads/elpa-mirror.zip && zip -r9 /home/andreas/Downloads/elpa-mirror.zip elpa-mirror/")
  (start-process-shell-command "zip-elpa-mirror" nil zip-command))

(defun my/run-elpa-mirror ()
  "If not already exists, creates destination directory as
defined in \"customize my/elpa-mirror-directory\".  Afterwards
old content will be removed, and the command to generate new
content will be executed.  After all the destination directory
will be zipped.  See \"my/zip-dir-elpa-mirror\" for this."
  (interactive)
  (my/delete-elpa-mirror-files)
  (setq elpamr-default-output-directory my/elpa-mirror-directory)
  (elpamr-create-mirror-for-installed)
  (my/zip-dir-elpa-mirror))

Dieses Skript parsed alles Links im Puffer und listet sie.

  (defun my/list-links ()
    "Listet alle Links im aktuellen Puffer."
    (interactive)
    (let (setq *list-of-links* '())
      (save-excursion
        (goto-char (point-min))
        (while (re-search-forward "\\[\\(http.*?\\)]" nil t)
          (add-to-list '*list-of-links*
                       (match-string 1)
                       t)))
      (insert "\n")
      (dolist (link *list-of-links*)
        (insert "1. " link "\n"))))

my/list-links

Nach dem Exportieren der Agenda Dateien in eine ics Datei, kann deren Inhalt in einem PIM (Outlook, Kontact, etc.) angezeigt werden. Damit der Inhalt meiner Agenda bei jedem Sichern automatisch in die ~/org.ics Datei geschrieben wird, nutze ich die hook Funktion after-save-hook. Zusatzlich habe ich mir die Funktion auf die Tastenkombination C-c F gelegt.

  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;; Write ~/org.ics, a icalendar file of combined agenda files. ;;
  ;; Do this each time the file will be saved.                   ;;
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  (global-set-key (kbd "C-c F") 'org-icalendar-combine-agenda-files)

  (add-hook 'after-save-hook
            (lambda ()
              (if (equal "aufgaben.org" (file-name-nondirectory buffer-file-name))
                  (org-icalendar-combine-agenda-files)
                nil)))

Immer wenn man in vielen Dateien mehrere Strings verändern muss, kann es praktisch sein, dies als emacs-lisp Funktion zu verwirklichen. Einmal gebaut, kann diese Funktion schnell angepasst, und mit C-c C-c aktualisiert werden.

  (defun my/search-n-replace()
    (interactive)
    (setq to-replace (make-hash-table :test 'equal))
    (puthash "search" "replace" to-replace)
    (puthash "suchen" "ersetzen" to-replace)
    (maphash (lambda (orig replace)
               (save-excursion
                 (goto-char 0)
                 (while (re-search-forward orig nil t nil)
                   (replace-match replace nil t)))
               ) to-replace))

  (defun my/search-n-add()
    (interactive)
    (setq to-replace (make-hash-table :test 'equal))
    (puthash "search" " add" to-replace)
    (puthash "suchen" " und dran hängen" to-replace)
    (maphash (lambda (orig replace)
               (save-excursion
                 (goto-char 0)
                 (while (re-search-forward orig nil t nil)
                   (insert replace)))
               ) to-replace))