Dernière version du 28 août 2015 à 18:50

rapide présentation

Je suis historien, et mon travail implique une large utilisation des alphabets français et polonais, et parfois des caractères allemands.

Côté matériel, j’utilise un TypeMatrix 2030. J’essaie de me passer au maximum de la souris.

clavier bépo optimisé polonais

Inspiré des variantes «w» de Flamme et UtilisezLinux, il est optimisé en fonction de quelques critères:

avoir un accès simplifié aux lettres polonaises ą, ę, ó, ć, ś, ł, ź, ż, ń, toutes accessibles en combinaison avec Alt-gr, sauf ź (Alt-gr+é, z). Rappel: sur un clavier bépo, il faut passer par les lettres mortes, parfois avec un Alt-gr+maj.
avoir la lettre w à portée de main (pour un Polonais, le qwerty est assez ergonomique vu leur abus de z et w. D’ailleurs, il n’y a pas de dvorak polonais)
l’apostrophe française ’ en accès direct
initialement, j’avais optimisé la rangée numérique pour un usage de latex. Finalement, un usage averti des abbréviations me permet d’avoir relativement peu usage des {} et autres, donc j’ai fini par donner priorité aux chiffres qui sont en accès direct.
début 2015, j’ai révolutionné la colonne des chiffres pour que le 0 et le 1 soit sous l’index. Je me suis du coup inspiré de l’idée initiale de dvorak (impair=main gauche, pair=main droite). Et j’en suis très content! Plus de fatigue au petit doigt…

les quatre couches, clavier matriciel

accès direct, clavier décalé

Les touches vertes sont celles qui diffèrent d’un bépo standard pour l’accès direct. Si l’on excepte la ligne des chiffres totalement chamboulée, j’ai essayé de ne pas trop modifier les touches en accès direct. En revanche, la couche 3 (alt-gr) a été pas mal retouchée.

le fichier xkb

