Bonjour,
Après avoir utilisé Emacs pour rédiger du code LaTeX avec AucTeX, je
viens de me mettre au HTML avec l'aide du html-helper-mode chargé
ainsi (si ça peut servir pour la suite) :
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
;;HTML
(define-key html-mode-map (kbd "RET") 'newline-and-indent))
(global-set-key (kbd "M-"") 'insert-french-quotes)
(global-set-key (kbd "C-"") 'insert-html-french-quotes)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Je viens à vous afin de savoir s'il était possible de faire en sorte
qu'un même raccourci clavier puisse produire une action différente
selon le mode dans lequel on se trouve : ainsi, le raccourci clavier
C-" pourrait produire des guillemets français que l'on soit en latex
ou en html. Je suppose que pour ce faire il faut mettre en place une
sorte de "condition" mais mes recherches ne m'ont pas vraiment
renseigné :/
Merci, à bientôt.
Bonjour,
Après avoir utilisé Emacs pour rédiger du code LaTeX avec AucTeX, je
viens de me mettre au HTML avec l'aide du html-helper-mode chargé
ainsi (si ça peut servir pour la suite) :
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
;;HTML
(define-key html-mode-map (kbd "RET") 'newline-and-indent))
(global-set-key (kbd "M-"") 'insert-french-quotes)
(global-set-key (kbd "C-"") 'insert-html-french-quotes)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Je viens à vous afin de savoir s'il était possible de faire en sorte
qu'un même raccourci clavier puisse produire une action différente
selon le mode dans lequel on se trouve : ainsi, le raccourci clavier
C-" pourrait produire des guillemets français que l'on soit en latex
ou en html. Je suppose que pour ce faire il faut mettre en place une
sorte de "condition" mais mes recherches ne m'ont pas vraiment
renseigné :/
Merci, à bientôt.
Bonjour,
Après avoir utilisé Emacs pour rédiger du code LaTeX avec AucTeX, je
viens de me mettre au HTML avec l'aide du html-helper-mode chargé
ainsi (si ça peut servir pour la suite) :
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
;;HTML
(define-key html-mode-map (kbd "RET") 'newline-and-indent))
(global-set-key (kbd "M-"") 'insert-french-quotes)
(global-set-key (kbd "C-"") 'insert-html-french-quotes)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Je viens à vous afin de savoir s'il était possible de faire en sorte
qu'un même raccourci clavier puisse produire une action différente
selon le mode dans lequel on se trouve : ainsi, le raccourci clavier
C-" pourrait produire des guillemets français que l'on soit en latex
ou en html. Je suppose que pour ce faire il faut mettre en place une
sorte de "condition" mais mes recherches ne m'ont pas vraiment
renseigné :/
Merci, à bientôt.
Le 29-07-2008, Astier a écrit :
Pour avoir des raccourcis adaptés aux modes, il ne faut pas les lais ser
se battre à coups de global-set-key :)
Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
(defun my-footnote ()
"Ouvre une footnote"
(interactive)
(search-backward-regexp "[])>».,[:alnum:]]")
(forward-char)
(insert "footnote{%n .}")
(newline-and-indent)
(beginning-of-line)
(backward-char 4))
(defun my-fraction ()
"Insère une fraction"
(interactive)
(insert "frac{}{}")
(backward-char 3))
(defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
> Merci, à bientôt.
de rien,
--
Jacques L'helgoualc'h
Le 29-07-2008, Astier a écrit :
Pour avoir des raccourcis adaptés aux modes, il ne faut pas les lais ser
se battre à coups de global-set-key :)
Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
(defun my-footnote ()
"Ouvre une footnote"
(interactive)
(search-backward-regexp "[])>».,[:alnum:]]")
(forward-char)
(insert "\footnote{%n .}")
(newline-and-indent)
(beginning-of-line)
(backward-char 4))
(defun my-fraction ()
"Insère une fraction"
(interactive)
(insert "\frac{}{}")
(backward-char 3))
(defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
> Merci, à bientôt.
de rien,
--
Jacques L'helgoualc'h
Le 29-07-2008, Astier a écrit :
Pour avoir des raccourcis adaptés aux modes, il ne faut pas les lais ser
se battre à coups de global-set-key :)
Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
(defun my-footnote ()
"Ouvre une footnote"
(interactive)
(search-backward-regexp "[])>».,[:alnum:]]")
(forward-char)
(insert "footnote{%n .}")
(newline-and-indent)
(beginning-of-line)
(backward-char 4))
(defun my-fraction ()
"Insère une fraction"
(interactive)
(insert "frac{}{}")
(backward-char 3))
(defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
> Merci, à bientôt.
de rien,
--
Jacques L'helgoualc'h
On 29 juil, 10:52, Jacques L'helgoualc'h <lhh+ wrote:Le 29-07-2008, Astier a écrit :
Pour avoir des raccourcis adaptés aux modes, il ne faut pas les laisser
se battre à coups de global-set-key :)
Arf...Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
(defun my-footnote ()
"Ouvre une footnote"
(interactive)
(search-backward-regexp "[])>».,[:alnum:]]")
(forward-char)
(insert "footnote{%n .}")
(newline-and-indent)
(beginning-of-line)
(backward-char 4))
(defun my-fraction ()
"Insère une fraction"
(interactive)
(insert "frac{}{}")
(backward-char 3))
(defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Ah oui c'est un peu plus "complexe" que je ne pensais :/ Je vais
essayer de faire ça.
Sinon, une autre solution consisterait à avoir plusieurs .emacs
portant chacun les spécificités des modes ; à moins que cette approche
soit totalement "ridicule" ou inutile ?
On 29 juil, 10:52, Jacques L'helgoualc'h <lhh+no_s...@free.fr> wrote:
Le 29-07-2008, Astier a écrit :
Pour avoir des raccourcis adaptés aux modes, il ne faut pas les laisser
se battre à coups de global-set-key :)
Arf...
Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
(defun my-footnote ()
"Ouvre une footnote"
(interactive)
(search-backward-regexp "[])>».,[:alnum:]]")
(forward-char)
(insert "\footnote{%n .}")
(newline-and-indent)
(beginning-of-line)
(backward-char 4))
(defun my-fraction ()
"Insère une fraction"
(interactive)
(insert "\frac{}{}")
(backward-char 3))
(defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Ah oui c'est un peu plus "complexe" que je ne pensais :/ Je vais
essayer de faire ça.
Sinon, une autre solution consisterait à avoir plusieurs .emacs
portant chacun les spécificités des modes ; à moins que cette approche
soit totalement "ridicule" ou inutile ?
On 29 juil, 10:52, Jacques L'helgoualc'h <lhh+ wrote:Le 29-07-2008, Astier a écrit :
Pour avoir des raccourcis adaptés aux modes, il ne faut pas les laisser
se battre à coups de global-set-key :)
Arf...Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
(defun my-footnote ()
"Ouvre une footnote"
(interactive)
(search-backward-regexp "[])>».,[:alnum:]]")
(forward-char)
(insert "footnote{%n .}")
(newline-and-indent)
(beginning-of-line)
(backward-char 4))
(defun my-fraction ()
"Insère une fraction"
(interactive)
(insert "frac{}{}")
(backward-char 3))
(defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Ah oui c'est un peu plus "complexe" que je ne pensais :/ Je vais
essayer de faire ça.
Sinon, une autre solution consisterait à avoir plusieurs .emacs
portant chacun les spécificités des modes ; à moins que cette approche
soit totalement "ridicule" ou inutile ?
Astier écrivait :On 29 juil, 10:52, Jacques L'helgoualc'h <lhh+ wrote:
Pour avoir des raccourcis adaptés aux modes, il ne faut pas les laisser
se battre à coups de global-set-key :)
Arf...Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
(defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Ah oui c'est un peu plus "complexe" que je ne pensais :/ Je vais
essayer de faire ça.
Sinon, une autre solution consisterait à avoir plusieurs .emacs
portant chacun les spécificités des modes ; à moins que cette approche
soit totalement "ridicule" ou inutile ?
S'il y a global-set-key, c'est aussi qu'il y a "local-set-key" qui
modifie la keymap pour le buffer uniquement. En mettant ces localset-key
dans le hook du mode, tout roule...
Astier écrivait :
On 29 juil, 10:52, Jacques L'helgoualc'h <lhh+no_s...@free.fr> wrote:
Pour avoir des raccourcis adaptés aux modes, il ne faut pas les laisser
se battre à coups de global-set-key :)
Arf...
Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
(defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Ah oui c'est un peu plus "complexe" que je ne pensais :/ Je vais
essayer de faire ça.
Sinon, une autre solution consisterait à avoir plusieurs .emacs
portant chacun les spécificités des modes ; à moins que cette approche
soit totalement "ridicule" ou inutile ?
S'il y a global-set-key, c'est aussi qu'il y a "local-set-key" qui
modifie la keymap pour le buffer uniquement. En mettant ces localset-key
dans le hook du mode, tout roule...
Astier écrivait :On 29 juil, 10:52, Jacques L'helgoualc'h <lhh+ wrote:
Pour avoir des raccourcis adaptés aux modes, il ne faut pas les laisser
se battre à coups de global-set-key :)
Arf...Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
(defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Ah oui c'est un peu plus "complexe" que je ne pensais :/ Je vais
essayer de faire ça.
Sinon, une autre solution consisterait à avoir plusieurs .emacs
portant chacun les spécificités des modes ; à moins que cette approche
soit totalement "ridicule" ou inutile ?
S'il y a global-set-key, c'est aussi qu'il y a "local-set-key" qui
modifie la keymap pour le buffer uniquement. En mettant ces localset-key
dans le hook du mode, tout roule...
Le 02-08-2008, Erwan David a écrit :Astier écrivait :On 29 juil, 10:52, Jacques L'helgoualc'h <lhh+ wrote:
[...]Pour avoir des raccourcis adaptés aux modes, il ne faut pas les laisser
se battre à coups de global-set-key :)
Arf...Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...](defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Ah oui c'est un peu plus "complexe" que je ne pensais :/ Je vais
essayer de faire ça.
Là, c'est à cause du sous-mode mathématique d'AucTeX, qui n'est actif
que dans certaines parties du buffer...Sinon, une autre solution consisterait à avoir plusieurs .emacs
portant chacun les spécificités des modes ; à moins que cette approche
soit totalement "ridicule" ou inutile ?
Tu peux faire ce que tu veux, avec plusieurs instances spécialisées
d'Emacs au besoin. Par exemple, pour accélérer l'appel de mon Éditeur
favori, j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
emacs -iconic -l ~/.elisp21/server.el &
qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
pour ne pas fermer l'Emacs serveur par inadvertance.S'il y a global-set-key, c'est aussi qu'il y a "local-set-key" qui
modifie la keymap pour le buffer uniquement. En mettant ces localset-key
dans le hook du mode, tout roule...
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Le 02-08-2008, Erwan David a écrit :
Astier écrivait :
On 29 juil, 10:52, Jacques L'helgoualc'h <lhh+no_s...@free.fr> wrote:
[...]
Pour avoir des raccourcis adaptés aux modes, il ne faut pas les laisser
se battre à coups de global-set-key :)
Arf...
Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...]
(defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Ah oui c'est un peu plus "complexe" que je ne pensais :/ Je vais
essayer de faire ça.
Là, c'est à cause du sous-mode mathématique d'AucTeX, qui n'est actif
que dans certaines parties du buffer...
Sinon, une autre solution consisterait à avoir plusieurs .emacs
portant chacun les spécificités des modes ; à moins que cette approche
soit totalement "ridicule" ou inutile ?
Tu peux faire ce que tu veux, avec plusieurs instances spécialisées
d'Emacs au besoin. Par exemple, pour accélérer l'appel de mon Éditeur
favori, j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
emacs -iconic -l ~/.elisp21/server.el &
qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
pour ne pas fermer l'Emacs serveur par inadvertance.
S'il y a global-set-key, c'est aussi qu'il y a "local-set-key" qui
modifie la keymap pour le buffer uniquement. En mettant ces localset-key
dans le hook du mode, tout roule...
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Le 02-08-2008, Erwan David a écrit :Astier écrivait :On 29 juil, 10:52, Jacques L'helgoualc'h <lhh+ wrote:
[...]Pour avoir des raccourcis adaptés aux modes, il ne faut pas les laisser
se battre à coups de global-set-key :)
Arf...Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...](defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Ah oui c'est un peu plus "complexe" que je ne pensais :/ Je vais
essayer de faire ça.
Là, c'est à cause du sous-mode mathématique d'AucTeX, qui n'est actif
que dans certaines parties du buffer...Sinon, une autre solution consisterait à avoir plusieurs .emacs
portant chacun les spécificités des modes ; à moins que cette approche
soit totalement "ridicule" ou inutile ?
Tu peux faire ce que tu veux, avec plusieurs instances spécialisées
d'Emacs au besoin. Par exemple, pour accélérer l'appel de mon Éditeur
favori, j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
emacs -iconic -l ~/.elisp21/server.el &
qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
pour ne pas fermer l'Emacs serveur par inadvertance.S'il y a global-set-key, c'est aussi qu'il y a "local-set-key" qui
modifie la keymap pour le buffer uniquement. En mettant ces localset-key
dans le hook du mode, tout roule...
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...](defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Sinon, une autre solution consisterait à avoir plusieurs .emacs
portant chacun les spécificités des modes ; à moins que cette approche
soit totalement "ridicule" ou inutile ?
Tu peux faire ce que tu veux, avec plusieurs instances spécialisées
d'Emacs au besoin. Par exemple, pour accélérer l'appel de mon Éditeur
favori, j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
emacs -iconic -l ~/.elisp21/server.el &
qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
pour ne pas fermer l'Emacs serveur par inadvertance.
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...]
(defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Sinon, une autre solution consisterait à avoir plusieurs .emacs
portant chacun les spécificités des modes ; à moins que cette approche
soit totalement "ridicule" ou inutile ?
Tu peux faire ce que tu veux, avec plusieurs instances spécialisées
d'Emacs au besoin. Par exemple, pour accélérer l'appel de mon Éditeur
favori, j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
emacs -iconic -l ~/.elisp21/server.el &
qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
pour ne pas fermer l'Emacs serveur par inadvertance.
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...](defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Sinon, une autre solution consisterait à avoir plusieurs .emacs
portant chacun les spécificités des modes ; à moins que cette approche
soit totalement "ridicule" ou inutile ?
Tu peux faire ce que tu veux, avec plusieurs instances spécialisées
d'Emacs au besoin. Par exemple, pour accélérer l'appel de mon Éditeur
favori, j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
emacs -iconic -l ~/.elisp21/server.el &
qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
pour ne pas fermer l'Emacs serveur par inadvertance.
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Astier a écrit :
Bonjour,
Désolé de "déterrer" ce topic, mais j'ai pris le temps de me mettre les
mains dans le cambouis.Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...](defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Donc, si je comprends bien, il faudrait que je fasse un truc dans le genre :
#####
(define-key LaTeX-mode-map (kbd "M-"") 'franguill')
(define-key html-mode-map (kbd "M-"") 'franguill')
(defun franguill ()
"Insère des guillemets français"
(interactive)
(insert "og fg{}")
(backward-char 5))
#####
à moins qu'il faille passer par une condition ?
[...] j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
ok, donc, gnuclient appartient au paquet gnuserv que je viens d'installer.
je suppose que le fichier ~/.xsession est chargé lors du lancement d'une
session graphique ?
Si c'est bien le cas, comment cela se passe lorsque
l'on travaille dans les tty ?
emacs -iconic -l ~/.elisp21/server.el &
donc on lance un serveur Emacs. Pour lancer emacs par la suite, il
suffit d'appeler emacs ou d'utiliser les lanceurs traditionnels ---
celui de mon tableau de bord correspond à /usr/bin/emacs22 ?
qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
euh... c'est bien un fichier "externe", qui se trouve ici :
~/.elisp21/server.el --- dans mon cas ~/.elisp22/server.el puisque j'ai
emacs22 (ou ça ne change rien) ?
De plus, si je me crée plusieurs ~/.emacs --- par exemple ~/.emacstex et
~/.emacshtml, comment faire pour les appeler au juste ? J'ai regardé
dans le man d'emacs et il ne m'a pas semblé voir d'option permettant de
choisir l'init file.
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Là j'ai du mal à saisir...
Merci pour vos éclaircissements,
A bientôt.
Astier a écrit :
Bonjour,
Désolé de "déterrer" ce topic, mais j'ai pris le temps de me mettre les
mains dans le cambouis.
Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...]
(defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Donc, si je comprends bien, il faudrait que je fasse un truc dans le genre :
#####
(define-key LaTeX-mode-map (kbd "M-"") 'franguill')
(define-key html-mode-map (kbd "M-"") 'franguill')
(defun franguill ()
"Insère des guillemets français"
(interactive)
(insert "\og \fg{}")
(backward-char 5))
#####
à moins qu'il faille passer par une condition ?
[...] j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
ok, donc, gnuclient appartient au paquet gnuserv que je viens d'installer.
je suppose que le fichier ~/.xsession est chargé lors du lancement d'une
session graphique ?
Si c'est bien le cas, comment cela se passe lorsque
l'on travaille dans les tty ?
emacs -iconic -l ~/.elisp21/server.el &
donc on lance un serveur Emacs. Pour lancer emacs par la suite, il
suffit d'appeler emacs ou d'utiliser les lanceurs traditionnels ---
celui de mon tableau de bord correspond à /usr/bin/emacs22 ?
qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
euh... c'est bien un fichier "externe", qui se trouve ici :
~/.elisp21/server.el --- dans mon cas ~/.elisp22/server.el puisque j'ai
emacs22 (ou ça ne change rien) ?
De plus, si je me crée plusieurs ~/.emacs --- par exemple ~/.emacstex et
~/.emacshtml, comment faire pour les appeler au juste ? J'ai regardé
dans le man d'emacs et il ne m'a pas semblé voir d'option permettant de
choisir l'init file.
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Là j'ai du mal à saisir...
Merci pour vos éclaircissements,
A bientôt.
Astier a écrit :
Bonjour,
Désolé de "déterrer" ce topic, mais j'ai pris le temps de me mettre les
mains dans le cambouis.Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...](defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Donc, si je comprends bien, il faudrait que je fasse un truc dans le genre :
#####
(define-key LaTeX-mode-map (kbd "M-"") 'franguill')
(define-key html-mode-map (kbd "M-"") 'franguill')
(defun franguill ()
"Insère des guillemets français"
(interactive)
(insert "og fg{}")
(backward-char 5))
#####
à moins qu'il faille passer par une condition ?
[...] j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
ok, donc, gnuclient appartient au paquet gnuserv que je viens d'installer.
je suppose que le fichier ~/.xsession est chargé lors du lancement d'une
session graphique ?
Si c'est bien le cas, comment cela se passe lorsque
l'on travaille dans les tty ?
emacs -iconic -l ~/.elisp21/server.el &
donc on lance un serveur Emacs. Pour lancer emacs par la suite, il
suffit d'appeler emacs ou d'utiliser les lanceurs traditionnels ---
celui de mon tableau de bord correspond à /usr/bin/emacs22 ?
qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
euh... c'est bien un fichier "externe", qui se trouve ici :
~/.elisp21/server.el --- dans mon cas ~/.elisp22/server.el puisque j'ai
emacs22 (ou ça ne change rien) ?
De plus, si je me crée plusieurs ~/.emacs --- par exemple ~/.emacstex et
~/.emacshtml, comment faire pour les appeler au juste ? J'ai regardé
dans le man d'emacs et il ne m'a pas semblé voir d'option permettant de
choisir l'init file.
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Là j'ai du mal à saisir...
Merci pour vos éclaircissements,
A bientôt.
Astier a écrit :
Bonjour,
Désolé de "déterrer" ce topic, mais j'ai pris le temps de me mettre les
mains dans le cambouis.Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...](defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Donc, si je comprends bien, il faudrait que je fasse un truc dans le genre :
#####
(define-key LaTeX-mode-map (kbd "M-"") 'franguill')
(define-key html-mode-map (kbd "M-"") 'franguill')
(defun franguill ()
"Insère des guillemets français"
(interactive)
(insert "og fg{}")
(backward-char 5))
#####
à moins qu'il faille passer par une condition ?
[...] j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
ok, donc, gnuclient appartient au paquet gnuserv que je viens d'installer.
je suppose que le fichier ~/.xsession est chargé lors du lancement d'une
session graphique ?
Si c'est bien le cas, comment cela se passe lorsque
l'on travaille dans les tty ?
emacs -iconic -l ~/.elisp21/server.el &
donc on lance un serveur Emacs. Pour lancer emacs par la suite, il
suffit d'appeler emacs ou d'utiliser les lanceurs traditionnels ---
celui de mon tableau de bord correspond à /usr/bin/emacs22 ?
qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
euh... c'est bien un fichier "externe", qui se trouve ici :
~/.elisp21/server.el --- dans mon cas ~/.elisp22/server.el puisque j'ai
emacs22 (ou ça ne change rien) ?
De plus, si je me crée plusieurs ~/.emacs --- par exemple ~/.emacstex et
~/.emacshtml, comment faire pour les appeler au juste ? J'ai regardé
dans le man d'emacs et il ne m'a pas semblé voir d'option permettant de
choisir l'init file.
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Là j'ai du mal à saisir...
Merci pour vos éclaircissements,
A bientôt.
Astier a écrit :
Bonjour,
Désolé de "déterrer" ce topic, mais j'ai pris le temps de me mettre les
mains dans le cambouis.
Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...]
(defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Donc, si je comprends bien, il faudrait que je fasse un truc dans le genre :
#####
(define-key LaTeX-mode-map (kbd "M-"") 'franguill')
(define-key html-mode-map (kbd "M-"") 'franguill')
(defun franguill ()
"Insère des guillemets français"
(interactive)
(insert "\og \fg{}")
(backward-char 5))
#####
à moins qu'il faille passer par une condition ?
[...] j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
ok, donc, gnuclient appartient au paquet gnuserv que je viens d'installer.
je suppose que le fichier ~/.xsession est chargé lors du lancement d'une
session graphique ?
Si c'est bien le cas, comment cela se passe lorsque
l'on travaille dans les tty ?
emacs -iconic -l ~/.elisp21/server.el &
donc on lance un serveur Emacs. Pour lancer emacs par la suite, il
suffit d'appeler emacs ou d'utiliser les lanceurs traditionnels ---
celui de mon tableau de bord correspond à /usr/bin/emacs22 ?
qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
euh... c'est bien un fichier "externe", qui se trouve ici :
~/.elisp21/server.el --- dans mon cas ~/.elisp22/server.el puisque j'ai
emacs22 (ou ça ne change rien) ?
De plus, si je me crée plusieurs ~/.emacs --- par exemple ~/.emacstex et
~/.emacshtml, comment faire pour les appeler au juste ? J'ai regardé
dans le man d'emacs et il ne m'a pas semblé voir d'option permettant de
choisir l'init file.
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Là j'ai du mal à saisir...
Merci pour vos éclaircissements,
A bientôt.
Astier a écrit :
Bonjour,
Désolé de "déterrer" ce topic, mais j'ai pris le temps de me mettre les
mains dans le cambouis.Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...](defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Donc, si je comprends bien, il faudrait que je fasse un truc dans le genre :
#####
(define-key LaTeX-mode-map (kbd "M-"") 'franguill')
(define-key html-mode-map (kbd "M-"") 'franguill')
(defun franguill ()
"Insère des guillemets français"
(interactive)
(insert "og fg{}")
(backward-char 5))
#####
à moins qu'il faille passer par une condition ?
[...] j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
ok, donc, gnuclient appartient au paquet gnuserv que je viens d'installer.
je suppose que le fichier ~/.xsession est chargé lors du lancement d'une
session graphique ?
Si c'est bien le cas, comment cela se passe lorsque
l'on travaille dans les tty ?
emacs -iconic -l ~/.elisp21/server.el &
donc on lance un serveur Emacs. Pour lancer emacs par la suite, il
suffit d'appeler emacs ou d'utiliser les lanceurs traditionnels ---
celui de mon tableau de bord correspond à /usr/bin/emacs22 ?
qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
euh... c'est bien un fichier "externe", qui se trouve ici :
~/.elisp21/server.el --- dans mon cas ~/.elisp22/server.el puisque j'ai
emacs22 (ou ça ne change rien) ?
De plus, si je me crée plusieurs ~/.emacs --- par exemple ~/.emacstex et
~/.emacshtml, comment faire pour les appeler au juste ? J'ai regardé
dans le man d'emacs et il ne m'a pas semblé voir d'option permettant de
choisir l'init file.
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Là j'ai du mal à saisir...
Merci pour vos éclaircissements,
A bientôt.
bonjour,
Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...](defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Donc, si je comprends bien, il faudrait que je fasse un truc dans le genre :
#####
(define-key LaTeX-mode-map (kbd "M-"") 'franguill')
(define-key html-mode-map (kbd "M-"") 'franguill')
(defun franguill ()
"Insère des guillemets français"
(interactive)
(insert "og fg{}")
(backward-char 5))
#####
à moins qu'il faille passer par une condition ?
Heu, la fonction « franguill » est spécifique à (La)TeX, en html il en
faudrait une autre... mon exemple conditionnel concerne deux parties
d'un /même/ buffer en mode LaTeX.
[...] j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
ok, donc, gnuclient appartient au paquet gnuserv que je viens d'installer.
je suppose que le fichier ~/.xsession est chargé lors du lancement d'une
session graphique ?
Oui.Si c'est bien le cas, comment cela se passe lorsque
l'on travaille dans les tty ?
ça ne marche pas (avec emacs 21). Il me semble que ça pourrait le faire
avec une version plus récente ?
emacs -iconic -l ~/.elisp21/server.el &
donc on lance un serveur Emacs. Pour lancer emacs par la suite, il
suffit d'appeler emacs ou d'utiliser les lanceurs traditionnels ---
celui de mon tableau de bord correspond à /usr/bin/emacs22 ?
Voilà : un Emacs indépendant ne charge pas le bout de code serveur.qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
euh... c'est bien un fichier "externe", qui se trouve ici :
~/.elisp21/server.el --- dans mon cas ~/.elisp22/server.el puisque j'ai
emacs22 (ou ça ne change rien) ?
Ça dépend de ce que l'on met dans son ~/.emacs...
J'ai préféré séparer ces répertoires suivant les versions, d'autant que
les *.el doivent être byte-compilés avec la version utilisée.
Mon ~/.emacs, lui, est tout petit, et n'a pas besoin de l'être :
;;; -*-emacs-lisp-*-
(setq debug-on-error t)
(setq message-log-max 300)
(cond
((= emacs-major-version 21) (add-to-list 'load-path (expand-file-name "~/.elisp21")))
((= emacs-major-version 22) (add-to-list 'load-path (expand-file-name "~/.elisp22")))
( t (add-to-list 'load-path (expand-file-name "~/.elisp"))))
(setq custom-file "~/.custom") ;; il faudra sans doute distinguer selon
;; la version aussi...
(if (> emacs-major-version 20)
(load custom-file))
(load-library "emacs") ;; charge un de mes ~/.elisp2?/emacs.el
Tout à la fin de ce(s) dernier(s), j'ai un
(require 'trucs)
qui charge trucs.el, pour éviter de byte-compiler à chaque essai le
fichier principal
De plus, si je me crée plusieurs ~/.emacs --- par exemple ~/.emacstex et
~/.emacshtml, comment faire pour les appeler au juste ? J'ai regardé
dans le man d'emacs et il ne m'a pas semblé voir d'option permettant de
choisir l'init file.
Ben, tu peux utiliser les options
--no-init-file, -q load neither ~/.emacs nor default.el
et
--load, -l FILE load FILE of Emacs Lisp code using the load function
pour charger ~/.montrucenplumes.el, mais pour un mode particulier, le
plus simple est d'avoir des fichiers dédiés, chargés en cas de besoin :
;;; blank-mode
(autoload 'blank-mode "blank-mode"
"Toggle blank visualization." t)
(autoload 'blank-mode-customize "blank-mode"
"Customize blank visualization." t)
(global-set-key [f6] 'blank-mode)
À l'appel d'une des fonctions « 'blank-mode... », le fichier
"blank-mode" (.el, voire .elc) sera chargé (si besoin (et s'il
est trouvé dans le load-path)).
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Là j'ai du mal à saisir...
J'ai rassemblé dans la fonction my-LaTeX-init mes nombreuses
définitions, initialisations, etc. ne concernant qu'AUCTeX...
Le « eval-after-load » ne l'exécutera qu'une fois.
Merci pour vos éclaircissements,
De rien, ça me permet de faire améliorer/remplacer mes bouts de code
(souvent pêchés ailleurs...) par les autres contributeurs.A bientôt.
Au plaisir,
bonjour,
Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...]
(defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Donc, si je comprends bien, il faudrait que je fasse un truc dans le genre :
#####
(define-key LaTeX-mode-map (kbd "M-"") 'franguill')
(define-key html-mode-map (kbd "M-"") 'franguill')
(defun franguill ()
"Insère des guillemets français"
(interactive)
(insert "\og \fg{}")
(backward-char 5))
#####
à moins qu'il faille passer par une condition ?
Heu, la fonction « franguill » est spécifique à (La)TeX, en html il en
faudrait une autre... mon exemple conditionnel concerne deux parties
d'un /même/ buffer en mode LaTeX.
[...] j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
ok, donc, gnuclient appartient au paquet gnuserv que je viens d'installer.
je suppose que le fichier ~/.xsession est chargé lors du lancement d'une
session graphique ?
Oui.
Si c'est bien le cas, comment cela se passe lorsque
l'on travaille dans les tty ?
ça ne marche pas (avec emacs 21). Il me semble que ça pourrait le faire
avec une version plus récente ?
emacs -iconic -l ~/.elisp21/server.el &
donc on lance un serveur Emacs. Pour lancer emacs par la suite, il
suffit d'appeler emacs ou d'utiliser les lanceurs traditionnels ---
celui de mon tableau de bord correspond à /usr/bin/emacs22 ?
Voilà : un Emacs indépendant ne charge pas le bout de code serveur.
qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
euh... c'est bien un fichier "externe", qui se trouve ici :
~/.elisp21/server.el --- dans mon cas ~/.elisp22/server.el puisque j'ai
emacs22 (ou ça ne change rien) ?
Ça dépend de ce que l'on met dans son ~/.emacs...
J'ai préféré séparer ces répertoires suivant les versions, d'autant que
les *.el doivent être byte-compilés avec la version utilisée.
Mon ~/.emacs, lui, est tout petit, et n'a pas besoin de l'être :
;;; -*-emacs-lisp-*-
(setq debug-on-error t)
(setq message-log-max 300)
(cond
((= emacs-major-version 21) (add-to-list 'load-path (expand-file-name "~/.elisp21")))
((= emacs-major-version 22) (add-to-list 'load-path (expand-file-name "~/.elisp22")))
( t (add-to-list 'load-path (expand-file-name "~/.elisp"))))
(setq custom-file "~/.custom") ;; il faudra sans doute distinguer selon
;; la version aussi...
(if (> emacs-major-version 20)
(load custom-file))
(load-library "emacs") ;; charge un de mes ~/.elisp2?/emacs.el
Tout à la fin de ce(s) dernier(s), j'ai un
(require 'trucs)
qui charge trucs.el, pour éviter de byte-compiler à chaque essai le
fichier principal
De plus, si je me crée plusieurs ~/.emacs --- par exemple ~/.emacstex et
~/.emacshtml, comment faire pour les appeler au juste ? J'ai regardé
dans le man d'emacs et il ne m'a pas semblé voir d'option permettant de
choisir l'init file.
Ben, tu peux utiliser les options
--no-init-file, -q load neither ~/.emacs nor default.el
et
--load, -l FILE load FILE of Emacs Lisp code using the load function
pour charger ~/.montrucenplumes.el, mais pour un mode particulier, le
plus simple est d'avoir des fichiers dédiés, chargés en cas de besoin :
;;; blank-mode
(autoload 'blank-mode "blank-mode"
"Toggle blank visualization." t)
(autoload 'blank-mode-customize "blank-mode"
"Customize blank visualization." t)
(global-set-key [f6] 'blank-mode)
À l'appel d'une des fonctions « 'blank-mode... », le fichier
"blank-mode" (.el, voire .elc) sera chargé (si besoin (et s'il
est trouvé dans le load-path)).
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Là j'ai du mal à saisir...
J'ai rassemblé dans la fonction my-LaTeX-init mes nombreuses
définitions, initialisations, etc. ne concernant qu'AUCTeX...
Le « eval-after-load » ne l'exécutera qu'une fois.
Merci pour vos éclaircissements,
De rien, ça me permet de faire améliorer/remplacer mes bouts de code
(souvent pêchés ailleurs...) par les autres contributeurs.
A bientôt.
Au plaisir,
bonjour,
Pour AucTeX, j'ai un raccourci conditionnel :
(define-key LaTeX-mode-map (kbd "C-c f") 'my-frac-or-foot)
[...](defun my-frac-or-foot ()
"Insère une fraction ou une footnote selon le contexte"
(interactive)
(if (texmathp)
(my-fraction)
(my-footnote)))
Donc, si je comprends bien, il faudrait que je fasse un truc dans le genre :
#####
(define-key LaTeX-mode-map (kbd "M-"") 'franguill')
(define-key html-mode-map (kbd "M-"") 'franguill')
(defun franguill ()
"Insère des guillemets français"
(interactive)
(insert "og fg{}")
(backward-char 5))
#####
à moins qu'il faille passer par une condition ?
Heu, la fonction « franguill » est spécifique à (La)TeX, en html il en
faudrait une autre... mon exemple conditionnel concerne deux parties
d'un /même/ buffer en mode LaTeX.
[...] j'utilise un Emacs serveur lancé une fois pour toutes, et
l'appelle par gnuclient : j'ai donc dans mon ~/.xsession une ligne
ok, donc, gnuclient appartient au paquet gnuserv que je viens d'installer.
je suppose que le fichier ~/.xsession est chargé lors du lancement d'une
session graphique ?
Oui.Si c'est bien le cas, comment cela se passe lorsque
l'on travaille dans les tty ?
ça ne marche pas (avec emacs 21). Il me semble que ça pourrait le faire
avec une version plus récente ?
emacs -iconic -l ~/.elisp21/server.el &
donc on lance un serveur Emacs. Pour lancer emacs par la suite, il
suffit d'appeler emacs ou d'utiliser les lanceurs traditionnels ---
celui de mon tableau de bord correspond à /usr/bin/emacs22 ?
Voilà : un Emacs indépendant ne charge pas le bout de code serveur.qui charge, après ~/.emacs, le supplément suivant :
,----[ server.el ]
| ;;; serveur de gnuclient
| (when window-system
| (when (fboundp 'gnuserv-start)
| (gnuserv-start)
| (defun adieu ()
| (unless (y-or-n-p "Ça va pas, la tête... ?! ")
| (keyboard-quit)))
| (add-hook 'server-switch-hook
| (lambda ()
| (set-frame-position (make-frame) 0 0)))
| (add-hook 'server-done-hook 'delete-frame)))
`----
et dans mon ~/.emacs, la définition générale d'adieu
(defun adieu ()
(unless (y-or-n-p "Fermer cette instance d'Emacs ?")
(keyboard-quit)))
(add-hook 'kill-emacs-hook
'adieu)
euh... c'est bien un fichier "externe", qui se trouve ici :
~/.elisp21/server.el --- dans mon cas ~/.elisp22/server.el puisque j'ai
emacs22 (ou ça ne change rien) ?
Ça dépend de ce que l'on met dans son ~/.emacs...
J'ai préféré séparer ces répertoires suivant les versions, d'autant que
les *.el doivent être byte-compilés avec la version utilisée.
Mon ~/.emacs, lui, est tout petit, et n'a pas besoin de l'être :
;;; -*-emacs-lisp-*-
(setq debug-on-error t)
(setq message-log-max 300)
(cond
((= emacs-major-version 21) (add-to-list 'load-path (expand-file-name "~/.elisp21")))
((= emacs-major-version 22) (add-to-list 'load-path (expand-file-name "~/.elisp22")))
( t (add-to-list 'load-path (expand-file-name "~/.elisp"))))
(setq custom-file "~/.custom") ;; il faudra sans doute distinguer selon
;; la version aussi...
(if (> emacs-major-version 20)
(load custom-file))
(load-library "emacs") ;; charge un de mes ~/.elisp2?/emacs.el
Tout à la fin de ce(s) dernier(s), j'ai un
(require 'trucs)
qui charge trucs.el, pour éviter de byte-compiler à chaque essai le
fichier principal
De plus, si je me crée plusieurs ~/.emacs --- par exemple ~/.emacstex et
~/.emacshtml, comment faire pour les appeler au juste ? J'ai regardé
dans le man d'emacs et il ne m'a pas semblé voir d'option permettant de
choisir l'init file.
Ben, tu peux utiliser les options
--no-init-file, -q load neither ~/.emacs nor default.el
et
--load, -l FILE load FILE of Emacs Lisp code using the load function
pour charger ~/.montrucenplumes.el, mais pour un mode particulier, le
plus simple est d'avoir des fichiers dédiés, chargés en cas de besoin :
;;; blank-mode
(autoload 'blank-mode "blank-mode"
"Toggle blank visualization." t)
(autoload 'blank-mode-customize "blank-mode"
"Customize blank visualization." t)
(global-set-key [f6] 'blank-mode)
À l'appel d'une des fonctions « 'blank-mode... », le fichier
"blank-mode" (.el, voire .elc) sera chargé (si besoin (et s'il
est trouvé dans le load-path)).
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Là j'ai du mal à saisir...
J'ai rassemblé dans la fonction my-LaTeX-init mes nombreuses
définitions, initialisations, etc. ne concernant qu'AUCTeX...
Le « eval-after-load » ne l'exécutera qu'une fois.
Merci pour vos éclaircissements,
De rien, ça me permet de faire améliorer/remplacer mes bouts de code
(souvent pêchés ailleurs...) par les autres contributeurs.A bientôt.
Au plaisir,
Jacques L'helgoualc'h a écrit :
J'ai préféré séparer ces répertoires suivant les versions, d'autant que
les *.el doivent être byte-compilés avec la version utilisée.
Mon ~/.emacs, lui, est tout petit, et n'a pas besoin de l'être :
;;; -*-emacs-lisp-*-
(setq debug-on-error t)
(setq message-log-max 300)
(cond
((= emacs-major-version 21) (add-to-list 'load-path (expand-file-name "~/.elisp21")))
((= emacs-major-version 22) (add-to-list 'load-path (expand-file-name "~/.elisp22")))
( t (add-to-list 'load-path (expand-file-name "~/.elisp"))))
(setq custom-file "~/.custom") ;; il faudra sans doute distinguer selon
;; la version aussi...
(if (> emacs-major-version 20)
(load custom-file))
(load-library "emacs") ;; charge un de mes ~/.elisp2?/emacs.el
Donc si je comprends bien, on a un ~/.emacs global, avec des définitions
"classiques", genre : taille et "apparence" de la fenêtre, thème
utilisé, fonte, raccourcis génériques... qui ensuite, selon le mode
appelé charge un fichier de configuration particulier, comme ceci :
####
(load-library "emacs")
#####
c'est bien cela ?
Sinon, à quoi sert le fichier ~/.custom qui est chargé
D'ailleurs, pourquoi utiliser différentes versions d'emacs ?
Tout à la fin de ce(s) dernier(s), j'ai un
(require 'trucs)
qui charge trucs.el, pour éviter de byte-compiler à chaque essai le
fichier principal
Encore une fois, j'ai du mal à saisir :/
;;; blank-mode
(autoload 'blank-mode "blank-mode"
"Toggle blank visualization." t)
(autoload 'blank-mode-customize "blank-mode"
"Customize blank visualization." t)
(global-set-key [f6] 'blank-mode)
À l'appel d'une des fonctions « 'blank-mode... », le fichier
"blank-mode" (.el, voire .elc) sera chargé (si besoin (et s'il
est trouvé dans le load-path)).
Alors, je comprends bien la portée limitée de passer par le chargement
d'un fichier spécifique, mais je ne saisis pas trop le bout de code
ci-dessus :
n'est-ce pas déjà ce que l'on fait avec le code "avec
condition" dans le ~/.emacs (code entre ####) ?
####
(cond
((= LaTeX-mode) (add-to-list 'load-path (expand-file-name
"~/.elisp22/latex")))
((= html-mode) (add-to-list 'load-path (expand-file-name
"~/.elisp22/html")))
####
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Là j'ai du mal à saisir...
J'ai rassemblé dans la fonction my-LaTeX-init mes nombreuses
définitions, initialisations, etc. ne concernant qu'AUCTeX...
Ok, mais alors quelle est la forme de cette fonction ? Dans quel fichier
se place-t-elle ? Dans le fichier ~/.emacs ou dans le .emacs spécifique
à latex ?
Et par curiosité, quelle sont vos "nombreuses définitions,
initialisations, etc. ne concernant qu'AUCTeX" ?
Le « eval-after-load » ne l'exécutera qu'une fois.
Comment ça ?
Désolé si certaines de mes questions sont "simplistes" mais j'essaye de
poursuivre ma compréhension d'emacs.
Merci encore, à bientôt.
Jacques L'helgoualc'h a écrit :
J'ai préféré séparer ces répertoires suivant les versions, d'autant que
les *.el doivent être byte-compilés avec la version utilisée.
Mon ~/.emacs, lui, est tout petit, et n'a pas besoin de l'être :
;;; -*-emacs-lisp-*-
(setq debug-on-error t)
(setq message-log-max 300)
(cond
((= emacs-major-version 21) (add-to-list 'load-path (expand-file-name "~/.elisp21")))
((= emacs-major-version 22) (add-to-list 'load-path (expand-file-name "~/.elisp22")))
( t (add-to-list 'load-path (expand-file-name "~/.elisp"))))
(setq custom-file "~/.custom") ;; il faudra sans doute distinguer selon
;; la version aussi...
(if (> emacs-major-version 20)
(load custom-file))
(load-library "emacs") ;; charge un de mes ~/.elisp2?/emacs.el
Donc si je comprends bien, on a un ~/.emacs global, avec des définitions
"classiques", genre : taille et "apparence" de la fenêtre, thème
utilisé, fonte, raccourcis génériques... qui ensuite, selon le mode
appelé charge un fichier de configuration particulier, comme ceci :
####
(load-library "emacs")
#####
c'est bien cela ?
Sinon, à quoi sert le fichier ~/.custom qui est chargé
D'ailleurs, pourquoi utiliser différentes versions d'emacs ?
Tout à la fin de ce(s) dernier(s), j'ai un
(require 'trucs)
qui charge trucs.el, pour éviter de byte-compiler à chaque essai le
fichier principal
Encore une fois, j'ai du mal à saisir :/
;;; blank-mode
(autoload 'blank-mode "blank-mode"
"Toggle blank visualization." t)
(autoload 'blank-mode-customize "blank-mode"
"Customize blank visualization." t)
(global-set-key [f6] 'blank-mode)
À l'appel d'une des fonctions « 'blank-mode... », le fichier
"blank-mode" (.el, voire .elc) sera chargé (si besoin (et s'il
est trouvé dans le load-path)).
Alors, je comprends bien la portée limitée de passer par le chargement
d'un fichier spécifique, mais je ne saisis pas trop le bout de code
ci-dessus :
n'est-ce pas déjà ce que l'on fait avec le code "avec
condition" dans le ~/.emacs (code entre ####) ?
####
(cond
((= LaTeX-mode) (add-to-list 'load-path (expand-file-name
"~/.elisp22/latex")))
((= html-mode) (add-to-list 'load-path (expand-file-name
"~/.elisp22/html")))
####
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Là j'ai du mal à saisir...
J'ai rassemblé dans la fonction my-LaTeX-init mes nombreuses
définitions, initialisations, etc. ne concernant qu'AUCTeX...
Ok, mais alors quelle est la forme de cette fonction ? Dans quel fichier
se place-t-elle ? Dans le fichier ~/.emacs ou dans le .emacs spécifique
à latex ?
Et par curiosité, quelle sont vos "nombreuses définitions,
initialisations, etc. ne concernant qu'AUCTeX" ?
Le « eval-after-load » ne l'exécutera qu'une fois.
Comment ça ?
Désolé si certaines de mes questions sont "simplistes" mais j'essaye de
poursuivre ma compréhension d'emacs.
Merci encore, à bientôt.
Jacques L'helgoualc'h a écrit :
J'ai préféré séparer ces répertoires suivant les versions, d'autant que
les *.el doivent être byte-compilés avec la version utilisée.
Mon ~/.emacs, lui, est tout petit, et n'a pas besoin de l'être :
;;; -*-emacs-lisp-*-
(setq debug-on-error t)
(setq message-log-max 300)
(cond
((= emacs-major-version 21) (add-to-list 'load-path (expand-file-name "~/.elisp21")))
((= emacs-major-version 22) (add-to-list 'load-path (expand-file-name "~/.elisp22")))
( t (add-to-list 'load-path (expand-file-name "~/.elisp"))))
(setq custom-file "~/.custom") ;; il faudra sans doute distinguer selon
;; la version aussi...
(if (> emacs-major-version 20)
(load custom-file))
(load-library "emacs") ;; charge un de mes ~/.elisp2?/emacs.el
Donc si je comprends bien, on a un ~/.emacs global, avec des définitions
"classiques", genre : taille et "apparence" de la fenêtre, thème
utilisé, fonte, raccourcis génériques... qui ensuite, selon le mode
appelé charge un fichier de configuration particulier, comme ceci :
####
(load-library "emacs")
#####
c'est bien cela ?
Sinon, à quoi sert le fichier ~/.custom qui est chargé
D'ailleurs, pourquoi utiliser différentes versions d'emacs ?
Tout à la fin de ce(s) dernier(s), j'ai un
(require 'trucs)
qui charge trucs.el, pour éviter de byte-compiler à chaque essai le
fichier principal
Encore une fois, j'ai du mal à saisir :/
;;; blank-mode
(autoload 'blank-mode "blank-mode"
"Toggle blank visualization." t)
(autoload 'blank-mode-customize "blank-mode"
"Customize blank visualization." t)
(global-set-key [f6] 'blank-mode)
À l'appel d'une des fonctions « 'blank-mode... », le fichier
"blank-mode" (.el, voire .elc) sera chargé (si besoin (et s'il
est trouvé dans le load-path)).
Alors, je comprends bien la portée limitée de passer par le chargement
d'un fichier spécifique, mais je ne saisis pas trop le bout de code
ci-dessus :
n'est-ce pas déjà ce que l'on fait avec le code "avec
condition" dans le ~/.emacs (code entre ####) ?
####
(cond
((= LaTeX-mode) (add-to-list 'load-path (expand-file-name
"~/.elisp22/latex")))
((= html-mode) (add-to-list 'load-path (expand-file-name
"~/.elisp22/html")))
####
Le « local-set-key » est encore plus spécialisé, il me semble que la
méthode du *-mode-map est mieux adaptée aux raccourcis qui sont définis
une fois pour toutes au premier chargement du mode :
(eval-after-load "latex" '(my-LaTeX-init))
avec mes ajouts de LaTeX-mode-map dans la fonction appelée.
Là j'ai du mal à saisir...
J'ai rassemblé dans la fonction my-LaTeX-init mes nombreuses
définitions, initialisations, etc. ne concernant qu'AUCTeX...
Ok, mais alors quelle est la forme de cette fonction ? Dans quel fichier
se place-t-elle ? Dans le fichier ~/.emacs ou dans le .emacs spécifique
à latex ?
Et par curiosité, quelle sont vos "nombreuses définitions,
initialisations, etc. ne concernant qu'AUCTeX" ?
Le « eval-after-load » ne l'exécutera qu'une fois.
Comment ça ?
Désolé si certaines de mes questions sont "simplistes" mais j'essaye de
poursuivre ma compréhension d'emacs.
Merci encore, à bientôt.