Ce qui est dans votre.emacs?

mon snippet préféré. L'ultime dans Emacs bonbons pour les yeux:

;; real lisp hackers use the lambda character
;; courtesy of stefan monnier on c.l.l
(defun sm-lambda-mode-hook ()
  (font-lock-add-keywords
   nil `(("\<lambda\>"
   (0 (progn (compose-region (match-beginning 0) (match-end 0)
        ,(make-char 'greek-iso8859-7 107))
      nil))))))
(add-hook 'emacs-lisp-mode-hook 'sm-lambda-mode-hook)
(add-hook 'lisp-interactive-mode-hook 'sm-lamba-mode-hook)
(add-hook 'scheme-mode-hook 'sm-lambda-mode-hook)

vous voyez donc ce qui suit lors de l'édition de lisp / scheme:

(global-set-key "^Cr" '(λ () (interactive) (revert-buffer t t nil)))

j'ai cette modification yes ou no invite y ou n invites:

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

j'ai ceux-ci pour démarrer Emacs sans tellement de" fanfare "que j'ai eu de cette question .

(setq inhibit-startup-echo-area-message t)
(setq inhibit-startup-message t)

et la fonction de Steve Yegge pour renommer un fichier que vous éditez avec son buffer correspondant:

(defun rename-file-and-buffer (new-name)
  "Renames both current buffer and file it's visiting to NEW-NAME."
  (interactive "sNew name: ")
  (let ((name (buffer-name))
 (filename (buffer-file-name)))
    (if (not filename)
 (message "Buffer '%s' is not visiting a file!" name)
      (if (get-buffer new-name)
   (message "A buffer named '%s' already exists!" new-name)
 (progn
   (rename-file name new-name 1)
   (rename-buffer new-name)
   (set-visited-file-name new-name)
   (set-buffer-modified-p nil))))))

Une chose qui peut s'avérer très utile: Avant qu'il soit trop gros, essayez de le diviser en plusieurs fichiers pour diverses tâches: Mon .emacs ne fait que définir mon chemin de chargement et les chargements d'un tas de fichiers- j'ai tous les réglages spécifiques à mon mode dans mode-configs.el , les reliures de touches dans keys.el , et cetera

My .emacs est seulement 127 lignes, voici les plus utiles bribes:

;; keep backup files neatly out of the way in .~/
(setq backup-directory-alist '(("." . ".~")))

Cela fait que les fichiers *~ que je trouve encombrants dans le répertoire vont dans un répertoire spécial, dans ce cas .~

;; uniquify changes conflicting buffer names from file<2> etc
(require 'uniquify)
(setq uniquify-buffer-name-style 'reverse)
(setq uniquify-separator "/")
(setq uniquify-after-kill-buffer-p t) ; rename after killing uniquified
(setq uniquify-ignore-buffers-re "^\*") ; don't muck with special buffers

cela crée uniquify qui modifie le fichier<2> etc. les noms de tampon que vous obtenez lorsque plusieurs fichiers ont le même nom dans un nom beaucoup plus clair et non ambigu en utilisant autant de l'ensemble du chemin du fichier qu'il doit.

c'est à peu près tout... le reste est assez classique, je suis sûr que tout le monde le sait.

ce n'est pas tout le kit et kaboodle, mais c'est quelques-uns des extraits les plus utiles que j'ai recueillis:

(defadvice show-paren-function (after show-matching-paren-offscreen
                                      activate)
  "If the matching paren is offscreen, show the matching line in the                               
echo area. Has no effect if the character before point is not of                                   
the syntax class ')'."
  (interactive)
  (let ((matching-text nil))
    ;; Only call `blink-matching-open' if the character before point                               
    ;; is a close parentheses type character. Otherwise, there's not                               
    ;; really any point, and `blink-matching-open' would just echo                                 
    ;; "Mismatched parentheses", which gets really annoying.                                       
    (if (char-equal (char-syntax (char-before (point))) ?\))
        (setq matching-text (blink-matching-open)))
    (if (not (null matching-text))
        (message matching-text))))

;;;;;;;;;;;;;;;
;; UTF-8
;;;;;;;;;;;;;;;;;;;;
;; set up unicode
(prefer-coding-system       'utf-8)
(set-default-coding-systems 'utf-8)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
;; This from a japanese individual.  I hope it works.
(setq default-buffer-file-coding-system 'utf-8)
;; From Emacs wiki
(setq x-select-request-type '(UTF8_STRING COMPOUND_TEXT TEXT STRING))
;; Wwindows clipboard is UTF-16LE 
(set-clipboard-coding-system 'utf-16le-dos)


(defun jonnay-timestamp ()
  "Spit out the current time"
  (interactive)
  (insert (format-time-string "%Y-%m-%d")))

(defun jonnay-sign ()
  "spit out my name, email and the current time"
  (interactive)
  (insert "-- Jonathan Arkell (jonathana@criticalmass.com)")
  (jonnay-timestamp))


;; Cygwin requires some seriosu setting up to work the way i likes it
(message "Setting up Cygwin...")
(let* ((cygwin-root "c:")
       (cygwin-bin (concat cygwin-root "/bin"))
       (gambit-bin "/usr/local/Gambit-C/4.0b22/bin/")
       (snow-bin "/usr/local/snow/current/bin")
       (mysql-bin "/wamp/bin/mysql/mysql5.0.51a/bin/"))
   (setenv "PATH" (concat cygwin-bin ";" ;
                          snow-bin ";" 
                          gambit-bin ";"
                          mysql-bin ";"
                          ".;")  
           (getenv "PATH"))
   (setq exec-path (cons cygwin-bin exec-path)))

(setq shell-file-name "bash")
(setq explicit-shell-file-name "bash")

(require 'cygwin-mount)
(cygwin-mount-activate)
(message "Setting up Cygwin...Done")


; Completion isn't perfect, but close
(defun my-shell-setup ()
   "For Cygwin bash under Emacs 20+"
   (setq comint-scroll-show-maximum-output 'this)
   (setq comint-completion-addsuffix t)
   (setq comint-eol-on-send t)
   (setq w32-quote-process-args ?\")
   (make-variable-buffer-local 'comint-completion-addsuffix))

(setq shell-mode-hook 'my-shell-setup)
(add-hook 'emacs-startup-hook 'cygwin-shell)


; Change how home key works
(global-set-key [home] 'beginning-or-indentation)
(substitute-key-definition 'beginning-of-line 'beginning-or-indentation global-map)


(defun yank-and-down ()
  "Yank the text and go down a line."
  (interactive)
  (yank)
  (exchange-point-and-mark)
  (next-line))

(defun kill-syntax (&optional arg)
  "Kill ARG sets of syntax characters after point."
  (interactive "p")
  (let ((arg (or arg 1))
    (inc (if (and arg (< arg 0)) 1 -1))
    (opoint (point)))
    (while (not (= arg 0))
      (if (> arg 0)
      (skip-syntax-forward (string (char-syntax (char-after))))
    (skip-syntax-backward (string (char-syntax (char-before)))))
      (setq arg (+ arg inc)))
    (kill-region opoint (point))))

(defun kill-syntax-backward (&optional arg)
  "Kill ARG sets of syntax characters preceding point."
  (interactive "p")
  (kill-syntax (- 0 (or arg 1))))

(global-set-key [(control shift y)] 'yank-and-down)
(global-set-key [(shift backspace)] 'kill-syntax-backward)
(global-set-key [(shift delete)] 'kill-syntax)


(defun insert-file-name (arg filename)
  "Insert name of file FILENAME into buffer after point.
  Set mark after the inserted text.

  Prefixed with \[universal-argument], expand the file name to
  its fully canocalized path.

  See `expand-file-name'."
  ;; Based on insert-file in Emacs -- ashawley 2008-09-26
  (interactive "*P\nfInsert file name: ")
  (if arg
      (insert (expand-file-name filename))
      (insert filename)))

(defun kill-ring-save-filename ()
  "Copy the current filename to the kill ring"
  (interactive)
  (kill-new (buffer-file-name)))

(defun insert-file-name ()
  "Insert the name of the current file."
  (interactive)
  (insert (buffer-file-name)))

(defun insert-directory-name ()
  "Insert the name of the current directory"
  (interactive)
  (insert (file-name-directory (buffer-file-name))))

(defun jonnay-toggle-debug ()
  "Toggle debugging by toggling icicles, and debug on error"
  (interactive)
  (toggle-debug-on-error)
  (icicle-mode))


(defvar programming-modes
  '(emacs-lisp-mode scheme-mode lisp-mode c-mode c++-mode 
    objc-mode latex-mode plain-tex-mode java-mode
    php-mode css-mode js2-mode nxml-mode nxhtml-mode)
  "List of modes related to programming")