xkb_keymap        {

xkb_keycodes      { include "evdev+aliases(azerty)" };

xkb_types         { include "complete" };

xkb_compatibility { include "complete" };

partial alphanumeric_keys
xkb_symbols "bepo_pl" {

    name[Group1]= "France - Bepo, ergonomic, franco-polonais";

    include "pc(pc105)"

	key <TLDE> { type[group1] = "FOUR_LEVEL", [ dollar, numbersign, endash, paragraph ] }; // $ # – ¶
	key <AE01> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 7, quotedbl, emdash, doublelowquotemark ] }; // 1 " — „
	key <AE02> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 5, braceleft, less, leftdoublequotemark ] }; // 2 { < “
	key <AE03> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 3, braceright, greater, rightdoublequotemark ] }; // 3 } > ”
	key <AE04> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 1, parenleft, bracketleft, lessthanequal ] }; // 4 ( [ ≤
	key <AE05> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 9, parenright, bracketright, greaterthanequal ] }; // 5 ) ] ≥
	key <AE06> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 8, at, asciicircum ] }; // 6 @ ^
	key <AE07> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 0, plus, plusminus, notsign ] }; // 7 + ± ¬
	key <AE08> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 6, minus, U2212, onequarter ] }; // 8 - − ¼
	key <AE09> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 4, asterisk, division, onehalf ] }; // 9 / ÷ ½
	key <AE10> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 2, slash, multiply, threequarters ] }; // 0 * × ¾
	key <AE11> { type[group1] = "FOUR_LEVEL", [ equal, degree, notequal, minutes ] }; // = ° ≠ ′
	key <AE12> { type[group1] = "FOUR_LEVEL", [ percent, grave, U2030, seconds ] }; // % ` ‰ ″

	key <AD01> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ b, B, bar, brokenbar ] }; // b B | ¦
	key <AD02> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ eacute, Eacute, dead_acute, dead_doubleacute ] }; // é É ´ ˝
	key <AD03> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ p, P, ampersand, section ] }; // p P & §
	key <AD04> { type[group1] = "FOUR_LEVEL_ALPHABETIC", [ o, O, oacute, oe ] }; // o O ó œ
	key <AD05> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ egrave, Egrave, dead_grave, OE ] }; // è È ` Œ
	key <AD06> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ w, W, exclam, exclamdown ] }; // w W ! ¡
	key <AD07> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ v, V, dead_caron, thorn ] }; // v V ˇ þ
	key <AD08> { type[group1] = "FOUR_LEVEL_ALPHABETIC", [ d, D, eth, ETH ] }; // d D ð Ð
	key <AD09> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ l, L, lstroke, Lstroke ] }; // l L ł Ł
	key <AD10> { type[group1] = "FOUR_LEVEL_ALPHABETIC", [ j, J, U0133, U0132 ] }; // j J ĳ Ĳ
	key <AD11> { type[group1] = "FOUR_LEVEL_ALPHABETIC", [  x, X, copyright, U017F ] }; // x X © ſ
	key <AD12> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ dead_circumflex, EuroSign, dead_breve, dead_stroke }; // ^ € ˘ /

	key <AC01> { type[group1] = "FOUR_LEVEL_ALPHABETIC", [ a, A, aogonek, Aogonek ] }; // a A ą Ą
	key <AC02> { type[group1] = "FOUR_LEVEL_ALPHABETIC", [ u, U, ugrave, Ugrave ] }; // u U ù Ù
	key <AC03> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ i, I, dead_diaeresis, dead_abovedot ] }; // i I ¨ ˙
	key <AC04> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ e, E, eogonek, UFDD1 ] }; // e E ę ¤
	key <AC05> { type[group1] = "FOUR_LEVEL", [ comma, semicolon, dead_hook, dead_horn ] }; // , ;  ̉  ̛
	key <AC06> { type[group1] = "FOUR_LEVEL_ALPHABETIC", [ c, C, cacute, Cacute ] }; // c C ć Ć
	key <AC07> { type[group1] = "FOUR_LEVEL_ALPHABETIC", [ t, T, ccedilla, Ccedilla ] }; // t T ç Ç
	key <AC08> { type[group1] = "FOUR_LEVEL_ALPHABETIC", [ s, S, sacute, Sacute ] }; // s S ś Ś
	key <AC09> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ r, R, registered, trademark ] }; // r R ® ™
	key <AC10> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ n, N, nacute, dead_tilde ] }; // n N ń ~
	key <AC11> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ m, M, dead_macron, masculine ] }; // m M ¯ º
	key <BKSL> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ slash,
	backslash, dead_cedilla, UFDD3 ] }; // / \ ¸ ,

	key <LSGT> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ ecircumflex, Ecircumflex, ae, AE ] }; // ê Ê æ Æ
	key <AB01> { type[group1] = "FOUR_LEVEL_ALPHABETIC", [ agrave, Agrave,  guillemotleft, leftsinglequotemark ] }; // à À « ‘
	key <AB02> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ y, Y, guillemotright, rightsinglequotemark ] }; // y Y » ’
	key <AB03> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ z, Z, zabovedot, Zabovedot ] }; // z Z ż Ż
	key <AB04> { type[group1] = "FOUR_LEVEL", [ period, colon, ellipsis, periodcentered ] }; // . : … ·
	key <AB05> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ k,	K, asciitilde, THORN ] }; // k K ~ Þ
	key <AB06> { type[group1] = "FOUR_LEVEL", [ rightsinglequotemark, apostrophe, question, questiondown ] }; // ’ ' ? ¿
	key <AB07> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ q, Q, dead_abovering, dead_belowdot ] }; // q Q ˚ ̣
	key <AB08> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ g, G, ssharp, UFDD2 ] }; // g G ß µ
	key <AB09> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ h, H, dagger, doubledagger ] }; // h H † ‡
	key <AB10> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ f, F, dead_ogonek, ordfeminine ] }; // f F ˛ ª
	key <SPCE> { type[group1] = "FOUR_LEVEL", [ space, nobreakspace, underscore, U202F ] }; //     _  

	include "level3(ralt_switch)"
};

xkb_geometry { include "pc(pc105)" };

};

un petit logo "tapé en bépo"

Pour faire de la pub pour le bépo, vous pouvez ajouter ce logo à vos sites, blogs etc.

bépo et informatique

un système plus ergonomique

Passer au bépo, et en parallèle à Arch Linux a énormément changé ma manière de faire de l’informatique. Je suis devenu peu à peu un adepte du KISS (Keep It Simple Stupid), en essayant de le combiner à l’ergonomie. La lecture de la page vim du wiki bépo m’a conduit à vimifier — n’utiliser la souris qu’en dernier recours, et préférer les applications modales — mes bureaux, applications etc. Actuellement j’essaie de suivre trois principes:

préférer la logique UNIX de choisir des applications qui ne font qu’une seule tâche, mais bien
privilégier les applications légères, notamment parce que leur manuel est plus facile à maîtriser. J’ai ainsi fini par préférer vim à emacs, et j’ai découvert qu’il y avait moyen, en utilisant des applications externes (tmux et latexmk), de compenser en bonne partie la perte d’auctex sans même utiliser de plugin latex pour vim (en fait j’utilise latex-box, mais uniquement pour la coloration syntaxique et le saut entre le début et la fin des environnements avec la touche %. Plus la fonction CloseCurrentEnvironment, que je n’utilise qu’exceptionnellement).
éliminer au maximum les combinaisons de touches et les frappes éloignées de la ligne de repos. Cela se traduit par une utilisation intensive des abbréviations

Je retrace plus en détail ces évolutions plus bas.

utilité des abbréviations

Les abbréviations et les feuilles de style souvent sous-utilisées (c’est du moins ce que l’on lit dans un des manuels annexes d’emacs, autotype, utilisateurs emacs, mangez-en, c’est bon. Comme ma disposition bépo place les chiffres en accès direct, pour taper une parenthèse, je dois faire des combinaisons Maj+4 ou Maj+5, et je ne parle pas des Alt-gr. La solution est de rentrer une abbréviation, sur vim comme emacs. En gros, je tape pp puis tab et j’ai deux parenthèses avec le curseur au milieu (sur emacs, c’était encore plus simple, voir plus bas). Pour donner un aperçu de ce fonctionnement, je mets en ligne une partie de mes fichiers vim, pas tout parce que les abbréviaitons, pour être efficaces, doivent être conçues par chaque utilisateur. Sinon, on a un effort de mémorisation monstrueux qui revient à importer un plugin…

Avec vim et emacs, les abbréviations sont converties si le caractère suivant n’est pas une lettre ou un numéro. Quand je tape clavier azerty2clavier azertygclavier azertymclavier bépoEspace, j’obtiens deuxième guerre mondiale suivie d’une espace. Mais on a parfois besoin d’avoir le curseur juste derrière le mot qui vient d’être converti (pour mettre le mot au pluriel, au féminin…). Sous vim, il faut taper clavier bépoCtr-clavier azerty] pour avoir cet effet. Comme ce raccourci est très mal adapté au bépo, j’ai attribué cette fonction à la touche clavier bépoTab. Pour éviter une abbréviation d’être activée, il faut sortir du mode insersion en cours de frappe, puis revenir. clavier azerty2clavier bépoÉchapclavier azertyaclavier azertygclavier azertym donnera bien 2gm à l’écran.

abbréviations vim

Quelques exemples d’abbréviations "ergonomiques" qui limitent le recours à la touche majuscule et au rang du haut.

iabbrev 2gm Deuxième Guerre mondiale
iabbrev ddpadem droit des peuples à disposer d’eux-mêmes
iabbrev etre être
iabbrev eurce Europe du Centre-Est

"guillemets
iabbrev gd »«<Left>
iabbrev gf «»<Left>
iabbrev gg ""<Left>
iabbrev gp „“<Left>
iabbrev gs ''<Left>

"parenthèses et assimilés
iabbrev pa {}<Left>
iabbrev pc []<Left>
iabbrev pp ()<Left>
iabbrev pr <><Left>

Quelques abbréviations de mon fichier .vim/ftplugin/tex.vim. Celles-ci font parfois appel à des fonctions maisons. Taille() demande la Taille de certains environnements. Elle ne sert qu’à XeLaTeX donc elle est dans mon tex.vim. titre() demande un nom de fichier, nom() permet de charger les noms de fichiers en utilisant la complétion. En voici la teneur, dans mon .vim/autoload/mesfonctions.vim

"demande le titre d’un environnement 
function mesfonctions#titre()
    call inputsave()
    let untitre = input ("Titre de l’élément? ")
    call inputrestore()
    return untitre
endfunction

"demande un nom de fichier
function mesfonctions#nom()
    call inputsave()
    let unfichier = input ("Nom du fichier? ", "", "file")
    call inputrestore()
    return unfichier
endfunction

" tex.vim configuration des fichiers .tex
" TIP: if you write your \label's as \label{fig:something}, then if you type in \ref{fig: and press <C-n> you will automatically cycle through all the figure labels. Very useful!
set iskeyword+=:

