Utilisateur:Damien thiriet

rapide présentation

Je suis historien, et mon travail implique une large utilisation des alphabets français et polonais, et dans une moindre mesure de l’allemand. Après avoir basculé vers le bépo, j’ai fait un gros travail d’optimisation de mon système (j’utilise Arch Linux). Actuellement, j’ai optimisé Vim, Emacs (avec Evil), fluxbox, zathura, less, info, feh, i3 et zsh pour une utilisation de ma variante bépo.

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 expansions sous emacs 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. Cela me permet de bien optimiser evil.

le fichier xkb

En attendant une représentation graphique…

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", [ 1, quotedbl, emdash, doublelowquotemark ] }; // 1 " — „
	key <AE02> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 2, braceleft, less, leftdoublequotemark ] }; // 2 { < “
	key <AE03> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 3, braceright, greater, rightdoublequotemark ] }; // 3 } > ”
	key <AE04> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 4, parenleft, bracketleft, lessthanequal ] }; // 4 ( [ ≤
	key <AE05> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 5, parenright, bracketright, greaterthanequal ] }; // 5 ) ] ≥
	key <AE06> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 6, at, asciicircum ] }; // 6 @ ^
	key <AE07> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 7, plus, plusminus, notsign ] }; // 7 + ± ¬
	key <AE08> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 8, minus, U2212, onequarter ] }; // 8 - − ¼
	key <AE09> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 9, slash, division, onehalf ] }; // 9 / ÷ ½
	key <AE10> { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ 0, asterisk, 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 ij IJ
	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

Passer au bépo, et en parallèle à [url=http://www.archlinux.fr]Arch Linux[/url] 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 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’envisage pour cette raison de passer de zsh vers pcksh mais je dois encore résoudre le problème de la vimification-bépoisation de ce shell). 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

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, [url=https://www.gnu.org/software/emacs/manual/html_node/autotype/index.html]autotype[/url], 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…

mon .vimrc

il est divisé en plusieurs fichiers: le .vimrc proprement dit

""""""""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

"set background=light
colorscheme thiriet
syntax enable   "coloration syntaxique

""""""""traitement des fichiers"""
set history=50
set viminfo='40,:20,@20,/5
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 encoding=utf-8
set fileencoding=utf-8

"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

" colorise les nbsp (wiki bépo)
highlight NbSp ctermbg=lightblue guibg=lightred
match NbSp /\%xa0/

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

"Nemolivier http://bepo.fr/wiki/Utilisateur:Nemolivier/vimrc
set laststatus=2  "statusline en permanence
set statusline=%<%f%h%m%r%=%l,%c\ %P  

"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

"call pathogen#infect() "pathogen gère les plugins
"let g:LatexBox_Folding = 1

""""""""""vimdiff"""""""""""""""""""""""""""""""""""""""

""""""""""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»

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

""""""source: wiki bépo http://bepo.fr/wiki/Vim"""""""""""""""

" Pour faciliter les manipulations de fenêtres, on utilise {à} comme un Ctrl+W :
nmap à <C-w>
nmap À <C-w><C-w>
nmap àà <C-w><C-w>

" RECHERCHE
" —————————
"je remappe ' en ? pour avoir la fonction recherche en accès direct en mode normal… malheureusement cela ne marche pas
"noremap ? ’
"noremap ’ ?
 
" [HJKL] -> {CTSR}
" ————————————————
" {cr} = « gauche / droite »
noremap c h
noremap r l
" {CR} = « haut / bas de l'écran »
noremap C H
noremap R L
" {TS} = « joindre / aide »
noremap T J
noremap S K
 
" {HJKL} <- [CTSR]
" ————————————————
" {J} = « Jusqu'à »            (j = suivant, J = précédant)
noremap j t
noremap J T
" {L} = « Change »
noremap l r
noremap L R
" {H} = « Remplace »
noremap h c
noremap H C
" {K} = « Substitue »          (k = caractère, K = ligne)
noremap k s
noremap K S
" Corollaire : correction orthographique
noremap ]k ]s
noremap [k [s


"utilise backspace et espace pour pageup et pagedown en mode normal (wiki bépo)
noremap <BS> <PageUp>
noremap <Space> <PageDown>


"
"
""""""fin de: source wiki bepo"""""""""""""""

" <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>

Mes abbréviations de type programmation (parenthèses, crochets etc) plus quelques exemples

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