; Text-mate style indenting
(defadvice yank (after indent-region activate)
  (if (member major-mode programming-modes)
      (indent-region (region-beginning) (region-end) nil)))

j'ai beaucoup d'autres, qui ont déjà été mentionnées, mais elles sont absolument nécessaires à mon avis:

(transient-mark-mode 1) ; makes the region visible
(line-number-mode 1)    ; makes the line number show up
(column-number-mode 1)  ; makes the column number show up

vous pouvez regarder ici: http://www.dotemacs.de/

et mon.emacs est assez long pour le mettre ici aussi, donc il va rendre la réponse pas trop lisible. De toute façon, si vous le souhaitez, je peux vous l'a envoyé.

je vous recommande aussi de lire ceci: http://steve.yegge.googlepages.com/my-dot-emacs-file

voici quelques mappages clés dont je suis devenu dépendant:

(global-set-key [(control \,)] 'goto-line)
(global-set-key [(control \.)] 'call-last-kbd-macro)
(global-set-key [(control tab)] 'indent-region)
(global-set-key [(control j)] 'join-line)
(global-set-key [f1] 'man)
(global-set-key [f2] 'igrep-find)
(global-set-key [f3] 'isearch-forward)
(global-set-key [f4] 'next-error)
(global-set-key [f5] 'gdb)
(global-set-key [f6] 'compile)
(global-set-key [f7] 'recompile)
(global-set-key [f8] 'shell)
(global-set-key [f9] 'find-next-matching-tag)
(global-set-key [f11] 'list-buffers)
(global-set-key [f12] 'shell)

quelques autres trucs divers, surtout pour le développement C++:

;; Use C++ mode for .h files (instead of plain-old C mode)
(setq auto-mode-alist (cons '("\.h$" . c++-mode) auto-mode-alist))

;; Use python-mode for SCons files
(setq auto-mode-alist (cons '("SConstruct" . python-mode) auto-mode-alist))
(setq auto-mode-alist (cons '("SConscript" . python-mode) auto-mode-alist))

;; Parse CppUnit failure reports in compilation-mode
(require 'compile)
(setq compilation-error-regexp-alist
      (cons '("\(!!!FAILURES!!!\nTest Results:\nRun:[^\n]*\n\n\n\)?\([0-9]+\)) test: \([^(]+\)(F) line: \([0-9]+\) \([^ \n]+\)" 5 4)
            compilation-error-regexp-alist))

;; Enable cmake-mode from http://www.cmake.org/Wiki/CMake_Emacs_mode_patch_for_comment_formatting
(require 'cmake-mode)
(setq auto-mode-alist
      (append '(("CMakeLists\.txt\'" . cmake-mode)
                ("\.cmake\'" . cmake-mode))
              auto-mode-alist))

;; "M-x reload-buffer" will revert-buffer without requiring confirmation
(defun reload-buffer ()
  "revert-buffer without confirmation"
  (interactive)
  (revert-buffer t t))

pour rafraîchir la page Web que vous éditez depuis Emacs

(defun moz-connect()
  (interactive)
  (make-comint "moz-buffer" (cons "127.0.0.1" "4242"))
  (global-set-key "\C-x\C-g" '(lambda () 
                (interactive)
                (save-buffer)
                (comint-send-string "*moz-buffer*" "this.BrowserReload()\n"))))

utilisé en combinaison avec http://hyperstruct.net/projects/mozlab

vous pouvez trouver ma configuration (à la fois en html et dans les archives tar'ed) sur mon site . Il contient beaucoup de paramètres pour les différents modes

ce bloc est le plus important pour moi:

(setq locale-coding-system 'utf-8)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
(set-selection-coding-system 'utf-8)
(prefer-coding-system 'utf-8)

je n'ai jamais été clair sur la différence entre ceux, cependant. Cargo cult, je suppose...

j'essaie de garder la mienne .emacs organisé. La configuration sera toujours un travail en cours, mais je commence à être satisfait de la structure globale.

All stuff est sous ~/.elisp , un répertoire qui est sous le contrôle des versions (j'utilise git, si cela est d'intérêt). ~/.emacs indique simplement ~/.elisp/dotemacs qui charge lui-même juste ~/.elisp/cfg/init . Ce fichier importe à son tour divers fichiers de configuration via require . Cela signifie que l' les fichiers de configuration doivent se comporter comme des modes: ils importent les choses dont ils dépendent et se provide à la fin du fichier, par exemple (provide 'my-ibuffer-cfg) . Je préfixe tous les identificateurs définis dans ma configuration avec my- .

j'organise la configuration en fonction des modes/sujets/tâches, et non par leurs implications techniques, p.ex. I don't ont un fichier de configuration séparé dans lequel tous keybindings ou les visages sont définis.

mon init.el définit le crochet suivant pour s'assurer Qu'Emacs recompile les fichiers de configuration à chaque fois qu'ils sont sauvegardés (elisp compilé se charge beaucoup plus rapidement mais je ne veux pas faire cette étape manuellement):

;; byte compile config file if changed
(add-hook 'after-save-hook
          '(lambda ()
                   (when (string-match
                          (concat (expand-file-name "~/.elisp/cfg/") ".*\.el$")
                          buffer-file-name)
           (byte-compile-file buffer-file-name))))

c'est la structure du répertoire pour ~/.elisp :

~/.elisp/todo.org : fichier Org-mode dans lequel je garde la trace des choses qui doivent encore être faites (+ éléments de liste de souhaits).

~/.elisp/dotemacs : cible Symlink pour ~/.emacs , charges ~/.elisp/cfg/init .

~/.elisp/cfg : mes propres fichiers de configuration.

~/.elisp/modes : Modes qui consistent uniquement en un seul fichier.

~/.elisp/packages : modes sophistiqués avec lisp, documentation et probablement des fichiers de ressources.

J'utilise GNU Emacs, cette version ne supporte pas vraiment les paquets. J'ai donc organiser manuellement, généralement comme cela: ~/.elisp/packages/foobar-0.1.3 est le répertoire racine du paquet. Le sous-répertoire lisp contient tous les fichiers lisp et info est la référence de la documentation. ~/.elisp/packages/foobar est un lien symbolique qui pointe vers la version actuellement utilisée du paquet de sorte que je n'ai pas besoin de changer mes fichiers de configuration lorsque je mets à jour quelque chose. Pour certains paquets, je garde un fichier ~/.elisp/packages/foobar.installation dans lequel je garde des notes sur le processus d'installation. Pour des raisons de performance, j'ai compilé tous les elisp les fichiers nouvellement installé les paquets, si ce n'est pas le cas par défaut.

voici quelques-unes de mes affaires:

Insère la date au format ISO 8601:

(defun insertdate ()
  (interactive)
  (insert (format-time-string "%Y-%m-%d")))

(global-set-key [(f5)] 'insertdate)

Pour les programmeurs en C++, crée un squelette de classe (nom de la classe sera le même que le nom du fichier sans l'extension):

(defun createclass ()
  (interactive)
  (setq classname (file-name-sans-extension (file-name-nondirectory   buffer-file-name)))
  (insert 
"/**
  * " classname".h 
  *
  * Author: Your Mom
  * Modified: " (format-time-string "%Y-%m-%d") "
  * Licence: GNU GPL
  */
#ifndef "(upcase classname)"
#define "(upcase classname)"

class " classname "
{
  public:
    "classname"();
    ~"classname"();

  private:

};
#endif
"))

crée automatiquement les parenthèses de fermeture:

(setq skeleton-pair t)
(setq skeleton-pair-on-word t)
(global-set-key (kbd "[") 'skeleton-pair-insert-maybe)
(global-set-key (kbd "(") 'skeleton-pair-insert-maybe)
(global-set-key (kbd "{") 'skeleton-pair-insert-maybe) 
(global-set-key (kbd "<") 'skeleton-pair-insert-maybe)

j'utilise paredit pour la manipulation facile (e)lisp et ido-mode minibuffer completions.

il est difficile de répondre à cette question, car tout le monde utilise Emacs à des fins très différentes.

de plus, une meilleure pratique pourrait être D'embrasser vos dotemacs. Puisque l'" Interface de personnalisation facile est largement supportée parmi les modes D'Emacs, vous devez stocker toute votre personnalisation dans votre custom-file (qui peut être une place séparée dans votre dotemacs), et pour le dotemacs , mettez dedans seulement les paramètres de chemin de charge, package requiert, des crochets, et les raccourcis clavier. Une fois que vous commencez à utiliser Emacs Starter Kit , tout un tas de paramètres utiles peuvent être supprimés de votre dotemacs, aussi.

voir la catégorie DotEmacs D'EmacsWiki. Il fournit beaucoup de liens vers des pages traitant de cette question.

(put 'erase-buffer 'disabled nil)
(put 'downcase-region 'disabled nil)
(set-variable 'visible-bell t)
(set-variable 'tool-bar-mode nil)
(set-variable 'menu-bar-mode nil)

(setq load-path (cons (expand-file-name "/usr/share/doc/git-core/contrib/emacs") load-path))
 (require 'vc-git)
 (when (featurep 'vc-git) (add-to-list 'vc-handled-backends 'git))
 (require 'git)
 (autoload 'git-blame-mode "git-blame"
           "Minor mode for incremental blame for Git." t)

j'ai mis en place quelques raccourcis pratiques pour les pages web et les recherches en utilisant webjump

(require 'webjump)
(global-set-key [f2] 'webjump)
(setq webjump-sites
      (append '(
        ("Reddit Search" .
         [simple-query "www.reddit.com" "http://www.reddit.com/search?q=" ""])
        ("Google Image Search" .
         [simple-query "images.google.com" "images.google.com/images?hl=en&q=" ""])
        ("Flickr Search" .
         [simple-query "www.flickr.com" "flickr.com/search/?q=" ""])
        ("Astar algorithm" . 
         "http://www.heyes-jones.com/astar")
        )
          webjump-sample-sites))

Blog post sur la façon dont cela fonctionne ici

http://justinsboringpage.blogspot.com/2009/02/search-reddit-flickr-and-google-from.html

je recommande aussi ceci:

(setq visible-bell t) ; no beeping

(setq transient-mark-mode t) ; visually show region

(setq line-number-mode t) ; show line numbers

(setq global-font-lock-mode 1) ; everything should use fonts

(setq font-lock-maximum-decoration t)

aussi je me débarrasse de certains des trucs GUI superflus

  (if (fboundp 'scroll-bar-mode) (scroll-bar-mode -1))
  (if (fboundp 'tool-bar-mode) (tool-bar-mode -1))
  (if (fboundp 'menu-bar-mode) (menu-bar-mode -1)))

une ligne pour modifier la trajectoire de charge Une ligne pour charger ma bibliothèque init Une ligne pour charger mes fichiers emacs init

bien sûr, les" emacs INIT files " sont assez nombreux, un par chose spécifique, chargés dans un ordre déterministe.

emacs-starter-kit comme base, puis j'ai ajouté.. vimpulse.el , whitespace.el , yasnippet , textmate.el et newsticker.el .

Dans mon ~/.emacs.d / $ USERNAME.el (dbr.el) dossier:

(add-to-list 'load-path (concat dotfiles-dir "/vendor/"))

;; Snippets
(add-to-list 'load-path "~/.emacs.d/vendor/yasnippet/")
(require 'yasnippet)

(yas/initialize)
(yas/load-directory "~/.emacs.d/vendor/yasnippet/snippets")

;; TextMate module
(require 'textmate)
(textmate-mode 'on)

;; Whitespace module
(require 'whitespace)
(add-hook 'ruby-mode-hook 'whitespace-mode)
(add-hook 'python-mode-hook 'whitespace-mode)

;; Misc
(flyspell-mode 'on)
(setq viper-mode t)
(require 'viper)
(require 'vimpulse)

;; IM
(eval-after-load 'rcirc '(require 'rcirc-color))
(setq rcirc-default-nick "_dbr")
(setq rcirc-default-user-name "_dbr")
(setq rcirc-default-user-full-name "_dbr")

(require 'jabber)

;;; Google Talk account
(custom-set-variables
 '(jabber-connection-type (quote ssl))
 '(jabber-network-server "talk.google.com")
 '(jabber-port 5223)
 '(jabber-server "mysite.tld")
 '(jabber-username "myusername"))

;; Theme
(color-theme-zenburn)

;; Key bindings
(global-set-key (kbd "M-z") 'undo)
(global-set-key (kbd "M-s") 'save-buffer)
(global-set-key (kbd "M-S-z") 'redo)

toujours sauvegarder ma config dans svn http://my-trac.assembla.com/ez-conf/browser/emacs.d

Après cette lecture, j'ai pensé qu'il serait bon d'avoir un site simple, juste pour le meilleur .modifications emacs. N'hésitez pas à poster et voter ici:

http://dotemacs.slinkset.com /

https://b7j0c.org/stuff/dotemacs.html

je suis nouveau à emacs ,dans mon.fichier emacs il y a

• indentation de configuration
• thème couleur
• mode php, mode café et mode js2
• mode ido

FWIW, my .emacs est ici:

http://svn.red-bean.com/repos/kfogel/trunk/.emacs

beaucoup de choses: https://github.com/tavisrudd/emacs.d

el-get a rendu la gestion des TI et des dépendances beaucoup plus facile: https://github.com/tavisrudd/emacs.d/blob/master/dss-init-el-get.el

pour Scala codeurs

;; Load the ensime lisp code... http://github.com/aemoncannon/ensime
(add-to-list 'load-path "ENSIME_ROOT/elisp/")
(require 'ensime)
;; This step causes the ensime-mode to be started whenever ;; scala-mode is started for a buffer. You may have to customize this step ;; if you're not using the standard scala mode.
(add-hook 'scala-mode-hook 'ensime-scala-mode-hook)
;; MINI HOWTO:  ;; Open .scala file. M-x ensime (once per project)

ma configuration emacs s'est développée au fil des années et j'ai beaucoup de choses utiles pour moi là-bas, mais si j'avais deux fonctions, ce serait probablement celles-là.

définit C-x vers le haut et C-x vers le bas pour déplacer la ligne courante ou vers le bas en gardant le curseur à la bonne place:

;Down/UP the current line
(global-set-key '[(control x) (up)] 'my-up-line)
(global-set-key '[(control x) (down)] 'my-down-line)
(defun my-down-line()
  (interactive)
  (let ((col (current-column)))
    (forward-line 1)
    (transpose-lines 1)
    (forward-line -1)
    (forward-char col)
    )
  )

(defun my-up-line()
  (interactive)
  (let ((col (current-column)))
    (transpose-lines 1)
    (forward-line -2)
    (forward-char col)
    )
  )