"""""""""""fonctions""""""""""""""""""""
"options de mesure ou mise en forme
function! s:Taille()
    call inputsave()
    let lataille = input ("Taille ou format (pt, \linewidth, |c|c|…)?")
    call inputrestore()
    return lataille
endfunction

"""""""""""clavier""""""""""""""""""""""
imap <buffer> <F4> \footnote{}<Left>
nmap <buffer> <F4> a\footnote{}<Left>

"commenter et décommenter
cmap <buffer> <F2> s/^/%/
cmap <buffer> <F9> s/%//


"""""""""""abbrevs""""""""""""""""""""""
"environnements et autres (certains doivent être appelés par C-] ou tab
iabbrev <buffer> afb [allowframebreaks]
iabbrev <buffer> ahr \url{http://}<Left>
iabbrev <buffer> bf \textbf{}<Left>
iabbrev <buffer> bfs {\bfseries }<Left>
iabbrev <buffer> bl <CR>\begin{block}{<C-R>=mesfonctions#titre()<CR>}<CR><CR>\end{block}<Up>
iabbrev <buffer> clm \begin{columns}[t]<CR>\begin{column}{<C-R>=<SID>Taille()<CR>}<CR>\end{column}<CR>\end{columns}<Esc>2s2yyPo
iabbrev <buffer> clo <C-R>=<SID>CloseCurEnv()<CR>
iabbrev <buffer> cnt <CR>\begin{center}<CR><CR>\end{center}

"chapitres et autres
iabbrev <buffer> sn \section{}<Left>
iabbrev <buffer> ssn \subsection{}<Left>
iabbrev <buffer> sssn \subsubsection{}<Left>

"exemple d’abbréviation lançant un chargement de fichier
iabbrev <buffer> xepdf <CR>\mbox{\XeTeXpdffile <C-R>=mesfonctions#nom() <CR>}<Left>
iabbrev <buffer> xepic <CR>\mbox{\XeTeXpicfile <C-R>=mesfonctions#nom() <CR>}<Left>

L’avantage des abbréviations configurables par type de fichier, c’est que la même abbréviation peut désigner une réalité (insérer une url, un chapitre etc.) mais être converti dans le langage informatique adapté. Je donne ici trois exemples de mon fichier html.vim qui ont des équivalents dans le tex.vim: ahr (insersion d’url), bf (texte en gras) et sn (chapitre), ssn (sous-chapitre) et sssn (devinez-quoi…):

"html.vim, raccourcis pour l’html
iabbrev <buffer> ahr <CR><a href="<C-R>=mesfonctions#nom()<CR>"></a><Esc>F<i 
iabbrev <buffer> bf <strong></strong><Esc>F<i
iabbrev <buffer> sn <h1></h1><Esc>F<i
iabbrev <buffer> ssn <h2></h2><Esc>F<i
iabbrev <buffer> sssn <h3></h3><Esc>F<i

Comment j’ai ergonomisé mon système

La vimification de mon poste de travail s’est traduite par la recherche de programmes de plus en plus compacts et si possible utilisables sans souris:

OS: Sous GNU/Linux depuis 2002, je suis passé de Mandriva à Arch Linux, puis récemment à OpenBSD. Le plus d’OpenBSD, c’est que ses pages de manuel sont vraiment limpides (on ne peut pas en dire autant de la page info de sed ou awk sur GNU/LINUX)… et que l’on y trouve certains paquets qu’il faut compiler sur Arch (qgis!). Le moins est que certains paquets sont un peu datés, mais c’est de plus en plus rare (texlive a par exemple deux ans de retard mais n’en aura plus qu’un en novembre…).
gestionnaire de bureau/fenêtre: Peu après avoir découvert que KDE consommait beaucoup de mémoire et rajoutait des surcouches (sources potentielles de bug), j’ai décidé de me passer de gestionnaire de bureau. Comme gestionnaire de fenêtre, j’ai alors adopté openbox. Lassé par la structure XML des fichiers de config, j’ai migré vers fluxbox. En 2011, révolution culturelle avec le passage au tiling: i3 puis, un an plus tard, dwm car je me perdais parfois dans le changement de focus d’i3. Suite à des problèmes de compilation, je suis récemment passé à ratpoison qui me permet de me passer totalement de la souris (simulée au clavier). Il m’arrive d’utiliser cwm lorsque j’utilise QGIS.
shell et console: D’abord passage à zsh. Comme je suis toujours perdu dans le manuel, j’ai ensuite adopté pdksh, dont le manuel est limpide. Le problème est que l’on ne peut pas reprogrammer les touches vim de pdksh. Ah, et je n’utilise plus de gestionnaire de fichier maintenant que j’ai compris comment monter les périphériques. On peut restituer cette migration ainsi: dolphin-krusader-sunrise (clone emacs de midnight commander)-zsh. Pour la console, passage de URXvT à st, plus léger, en combinaison avec tmux.
bureautique: comme précisé plus haut, pour l’éditeur de texte, passage d’emacs à emacs-evil, puis à vim. J’utilise latex de longue date, et je produits maintenant la plupart de mes fichiers docs avec. Je n’utilise plus libreoffice que lorsqu’il faut travailler sur des docs préformatés. Pour les présentations, je suis aussi passé à latex avec l’excellent paquet beamer. Le tableur a été remplacé par des fichiers textes traités avec vim,sed et awk. Pour la base de données, passage de LibreOffice à sqlite invoqué depuis zsh.
images: Pour la visionneuse, je suis passé à feh. Là aussi, le manuel est un peu complexe, donc je suis passé ultérieurement à sxiv. Pour le traitement des images, j’ai abandonné gimp au profit d’imagemagick (IM) ou graphicsmagick (GM) (j’utilise IM lorsque les fonctions ne sont pas disponibles sur GM). Il m’arrive de créér des images avec IM. Pour les svg, j’utilise quand même inkscape.
visionneuse pdf: je suis passé à zathura-mupdf
vidéo: passage à mplayer, que j’utilise aussi comme lecteur audio, puis à mpv sur Linux (pas encore enpaqueté sur OpenBSD, où je reste sur mplayer)
internet: j’ai tenté midori, mais il n’était pas encore optimal à l’époque (beaucoup de crash), donc je suis passé à uzbl pour avoir un navigateur conçu pour le clavier. Comme certains contenus ne passent pas, je garde un navigateur avec l’engin mozilla. Sur OpenBSD, c’est conkeror, dont je suis très contemps, on peut très bien l’utiliser sans la souris. Sinon j’utilise Firefox. Enfin, la lenteur du serveur mail professionnel m’a permis de franchir le pas en passant sur mutt pour mes courriels pros.
synchronisation: La synchronisation m’avait incité à migrer vers krusader pour gérer les fichiers. J’utilise désormais rsync et unison.

des fichiers de configuration

vimrc

Mon vimrc est divisé en plusieurs fichiers: voici le .vimrc proprement dit. Je tape en général en mode longues lignes, car cela facilite le moulinage avec sed en cas de besoin (sed et awk travaillent sur une ligne, plus elle est longue moins on s’arrache les cheveux…). Je ne reprends pas ici les options qui figurent déjà dans le wiki.

""""""""aspect de vim""""""""""""

set number  "affiche numéro de ligne
set ruler   "affiche 'ligne,colonne' du curseur dans la barre
set showcmd "affiche la commande en cours
set visualbell

colorscheme thiriet
syntax enable   "coloration syntaxique

""""""""traitement des fichiers"""
set backup      "fichiers de sauvegarde
set autoread    "actualise les fichiers modifiés hors de vim
set autowriteall "enregistrement automatique si appelle autre fichier, quitte etc.
set confirm     "au lieu d’empêcher une action, demande confirmation

"set textwidth=70 "coupe la ligne au 70e caractère

set showmatch "parenthèse pendante
set matchpairs+=<:>,„:“,«:» "rajoute des paires accessibles par %
set expandtab
"set mouse=a

set ignorecase "n’utilise pas la casse pour chercher une complétion
set smartcase  "si on met une majuscule tient compte de la casse
set infercase  "vas appliquer la casse du mot complété
set incsearch  "montre où nous mène une recherche au fur et à mesure 

set smartindent
set shiftwidth=3 "nombre d’espaces pour l’indentation

set autowrite  "sauve le fichier en cours avant d’en ouvrir un autre


"""""""""astuces tirées de divers vimrc""""""""""""""""""""

"archwiki (en) https://wiki.archlinux.org/index.php/Vim
" le fichier s'ouvre avec curseur là où on l'a quitté
if has("autocmd")
    au BufReadPost * if line("'\"") > 1 && line("'\"") <= line("$") | exe "normal! g`\"" | endif
    endif

"""""""""""""""""plugins""""""""""""""""""""""""""""""""
filetype plugin indent on

""""""""""redéfinit les touches pour les adapter au bépo""""

source ~/.vim/vimrc.bepo

""""""""""abbreviations"""""""""""""""""""""""""""""""""
source ~/.vim/abbrevs_globales

Le .vimrc.bepo, qui concerne les modifications «spéciale bépo». Là aussi, je ne reproduits que les modifications que l’on ne trouve pas dans le wiki bépo.

""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
"      vimrc.bepo: raccourcis claviers adaptés au bépo     "
"                                                          " 
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""


" <Entrée> passe en mode Ex
" —————————————————————————
noremap <CR> :

" comme dl vaut x en bépo, je réaffecte x
" —————————————————————————————————————————————————————————
let mapleader = "x"

" [BÉÈ] -> [^$B]
" ——————————————
"je remappe b sur è pour avoir è et w à côté, sur des doigts forts
noremap è b
noremap È B
"{bé} = ^$
noremap b ^
noremap é $

" bépo et lignes visuelles
" ———————————————————————— 
" ligne visuelle précédente / suivante
noremap gs k
noremap gt j
" {ts} = « haut / bas »
noremap t gj
noremap s gk

" Tab fait un Ctr-] (pour abbrev), Maj+Tab fait un Tab en mode insertion
inoremap <Tab> <C-]>
inoremap <A-Tab> <C-]>
"inoremap <S-Tab> <Tab>

" En mode visuel et normal, Tab fait escape et Maj+Tab un Tab (i.e. jump list)
vnoremap <Tab> <Esc>
vnoremap <S-Tab> <Tab>
nnoremap <Tab> <Esc>
nnoremap <S-Tab> <Tab>

" f3 et f8 pour la complétion des mots (plus rapide que C-p et C-n)
inoremap <F3> <C-p>
inoremap <F8> <C-n>

" en mode insert et visuel, f7 donne escape
vnoremap <F7> <Esc>
inoremap <F7> <Esc>

" permet de coller proprement depuis le presse-papier de X
noremap ê :r !xsel -o

"""""""""""text-objects"""""""""""""""""""""""""""""""""
"extension des text-objects aux guillemets (dir supprime le texte situé entre < et > etc.
 
" pour une meilleure accessibilité ([,{,< moyennement accessibles
omap aa aB
omap ia iB
" r pour range (<-> en zsh ou beamer)
omap ar a<
omap ir i<
omap ac a[
omap ic i[
"guillemets polonais 
vnoremap a„ :<C-U>silent! normal! F„vf“<CR>
onoremap a„ :normal va„<CR> 
vnoremap i„ :<C-U>silent! normal! T„vt“<CR>
onoremap i„ :normal vi„<CR> 
vnoremap a’ :<C-U>silent! normal! F„vf“<CR>
onoremap a’ :normal va’<CR> 
vnoremap i’ :<C-U>silent! normal! T„vt“<CR>
onoremap i’ :normal vi’<CR> 
"guillemets français ([g]uillemet)
vnoremap ag :<C-U>silent! normal! F«vf»<CR>
onoremap ag :normal vag<CR>
vnoremap ig :<C-U>silent! normal! T«vt»<CR>
onoremap ig :normal vig<CR>

emacs

.emacs

inputrc

Très utile pour les consoles R et sqlite, sert aussi pour bash (que je n’utilise pas)

 # First, include any systemwide bindings and variable
 # assignments from /etc/Inputrc
 $include /etc/Inputrc
 
 #options générales
 set editing-mode vi
 set bell-style visible
 
 #configuration du clavier
 $if mode=vi
    set keymap vi-command
    "s": history-search-backward
    "t": history-search-forward
    "l": vi-change-char
    "L": vi-replace
    "k": vi-subst
    "h": vi-change-to
    "hh": kill-whole-line
    set keymap vi-move
    "c": backward-char
    "r": forward-char
    "j": vi-char-search
    "è": vi-prev-word
    set keymap vi-insert
    #si une touche ne marche pas en mode insert, la mapper en :self-insert
    "\e[A": history-search-backward
    "\e[B": history-search-forward
 
 $endif
 
 #la documentation étant lacunaire sur les fonctions spécifiques vi, un grand merci à:
 #http://www.calmar.ws/vim/vi-bash.html