Skip to content
Snippets Groups Projects
Select Git revision
  • 90ac3e2cf65b29f7959a4bcb0d828526625d0256
  • develop default protected
  • feature/local-dt-fsi
  • save_clemence
  • feature/advection
  • feature/reconstruction
  • feature/kinetic-schemes
  • feature/composite-scheme-sources
  • feature/composite-scheme-other-fluxes
  • origin/stage/bouguettaia
  • feature/variational-hydro
  • feature/gmsh-reader
  • feature/serraille
  • feature/composite-scheme
  • hyperplastic
  • feature/polynomials
  • feature/gks
  • feature/implicit-solver-o2
  • feature/coupling_module
  • feature/implicit-solver
  • feature/merge-local-dt-fsi
  • v0.5.0 protected
  • v0.4.1 protected
  • v0.4.0 protected
  • v0.3.0 protected
  • v0.2.0 protected
  • v0.1.0 protected
  • Kidder
  • v0.0.4 protected
  • v0.0.3 protected
  • v0.0.2 protected
  • v0 protected
  • v0.0.1 protected
33 results

CMakeLists.txt

Blame
    • Tutoriel.html 104.46 KiB 
    <?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="fr" xml:lang="fr">
<head>
<!-- 2021-02-02 mar. 07:52 -->
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Un court tutoriel pour Emacs</title>
<meta name="generator" content="Org mode" />
<style type="text/css">
 <!--/*--><![CDATA[/*><!--*/
  .title  { text-align: center;
             margin-bottom: .2em; }
  .subtitle { text-align: center;
              font-size: medium;
              font-weight: bold;
              margin-top:0; }
  .todo   { font-family: monospace; color: red; }
  .done   { font-family: monospace; color: green; }
  .priority { font-family: monospace; color: orange; }
  .tag    { background-color: #eee; font-family: monospace;
            padding: 2px; font-size: 80%; font-weight: normal; }
  .timestamp { color: #bebebe; }
  .timestamp-kwd { color: #5f9ea0; }
  .org-right  { margin-left: auto; margin-right: 0px;  text-align: right; }
  .org-left   { margin-left: 0px;  margin-right: auto; text-align: left; }
  .org-center { margin-left: auto; margin-right: auto; text-align: center; }
  .underline { text-decoration: underline; }
  #postamble p, #preamble p { font-size: 90%; margin: .2em; }
  p.verse { margin-left: 3%; }
  pre {
    border: 1px solid #ccc;
    box-shadow: 3px 3px 3px #eee;
    padding: 8pt;
    font-family: monospace;
    overflow: auto;
    margin: 1.2em;
  }
  pre.src {
    position: relative;
    overflow: visible;
    padding-top: 1.2em;
  }
  pre.src:before {
    display: none;
    position: absolute;
    background-color: white;
    top: -10px;
    right: 10px;
    padding: 3px;
    border: 1px solid black;
  }
  pre.src:hover:before { display: inline;}
  /* Languages per Org manual */
  pre.src-asymptote:before { content: 'Asymptote'; }
  pre.src-awk:before { content: 'Awk'; }
  pre.src-C:before { content: 'C'; }
  /* pre.src-C++ doesn't work in CSS */
  pre.src-clojure:before { content: 'Clojure'; }
  pre.src-css:before { content: 'CSS'; }
  pre.src-D:before { content: 'D'; }
  pre.src-ditaa:before { content: 'ditaa'; }
  pre.src-dot:before { content: 'Graphviz'; }
  pre.src-calc:before { content: 'Emacs Calc'; }
  pre.src-emacs-lisp:before { content: 'Emacs Lisp'; }
  pre.src-fortran:before { content: 'Fortran'; }
  pre.src-gnuplot:before { content: 'gnuplot'; }
  pre.src-haskell:before { content: 'Haskell'; }
  pre.src-hledger:before { content: 'hledger'; }
      pre.src-java:before { content: 'Java'; }
  pre.src-js:before { content: 'Javascript'; }
  pre.src-latex:before { content: 'LaTeX'; }
  pre.src-ledger:before { content: 'Ledger'; }
  pre.src-lisp:before { content: 'Lisp'; }
  pre.src-lilypond:before { content: 'Lilypond'; }
  pre.src-lua:before { content: 'Lua'; }
  pre.src-matlab:before { content: 'MATLAB'; }
  pre.src-mscgen:before { content: 'Mscgen'; }
  pre.src-ocaml:before { content: 'Objective Caml'; }
  pre.src-octave:before { content: 'Octave'; }
  pre.src-org:before { content: 'Org mode'; }
  pre.src-oz:before { content: 'OZ'; }
  pre.src-plantuml:before { content: 'Plantuml'; }
  pre.src-processing:before { content: 'Processing.js'; }
  pre.src-python:before { content: 'Python'; }
  pre.src-R:before { content: 'R'; }
  pre.src-ruby:before { content: 'Ruby'; }
  pre.src-sass:before { content: 'Sass'; }
  pre.src-scheme:before { content: 'Scheme'; }
  pre.src-screen:before { content: 'Gnu Screen'; }
  pre.src-sed:before { content: 'Sed'; }
  pre.src-sh:before { content: 'shell'; }
  pre.src-sql:before { content: 'SQL'; }
  pre.src-sqlite:before { content: 'SQLite'; }
  /* additional languages in org.el's org-babel-load-languages alist */
  pre.src-forth:before { content: 'Forth'; }
  pre.src-io:before { content: 'IO'; }
  pre.src-J:before { content: 'J'; }
  pre.src-makefile:before { content: 'Makefile'; }
  pre.src-maxima:before { content: 'Maxima'; }
  pre.src-perl:before { content: 'Perl'; }
  pre.src-picolisp:before { content: 'Pico Lisp'; }
  pre.src-scala:before { content: 'Scala'; }
  pre.src-shell:before { content: 'Shell Script'; }
  pre.src-ebnf2ps:before { content: 'ebfn2ps'; }
  /* additional language identifiers per "defun org-babel-execute"
       in ob-*.el */
  pre.src-cpp:before  { content: 'C++'; }
  pre.src-abc:before  { content: 'ABC'; }
  pre.src-coq:before  { content: 'Coq'; }
  pre.src-groovy:before  { content: 'Groovy'; }
  /* additional language identifiers from org-babel-shell-names in
     ob-shell.el: ob-shell is the only babel language using a lambda to put
     the execution function name together. */
  pre.src-bash:before  { content: 'bash'; }
  pre.src-csh:before  { content: 'csh'; }
  pre.src-ash:before  { content: 'ash'; }
  pre.src-dash:before  { content: 'dash'; }
  pre.src-ksh:before  { content: 'ksh'; }
  pre.src-mksh:before  { content: 'mksh'; }
  pre.src-posh:before  { content: 'posh'; }
  /* Additional Emacs modes also supported by the LaTeX listings package */
  pre.src-ada:before { content: 'Ada'; }
  pre.src-asm:before { content: 'Assembler'; }
  pre.src-caml:before { content: 'Caml'; }
  pre.src-delphi:before { content: 'Delphi'; }
  pre.src-html:before { content: 'HTML'; }
  pre.src-idl:before { content: 'IDL'; }
  pre.src-mercury:before { content: 'Mercury'; }
  pre.src-metapost:before { content: 'MetaPost'; }
  pre.src-modula-2:before { content: 'Modula-2'; }
  pre.src-pascal:before { content: 'Pascal'; }
  pre.src-ps:before { content: 'PostScript'; }
  pre.src-prolog:before { content: 'Prolog'; }
  pre.src-simula:before { content: 'Simula'; }
  pre.src-tcl:before { content: 'tcl'; }
  pre.src-tex:before { content: 'TeX'; }
  pre.src-plain-tex:before { content: 'Plain TeX'; }
  pre.src-verilog:before { content: 'Verilog'; }
      pre.src-vhdl:before { content: 'VHDL'; }
  pre.src-xml:before { content: 'XML'; }
  pre.src-nxml:before { content: 'XML'; }
  /* add a generic configuration mode; LaTeX export needs an additional
     (add-to-list 'org-latex-listings-langs '(conf " ")) in .emacs */
  pre.src-conf:before { content: 'Configuration File'; }

  table { border-collapse:collapse; }
  caption.t-above { caption-side: top; }
  caption.t-bottom { caption-side: bottom; }
  td, th { vertical-align:top;  }
  th.org-right  { text-align: center;  }
  th.org-left   { text-align: center;   }
  th.org-center { text-align: center; }
  td.org-right  { text-align: right;  }
  td.org-left   { text-align: left;   }
  td.org-center { text-align: center; }
  dt { font-weight: bold; }
  .footpara { display: inline; }
  .footdef  { margin-bottom: 1em; }
  .figure { padding: 1em; }
  .figure p { text-align: center; }
  .equation-container {
    display: table;
    text-align: center;
    width: 100%;
  }
  .equation {
    vertical-align: middle;
  }
  .equation-label {
    display: table-cell;
    text-align: right;
    vertical-align: middle;
  }
  .inlinetask {
    padding: 10px;
    border: 2px solid gray;
    margin: 10px;
    background: #ffffcc;
  }
  #org-div-home-and-up
   { text-align: right; font-size: 70%; white-space: nowrap; }
  textarea { overflow-x: auto; }
  .linenr { font-size: smaller }
  .code-highlighted { background-color: #ffff00; }
  .org-info-js_info-navigation { border-style: none; }
  #org-info-js_console-label
    { font-size: 10px; font-weight: bold; white-space: nowrap; }
  .org-info-js_search-highlight
    { background-color: #ffff00; color: #000000; font-weight: bold; }
  .org-svg { width: 90%; }
  /*]]>*/-->
</style>
<link rel="stylesheet" type="text/css" href="styles/readtheorg/css/htmlize.css"/>
<link rel="stylesheet" type="text/css" href="styles/readtheorg/css/readtheorg.css"/>
<script type="text/javascript" src="styles/lib/js/jquery.min.js"></script>
<script type="text/javascript" src="styles/lib/js/bootstrap.min.js"></script>
<script type="text/javascript" src="styles/lib/js/jquery.stickytableheaders.min.js"></script>
<script type="text/javascript" src="styles/readtheorg/js/readtheorg.js"></script>
<script type="text/javascript">
/*
@licstart  The following is the entire license notice for the
JavaScript code in this tag.

Copyright (C) 2012-2020 Free Software Foundation, Inc.

The JavaScript code in this tag is free software: you can
redistribute it and/or modify it under the terms of the GNU
General Public License (GNU GPL) as published by the Free Software
    Foundation, either version 3 of the License, or (at your option)
any later version.  The code is distributed WITHOUT ANY WARRANTY;
without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE.  See the GNU GPL for more details.

As additional permission under GNU GPL version 3 section 7, you
may distribute non-source (e.g., minimized or compacted) forms of
that code without the copy of the GNU GPL normally required by
section 4, provided you include this license notice and a URL
through which recipients can access the Corresponding Source.


@licend  The above is the entire license notice
for the JavaScript code in this tag.
*/
<!--/*--><![CDATA[/*><!--*/
 function CodeHighlightOn(elem, id)
 {
   var target = document.getElementById(id);
   if(null != target) {
     elem.cacheClassElem = elem.className;
     elem.cacheClassTarget = target.className;
     target.className = "code-highlighted";
     elem.className   = "code-highlighted";
   }
 }
 function CodeHighlightOff(elem, id)
 {
   var target = document.getElementById(id);
   if(elem.cacheClassElem)
     elem.className = elem.cacheClassElem;
   if(elem.cacheClassTarget)
     target.className = elem.cacheClassTarget;
 }
/*]]>*///-->
</script>
<script type="text/x-mathjax-config">
    MathJax.Hub.Config({
        displayAlign: "center",
        displayIndent: "0em",

        "HTML-CSS": { scale: 100,
                        linebreaks: { automatic: "false" },
                        webFont: "TeX"
                       },
        SVG: {scale: 100,
              linebreaks: { automatic: "false" },
              font: "TeX"},
        NativeMML: {scale: 100},
        TeX: { equationNumbers: {autoNumber: "AMS"},
               MultLineWidth: "85%",
               TagSide: "right",
               TagIndent: ".8em"
             }
});
</script>
<script type="text/javascript"
        src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS_HTML"></script>
</head>
<body>
<div id="content">
<h1 class="title">Un court tutoriel pour Emacs</h1>
<div id="table-of-contents">
<h2>Table des matières</h2>
<div id="text-table-of-contents">
<ul>
<li><a href="#orgfd15d5f">1. Historique</a></li>
<li><a href="#org4abc37d">2. Lancement d'Emacs</a></li>
<li><a href="#org62d9413">3. Prise en main</a>
<ul>
    <li><a href="#org4f2fb9a">3.1. Interface</a>
<ul>
<li><a href="#org79f9ff2">3.1.1. <i>Buffers</i></a></li>
<li><a href="#org3149d71">3.1.2. <i>Windows</i></a></li>
<li><a href="#orgab1867f">3.1.3. Cadre (<i>frames</i>)</a></li>
<li><a href="#org3b8c8c3">3.1.4. <i>Modeline</i></a></li>
<li><a href="#org3ba71ec">3.1.5. <i>Minibuffer</i></a></li>
</ul>
</li>
<li><a href="#org2ad55f5">3.2. Fonctions</a></li>
</ul>
</li>
<li><a href="#org607cbcd">4. Quelques raccourcis</a>
<ul>
<li><a href="#orgf7067b3">4.1. Commandes générales</a></li>
<li><a href="#org6e84cf9">4.2. <i>minibuffer</i></a></li>
<li><a href="#org1f9ca5e">4.3. Obtenir de l'aide</a></li>
<li><a href="#orga4907ca">4.4. Naviguer dans un <i>buffer</i></a></li>
<li><a href="#orgb4d0481">4.5. Marquer une zone d'un <i>buffer</i></a></li>
<li><a href="#org9409fd9">4.6. Éditer le contenu d'un <i>buffer</i></a></li>
<li><a href="#orgb1b0a52">4.7. Gestion des <i>buffers</i>, fenêtres et cadres</a>
<ul>
<li><a href="#orga6f1d97">4.7.1. <i>buffers</i></a></li>
<li><a href="#org5042de0">4.7.2. Fenêtres</a></li>
<li><a href="#org7b5456d">4.7.3. Cadres (<i>frames</i>)</a></li>
</ul>
</li>
<li><a href="#org0a67876">4.8. Fichiers</a></li>
<li><a href="#orgc27f06a">4.9. Recherche</a></li>
<li><a href="#orgbdac216">4.10. Remplacement de texte</a></li>
<li><a href="#orgd58f9ea">4.11. Répétitions et macros</a></li>
<li><a href="#orgf90567b">4.12. Complétion</a></li>
</ul>
</li>
<li><a href="#org39dda89">5. Modes utiles</a>
<ul>
<li><a href="#org8edc7d1">5.1. Modes utilitaires</a>
<ul>
<li><a href="#org89cbbb4">5.1.1. Flyspell</a></li>
<li><a href="#org57f7c02">5.1.2. FlyCheck</a></li>
</ul>
</li>
<li><a href="#org73f7f8c">5.2. Interfaces avec <code>git</code></a>
<ul>
<li><a href="#org2ce2cb9">5.2.1. GitGutter</a></li>
<li><a href="#orgd629488">5.2.2. Magit</a></li>
</ul>
</li>
<li><a href="#org6d15d06">5.3. Rédaction de documents LaTeX</a>
<ul>
<li><a href="#org6d6c20b">5.3.1. AUCTeX</a></li>
<li><a href="#org4b74bdf">5.3.2. RefTeX</a></li>
</ul>
</li>
<li><a href="#org064b31d">5.4. Programmation</a>
<ul>
<li><a href="#org2fab2f8">5.4.1. Python</a></li>
<li><a href="#orgaa1c6cc">5.4.2. C++</a></li>
<li><a href="#orgc444ccd">5.4.3. YASnippet</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#orgcc3782a">6. Pour aller plus loin</a>
<ul>
<li><a href="#orgcfcb89f">6.1. Org-mode</a></li>
<li><a href="#orgd0cb9bc">6.2. Pliage et dépliage avec <code>narrow-or-widen-dwim</code></a></li>
<li><a href="#org6f718b1">6.3. Autres modes installés</a></li>
<li><a href="#orgf346812">6.4. Personnalisation</a>
<ul>
    <li><a href="#orgd23a4f3">6.4.1. custom.el</a></li>
<li><a href="#org5923d3c">6.4.2. Emacs lisp</a></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>


<div id="outline-container-orgfd15d5f" class="outline-2">
<h2 id="orgfd15d5f"><span class="section-number-2">1</span> Historique</h2>
<div class="outline-text-2" id="text-1">
<p>
<a href="https://fr.wikipedia.org/wiki/Emacs">Emacs</a> (initialement pour <i><b>Editing MACroS</b> running on TECO</i>) fut créé
par <a href="https://fr.wikipedia.org/wiki/Richard_Stallman">Richard M. Stallman</a> (dit RMS) et <a href="https://fr.wikipedia.org/wiki/Guy_L._Steele,_Jr.">Guy L. Steele</a> en 1976. Il
s'agissait alors d'une collection de macro-commandes pour simplifier
l'utilisation de <a href="https://fr.wikipedia.org/wiki/TECO">TECO</a> (1964) qui était un langage de programmation
pour l'édition de fichier orienté ligne.
</p>

<p>
En 1983 RMS lance le projet <a href="https://fr.wikipedia.org/wiki/Projet_GNU">GNU</a> et l'une de ses premières tâches est
de le doter d'un éditeur digne de ce nom. Profitant de son expérience
et en s'inspirant de <a href="https://fr.wikipedia.org/wiki/Gosling_Emacs">Gosling Emacs</a> il crée <a href="https://fr.wikipedia.org/wiki/GNU_Emacs">GNU Emacs</a>. Pour cela, il
l'écrit en <a href="https://fr.wikipedia.org/wiki/C_(langage)">C</a> et permet l'écriture d'extensions en <a href="https://fr.wikipedia.org/wiki/Emacs_Lisp">Emacs Lisp</a>. C'est
probablement cette extensibilité qui fait que malgré son âge avancé,
Emacs est l'un des outils les plus utilisés pour le développement.
</p>
</div>
</div>

<div id="outline-container-org4abc37d" class="outline-2">
<h2 id="org4abc37d"><span class="section-number-2">2</span> Lancement d'Emacs</h2>
<div class="outline-text-2" id="text-2">
<p>
Pour lancer Emacs, il suffit de taper la commande
</p>
<div class="org-src-container">
<pre class="src src-bash">emacs
</pre>
</div>
<p>
dans un terminal. Si le terminal ne permet pas l'ouverture de fenêtres
graphiques (pas de <code>DISPLAY</code>), Emacs démarrera alors en mode texte. Si
on utilise l'option <code>-nw</code>, pour <i>no window</i>, on force le lancement d'Emacs
en mode texte.
</p>
<div class="org-src-container">
<pre class="src src-bash">emacs -nw
</pre>
</div>
<p>
Attention dans ce mode, pour quitter Emacs, il faut utiliser le
raccourcis clavier <code>C-x C-c</code> (contrôle-x puis contrôle-c). Une dernière
option pratique est l'option <code>-q</code>. Son effet est de lancer Emacs sans
utiliser la configuration locale.
</p>
<div class="org-src-container">
<pre class="src src-bash">emacs -q
</pre>
</div>
</div>
</div>

<div id="outline-container-org62d9413" class="outline-2">
<h2 id="org62d9413"><span class="section-number-2">3</span> Prise en main</h2>
<div class="outline-text-2" id="text-3">
<p>
    La prise en main d'Emacs n'est pas difficile pour une utilisation
basique. En mode graphique Emacs dispose de menus qui permettent
d'accéder à toutes les opérations classiques. Néanmoins, pour
l'utiliser plus efficacement, il convient de comprendre un peu son
fonctionnement.
</p>

<p>
Comme on l'a dit, Emacs a vu le jour comme un ensemble de <b>macros</b>,
c'est-à-dire des enchaînements de commandes simples ou d'autres
macros.  Ces macros (ou plus précisément ces <b>fonctions</b>) sont toujours
un des piliers du fonctionnement d'Emacs. Le nombre de fonctions
proposées par Emacs est très important et pour y accéder rapidement
Emacs permet l'usage de raccourcis clavier. C'est en apprenant et en
utilisant ces raccourcis qu'on gagne en productivité. L'utilisation de
la souris avec Emacs est donc souvent contre productive. Enfin on peut
facilement créer et enregistrer des enchaînements de commandes pour
éviter les tâches répétitives.
</p>

<p>
Une première façon d'apprendre un peu Emacs est d'effectuer le
<b>tutoriel intégré</b> qu'il propose. Pour démarrer le tutoriel il suffit de
saisir le raccourcis <code>C-h t</code>. Pour le novice, cela signifie qu'on doit
taper sur la touche contrôle (<code>C</code>) et sur la touche <code>h</code> simultanément,
puis sur la touche <code>t</code> seulement.
</p>
</div>

<div id="outline-container-org4f2fb9a" class="outline-3">
<h3 id="org4f2fb9a"><span class="section-number-3">3.1</span> Interface</h3>
<div class="outline-text-3" id="text-3-1">
<p>
Globalement, l'interface d'Emacs est assez intuitive, mais elle a
conservé tous les ingrédients qui en faisaient sa richesse alors que
ce n'était pas une application graphique (la première version
graphique de GNU Emacs est la 19, sortie en 1994). Certains de ses
concepts ne sont donc pas si communs de nos jours.
</p>
</div>

<div id="outline-container-org79f9ff2" class="outline-4">
<h4 id="org79f9ff2"><span class="section-number-4">3.1.1</span> <i>Buffers</i></h4>
<div class="outline-text-4" id="text-3-1-1">
<p>
Un <i>buffer</i> est une zone tampon et la plus petite unité d'édition. Il
correspond en général à la vue d'un fichier édité.
</p>
</div>
</div>

<div id="outline-container-org3149d71" class="outline-4">
<h4 id="org3149d71"><span class="section-number-4">3.1.2</span> <i>Windows</i></h4>
<div class="outline-text-4" id="text-3-1-2">
<p>
Il est possible de visualiser plusieurs <i>buffers</i> simultanément dans
Emacs. Chaque vue est appelée <b>fenêtre</b>. Attention, dans le jargon
Emacs, une fenêtre n'est pas à confondre avec les fenêtres gérées par
le <i>window-manager</i> de l'interface graphique (voir
figure <a href="#org7089324">1</a>, où un <a href="#org9f1e54c">cadre</a> Emacs est découpé en trois
fenêtres). On peut afficher un <b>même</b> <i>buffer</i> dans différentes fenêtres
et il peut être modifié dans n'importe laquelle de ses vues.
</p>


<div id="org7089324" class="figure">
<p><img src="emacs-windows.png" alt="emacs-windows.png" />
</p>
<p><span class="figure-number">Figure&nbsp;1&nbsp;: </span>Trois fenêtres affichées dans Emacs</p>
</div>
    </div>
</div>

<div id="outline-container-orgab1867f" class="outline-4">
<h4 id="orgab1867f"><span class="section-number-4">3.1.3</span> <a id="org9f1e54c"></a> Cadre (<i>frames</i>)</h4>
<div class="outline-text-4" id="text-3-1-3">
<p>
Lorsqu'il est exécuté en mode graphique, une même instance d'Emacs
peut proposer plusieurs cadres (<i>frames</i>) d'affichage. Il s'agit en fait
de plusieurs fenêtres du gestionnaire graphique.
</p>

<p>
Dans l'exemple de la figure <a href="#org7367172">2</a>, il s'agit bien de la même
instance d'Emacs&nbsp;: on a lancé un seul exécutable, mais on a ouvert un
cadre (<i>frame</i>) supplémentaire. Dans chacun des cadres, on affiche une
vue d'un <b>même</b> <i>buffer</i> d'édition, c'est-à-dire que le <b>même</b> <i>buffer</i> peut
être modifié par l'intermédiaire de l'un ou l'autre des cadres.
</p>


<div id="org7367172" class="figure">
<p><img src="emacs-frames.png" alt="emacs-frames.png" />
</p>
<p><span class="figure-number">Figure&nbsp;2&nbsp;: </span>Deux cadres (<i>frames</i>) Emacs affichant le même <i>buffer</i></p>
</div>
</div>
</div>

<div id="outline-container-org3b8c8c3" class="outline-4">
<h4 id="org3b8c8c3"><span class="section-number-4">3.1.4</span> <i>Modeline</i></h4>
<div class="outline-text-4" id="text-3-1-4">
<p>
Dans Emacs, chaque <i>buffer</i> est délimité <b>en bas</b> par la <i>modeline</i>. Il
s'agit d'une zone dans laquelle sont affichées divers informations
quant au mode de fonctionnement d'Emacs dans son <i>buffer</i>. On la voit en
action sur la figure <a href="#org68b050b">3</a>, le mode majeur est <code>CMake</code>, le
fichier édité s'appelle <code>CMakeList.txt</code>, enfin, on travaille sur la
branche <code>develop</code>.
</p>


<div id="org68b050b" class="figure">
<p><img src="emacs-modeline.png" alt="emacs-modeline.png" />
</p>
<p><span class="figure-number">Figure&nbsp;3&nbsp;: </span>La <i>modeline</i>. Ici on voit qu'on est en mode <code>CMake</code>, que le fichier édité s'appelle <code>CMakeList.txt</code> et qu'on travaille sur la branche <code>develop</code>.</p>
</div>
</div>
</div>

<div id="outline-container-org3ba71ec" class="outline-4">
<h4 id="org3ba71ec"><span class="section-number-4">3.1.5</span> <i>Minibuffer</i></h4>
<div class="outline-text-4" id="text-3-1-5">
<p>
Le <i>minibuffer</i> est un <i>buffer</i> spécial d'Emacs. C'est la zone
d'interaction avec l'utilisateur. C'est là qu'on doit répondre aux
éventuelles questions d'Emacs et c'est là qu'on tape les commandes. Il
faut donc le garder constamment à l'oeil. Voir la
figure <a href="#org30746d0">4</a> (ici une exécution de <code>grep</code> dans Emacs en
préparation). Pour exécuter une commande dans le <i>minibuffer</i> il faut
taper <code>M-x</code>.
</p>


<div id="org30746d0" class="figure">
<p><img src="emacs-minibuffer.png" alt="emacs-minibuffer.png" />
</p>
<p><span class="figure-number">Figure&nbsp;4&nbsp;: </span>Le <i>minibuffer</i> en action. Préparation de l'exécution d'une commande <code>grep</code> dans Emacs.</p>
</div>
</div>
    </div>
</div>

<div id="outline-container-org2ad55f5" class="outline-3">
<h3 id="org2ad55f5"><span class="section-number-3">3.2</span> Fonctions</h3>
<div class="outline-text-3" id="text-3-2">
<p>
Dans Emacs, tout est fonction. Et toute fonction peut-être redéfinie
localement (dans un <i>buffer</i>), globalement (dans tout Emacs) ou en
fonction du <b>mode</b> (dans une famille de <i>buffers)</i>.
</p>

<p>
Par exemple, presser une touche (quel que soit le contexte) déclenche
l'appel d'une fonction et cette fonction dépend du contexte dans
lequel la touche est pressée. C'est ce concepts qui fait d'Emacs un
outil aussi puissant et versatile. Les fonctions peuvent être de deux
types. Ce sont
</p>
<ul class="org-ul">
<li>soit des fonctions internes (écrites en <code>C</code>),</li>
<li>soit des fonctions utilisateur (écrites en <code>ELisp</code>).</li>
</ul>
<p>
Par le passé, ce deuxième type de fonctions pouvait dégrader les
performances d'Emacs (si bien que certains lui donnaient l'acronyme
récursif <i>Emacs Makes All Computer Slow</i>). Mais les gains de
performances des ordinateurs et l'utilisation d'<code>ELisp</code> <i>byte</i>-compilé
plutôt que simplement interprété ont corrigé ce défaut.
</p>
</div>
</div>
</div>

<div id="outline-container-org607cbcd" class="outline-2">
<h2 id="org607cbcd"><span class="section-number-2">4</span> Quelques raccourcis</h2>
<div class="outline-text-2" id="text-4">
<p>
On présente dans cette partie certains raccourcis utiles. Lorsque les
raccourcis de cette configuration diffèrent des raccourcis standard
d'Emacs, on l'indique.
</p>

<p>
Mais rappelons tout d'abord les notations et principes.
</p>
<ul class="org-ul">
<li><code>C-a</code> signifie qu'on appuie simultanément sur les touches <code>Ctrl</code>
(contrôle) et <code>a</code>.</li>
<li><code>C-M-a</code> signifie qu'on appuie simultanément sur les touches <code>Ctrl</code>,
<code>Meta</code> (<code>Alt</code> sur les claviers modernes) et <code>a</code>.</li>
<li><code>C-S-a</code> signifie qu'on appuie simultanément sur les touches <code>Ctrl</code>, <code>Maj</code> et <code>a</code>.</li>
<li><code>C-a C-b c</code> signifie qu'on appuie simultanément sur les touches
<code>Ctrl</code> et <code>a</code>, puis simultanément sur les touches <code>Ctrl</code> et <code>b</code>,
puis sur la touche <code>c</code>.</li>
</ul>

<p>
On ne liste ici que quelques unes des commandes (et raccourcis),
seulement une liste de celles qu'on juge importantes.
</p>

<p>
Noter que cette configuration utilise le mode <code>which-key</code>, dont l'une
des fonctionnalités est de fournir une aide dans le <i>minibuffer</i> lors de
la saisie de commandes. Par exemple, si on tape <code>C-x</code>, au bout d'un
instant <code>which-key</code> affiche dans le <i>minibuffer</i> la liste des commandes
qui commencent par <code>C-x</code>. C'est donc un excellent moyen de retrouver les
raccourcis et d'en apprendre de nouveaux. Cette aide est évidemment
contextuelle.
    </p>
</div>

<div id="outline-container-orgf7067b3" class="outline-3">
<h3 id="orgf7067b3"><span class="section-number-3">4.1</span> Commandes générales</h3>
<div class="outline-text-3" id="text-4-1">
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-x C-c</code></td>
<td class="org-left">Sort d'Emacs</td>
</tr>

<tr>
<td class="org-left"><code>C-g</code></td>
<td class="org-left">Interrompt la commande en cours</td>
</tr>

<tr>
<td class="org-left"><code>C-S-g</code></td>
<td class="org-left">Force l'interruption de la commande</td>
</tr>

<tr>
<td class="org-left"><code>M-x</code></td>
<td class="org-left">Lance une commande (dans le <i>minibuffer</i>)</td>
</tr>

<tr>
<td class="org-left"><code>C-c C-n</code></td>
<td class="org-left">Relance l'évaluation du <i>buffer</i> (<code>normal-mode</code>)</td>
</tr>
</tbody>
</table>
</div>
</div>

<div id="outline-container-org6e84cf9" class="outline-3">
<h3 id="org6e84cf9"><span class="section-number-3">4.2</span> <i>minibuffer</i></h3>
<div class="outline-text-3" id="text-4-2">
<p>
Lors d'une interaction avec le <i>minibuffer</i>, on a accès à certains
raccourcis qui facilitent son utilisation.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
    </thead>
<tbody>
<tr>
<td class="org-left"><code>M-x</code></td>
<td class="org-left">Lance une interaction dans le <i>minibuffer</i></td>
</tr>

<tr>
<td class="org-left"><code>C-x ESC ESC</code></td>
<td class="org-left">Édite la dernière commande dans le <i>minibuffer</i></td>
</tr>

<tr>
<td class="org-left"><code>TAB</code></td>
<td class="org-left">Complète l'entrée autant que possible</td>
</tr>
</tbody>
</table>
<p>
Cette configuration utilise <code>swiper</code>, donc toutes les interactions
effectuées dans le <i>minibuffer</i> proposent la liste des commandes
disponibles qui correspondent à la chaîne entrée (<code>SPC</code> faisant office
de n'importe quelle liste de caractères). Il est alors possible de
naviguer dans cette liste (en utilisant les flèches du clavier pas
exemple)
</p>
</div>
</div>

<div id="outline-container-org1f9ca5e" class="outline-3">
<h3 id="org1f9ca5e"><span class="section-number-3">4.3</span> Obtenir de l'aide</h3>
<div class="outline-text-3" id="text-4-3">
<p>
On peut lancer l'aide en tapant <code>C-h</code> et en suivant les indications du
<i>minibuffer</i>.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-h t</code></td>
<td class="org-left">Lance le tutoriel intégré</td>
</tr>

<tr>
<td class="org-left"><code>C-h m</code></td>
<td class="org-left">Informations sur le mode courant</td>
</tr>

<tr>
<td class="org-left"><code>C-h i</code></td>
<td class="org-left">Accède à la documentation (<code>info</code>)</td>
</tr>

<tr>
<td class="org-left"><code>C-h a</code></td>
<td class="org-left"><b>à propos</b> (interaction dans le <i>minibuffer</i>)</td>
</tr>
    </tbody>
</table>
</div>
</div>

<div id="outline-container-orga4907ca" class="outline-3">
<h3 id="orga4907ca"><span class="section-number-3">4.4</span> Naviguer dans un <i>buffer</i></h3>
<div class="outline-text-3" id="text-4-4">
<p>
Au delà des flèches et autres touches usuelles du clavier, Emacs
propose d'autres moyens de se déplacer dans un <i>buffer</i>.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-b</code></td>
<td class="org-left">Recule d'un caractère</td>
</tr>

<tr>
<td class="org-left"><code>C-f</code></td>
<td class="org-left">Avance d'un caractère</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><code>M-b</code></td>
<td class="org-left">Recule d'un mot</td>
</tr>

<tr>
<td class="org-left"><code>M-f</code></td>
<td class="org-left">Avance d'un mot</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><code>C-p</code></td>
<td class="org-left">Ligne précédente</td>
</tr>

<tr>
<td class="org-left"><code>C-n</code></td>
<td class="org-left">Ligne suivante</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><code>C-a</code></td>
<td class="org-left">Début de ligne</td>
</tr>

<tr>
<td class="org-left"><code>C-e</code></td>
<td class="org-left">Fin de ligne</td>
</tr>
</tbody>
    <tbody>
<tr>
<td class="org-left"><code>M-a</code></td>
<td class="org-left">Début de la phrase</td>
</tr>

<tr>
<td class="org-left"><code>M-e</code></td>
<td class="org-left">Fin de la phrase</td>
</tr>

<tr>
<td class="org-left"><code>M-m</code></td>
<td class="org-left">Début de l'indentation</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><code>M-g g</code> <i>numéro</i></td>
<td class="org-left">Positionne le curseur à la ligne numéro <i>numéro</i></td>
</tr>
</tbody>
</table>

<p>
Noter qu'on peut généralement utiliser des combinaisons de <code>Ctrl</code>,
<code>Meta</code>,&#x2026;  avec les touches de déplacement du clavier (comme les
flèches).
</p>
</div>
</div>

<div id="outline-container-orgb4d0481" class="outline-3">
<h3 id="orgb4d0481"><span class="section-number-3">4.5</span> Marquer une zone d'un <i>buffer</i></h3>
<div class="outline-text-3" id="text-4-5">
<p>
Une zone est délimitée par une une <b>marque</b> (position de départ) et la
position courante du curseur Créer une zone consiste donc à poser une
<b>marque</b>, puis à déplacer le curseur pour la délimiter. Tous les
caractères compris entre ces deux positions font partie de la zone.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-SPC</code> ou <code>C-@</code></td>
<td class="org-left">Pose une <b>marque</b></td>
</tr>

<tr>
<td class="org-left"><code>C-g</code></td>
<td class="org-left">Supprime la <b>marque</b></td>
</tr>

<tr>
<td class="org-left"><code>C-x C-x</code></td>
<td class="org-left">Inverse la <b>marque</b> et le curseur</td>
</tr>
    
<tr>
<td class="org-left"><code>C-=</code></td>
<td class="org-left">Sélectionne un mot ou étend la sélection</td>
</tr>
</tbody>
</table>
<p>
Noter qu'un enchaînement de <code>C-=</code> permet d'étendre rapidement la zone
aux entités faisant sens. En effet, <code>C-=</code> s'arrête aux guillemets
encadrant une chaîne de caractères, aux paramètres ou au corps d'une
fonction par exemple, ce qui permet de facilement les sélectionner.
</p>
</div>
</div>

<div id="outline-container-org9409fd9" class="outline-3">
<h3 id="org9409fd9"><span class="section-number-3">4.6</span> Éditer le contenu d'un <i>buffer</i></h3>
<div class="outline-text-3" id="text-4-6">
<p>
Le commandes citées ici concernent essentiellement les <b>modes</b> d'édition
classiques. Il est possible que pour certains modes les raccourcis ne
fonctionnent pas ou n'aient simplement pas de sens.  Dans ces modes
d'édition classiques (modes de saisie par exemple), le clavier
fonctionne normalement. On précise simplement ici quelques commandes
usuelles.
</p>

<p>
L'action des commandes d'édition décrites ci-dessous est effectuée
relativement à la position courante du curseur.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>DEL</code></td>
<td class="org-left"><b>Efface</b> un caractère vers la gauche</td>
</tr>

<tr>
<td class="org-left"><code>C-d</code> ou <code>SUPR</code></td>
<td class="org-left"><b>Efface</b> le caractère sous le curseur</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><code>DEL</code> ou <code>SUPR</code></td>
<td class="org-left"><b>Efface</b> une zone sélectionnée</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><code>C-DEL</code>, <code>M-DEL</code> ou <code>C-w</code></td>
<td class="org-left"><b>Coupe</b> le mot vers la gauche</td>
</tr>

<tr>
    <td class="org-left"><code>M-d</code></td>
<td class="org-left"><b>Coupe</b> le mot vers la droite</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><code>M-0 C-k</code></td>
<td class="org-left"><b>Coupe</b> jusqu'au début de la ligne</td>
</tr>

<tr>
<td class="org-left"><code>C-k</code></td>
<td class="org-left"><b>Coupe</b> jusqu'à la fin de la ligne</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><code>C-w</code></td>
<td class="org-left"><b>Coupe</b> une zone sélectionnée</td>
</tr>

<tr>
<td class="org-left"><code>M-w</code></td>
<td class="org-left"><b>Copie</b> une zone sélectionnée</td>
</tr>

<tr>
<td class="org-left"><code>M-z</code> <i>caractère</i></td>
<td class="org-left"><b>Coupe</b> jusqu'au prochain caractère <i>caractère</i></td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><code>C-_</code> ou <code>C-/</code> ou <code>C-x u</code></td>
<td class="org-left">Annule la dernière saisie/commande</td>
</tr>
</tbody>
</table>
<p>
Noter qu'avec cette configuration d'Emacs, si le caractère à effacer
est un <b>blanc</b>, tous les blancs suivants dans la direction d'effacement
sont supprimés.
</p>

<p>
Puisqu'on vient d'aborder comment <b>copier</b> ou <b>couper</b> une zone du texte,
nous allons décrire le <b>coller</b>. Là encore, le vocable Emacs n'est pas
standard. L'action <b>couper</b> dans Emacs se nomme <b><i>kill</i></b> et <b>coller</b>,
<b><i>yank</i></b>. On comprend ainsi mieux les choix de lettres <code>k</code> et <code>y</code> dans ce
contexte.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-y</code></td>
<td class="org-left"><b>Colle</b> la dernière sélection <b>copiée</b></td>
</tr>
    
<tr>
<td class="org-left"><code>M-y</code></td>
<td class="org-left">Remplace le texte collé par la copie précédente</td>
</tr>
</tbody>
</table>
<p>
En fait, Emacs conserve toutes les copies en mémoire (<i>kill-ring</i>) et on
peut donc les utiliser à tout moment. Dans sa version de base,
parcourir le <i>kill-ring</i> nécessite d'abord un <b>coller</b>. C'est-à-dire qu'il
faut effectuer <code>C-y</code> and de taper <code>M-y</code> pour le parcourir.
</p>

<p>
Cette configuration d'Emacs utilise <code>swiper</code> et le parcours du <i>kill-ring</i>
est amélioré. En effet, <code>swiper</code> propose l'utilisation directe de <code>M-y</code> et
plutôt que de remplacer le texte <i>en ligne</i> comme le fait la version de
base, on y accède dans le <i>minibuffer</i>. On peut alors le parcourir, soit
en continuant à presser <code>M-y</code>, soit en utilisant les flèches du clavier,
soit même en entrant les une partie du texte comme pour les
<a href="#orgbfc33b6">recherches</a>.
</p>
</div>
</div>

<div id="outline-container-orgb1b0a52" class="outline-3">
<h3 id="orgb1b0a52"><span class="section-number-3">4.7</span> Gestion des <i>buffers</i>, fenêtres et cadres</h3>
<div class="outline-text-3" id="text-4-7">
</div>
<div id="outline-container-orga6f1d97" class="outline-4">
<h4 id="orga6f1d97"><span class="section-number-4">4.7.1</span> <i>buffers</i></h4>
<div class="outline-text-4" id="text-4-7-1">
<p>
Dans cette configuration, on utilise le paquet <code>IBuffer</code> à la place du
mode <code>Buffer</code> classique. Il fonctionne avec les mêmes raccourcis de
base.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-x b</code></td>
<td class="org-left">Choisit un autre <i>buffer</i></td>
</tr>

<tr>
<td class="org-left"><code>C-x C-b</code></td>
<td class="org-left">Ouvre le mode <code>IBuffer</code></td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><code>C-x k</code></td>
<td class="org-left">Choisit un <i>buffer</i> à fermer</td>
</tr>

<tr>
    <td class="org-left"><code>C-x k RET</code></td>
<td class="org-left">Ferme le <i>buffer</i> courant</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><code>C-x left</code></td>
<td class="org-left">Retourne au <i>buffer</i> précédent</td>
</tr>

<tr>
<td class="org-left"><code>C-x right</code></td>
<td class="org-left">Retourne au <i>buffer</i> suivant</td>
</tr>
</tbody>
</table>
<p>
Noter que les raccourcis <code>C-x left</code> et <code>C-x right</code> (où <code>left</code> et <code>right</code>
désignent les flèches du clavier) sont extrêmement utiles et il est
important de les mémoriser. On parle bien ici de retrouver le <i>buffer</i>
précédent ou suivant dans la même fenêtre.
</p>

<p>
Lorsqu'on ferme un <i>buffer</i>, si les données n'ont pas été sauvegardées
Emacs invite l'utilisateur à le faire.
</p>
</div>
</div>

<div id="outline-container-org5042de0" class="outline-4">
<h4 id="org5042de0"><span class="section-number-4">4.7.2</span> Fenêtres</h4>
<div class="outline-text-4" id="text-4-7-2">
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-x 1</code></td>
<td class="org-left">Agrandit la fenêtre pour qu'elle occupe tout le cadre</td>
</tr>

<tr>
<td class="org-left"><code>C-x 2</code></td>
<td class="org-left">Découpe la fenêtre courante horizontalement</td>
</tr>

<tr>
<td class="org-left"><code>C-x 3</code></td>
<td class="org-left">Découpe la fenêtre courante verticalement</td>
</tr>

<tr>
<td class="org-left"><code>C-x 0</code></td>
<td class="org-left">Ferme la fenêtre courante</td>
</tr>
</tbody>
<tbody>
<tr>
    <td class="org-left"><code>C-x o</code></td>
<td class="org-left">Positionne le curseur dans une autre fenêtre</td>
</tr>
</tbody>
</table>

<p>
Pour la gestion des fenêtres, on utilise le mode <code>ace-window</code> qui ajoute
la fonctionnalité suivante. Si plus de deux fenêtres sont actives dans
le cadre courant, <code>C-x o</code> affiche alors des numéros dans chacune des
fenêtres. On entre ce numéro pour basculer dans la fenêtre choisie.
</p>

<p>
On utilise aussi <code>window-jump</code> qui permet de changer intuitivement de
fenêtre en utilisant les flèches du clavier. S'il y a plusieurs
possibilités, la fenêtre choisie est celle alignée avec le curseur.
Dans cette configuration, les raccourcis sont les suivants.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-M-right</code></td>
<td class="org-left">Déplace le curseur dans une fenêtre à droite</td>
</tr>

<tr>
<td class="org-left"><code>C-M-left</code></td>
<td class="org-left">Déplace le curseur dans une fenêtre à gauche</td>
</tr>

<tr>
<td class="org-left"><code>C-M-up</code></td>
<td class="org-left">Déplace le curseur dans une fenêtre au dessus</td>
</tr>

<tr>
<td class="org-left"><code>C-M-down</code></td>
<td class="org-left">Déplace le curseur dans une fenêtre en dessous</td>
</tr>
</tbody>
</table>
</div>
</div>

<div id="outline-container-org7b5456d" class="outline-4">
<h4 id="org7b5456d"><span class="section-number-4">4.7.3</span> Cadres (<i>frames</i>)</h4>
<div class="outline-text-4" id="text-4-7-3">
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
    <tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-x 5 0</code></td>
<td class="org-left">Ferme le cadre actif</td>
</tr>

<tr>
<td class="org-left"><code>C-x 5 1</code></td>
<td class="org-left">Ferme tous les autres cadres</td>
</tr>

<tr>
<td class="org-left"><code>C-x 5 2</code></td>
<td class="org-left">Crée un nouveau cadre</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>

<div id="outline-container-org0a67876" class="outline-3">
<h3 id="org0a67876"><span class="section-number-3">4.8</span> Fichiers</h3>
<div class="outline-text-3" id="text-4-8">
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-x C-f</code></td>
<td class="org-left">Recherche incrémentale d'un fichier ou le crée</td>
</tr>

<tr>
<td class="org-left"><code>C-x C-s</code></td>
<td class="org-left">Sauvegarde le <i>buffer</i> courant</td>
</tr>

<tr>
<td class="org-left"><code>C-x s</code></td>
<td class="org-left">Sauvegarde tous les <i>buffers</i></td>
</tr>

<tr>
<td class="org-left"><code>C-x C-w</code></td>
<td class="org-left">Sauvegarde le <i>buffer</i> courant dans un nouveau fichier</td>
</tr>

<tr>
<td class="org-left"><code>C-x i</code></td>
<td class="org-left">Insère le contenu d'un fichier dans le <i>buffer</i></td>
</tr>
</tbody>
</table>
    
<div style="color: red;" class="mdframed">
<p>
<b>IMPORTANT</b>
</p>

<p>
Si on souhaite créer un nouveau fichier avec <code>C-x C-f</code> dont le nom est
une sous chaîne d'un fichier existant, il ne faut pas utiliser <code>RET</code>
pour valider, mais <code>C-M-j</code>. Utiliser <code>RET</code> valide la recherche.
</p>

<p>
Une autre façon de créer le fichier <code>foo</code>, si un fichier correspondant à
l'expression <i>foo</i> existe (par exemple <code>foobar</code>), consiste à interrompre
la recherche incrémentale en sélectionnant la <b>zone de saisie</b> avec les
flèches puis à taper <code>RET</code>.
</p>

</div>

<p>
<b>Ouverture de fichiers/répertoirs distants.</b> À noter que cette
configuration d'Emacs utilise le mode <code>TRAMP</code> pour (<i>Transparent Remote
Access, Multiple Protocols</i>) qui permet l'ouverture de fichiers à
distance depuis Emacs.
</p>

<p>
Pour que l'édition distante fonctionne, il suffit que la connexion par
<code>ssh</code> soit autorisée.
</p>

<p>
L'intérêt de ce mode est évident puisqu'on n'a pas besoin de
réinstaller l'environnement Emacs sur cette nouvelle machine, pour
travailler dans son environnement usuel. Il suffit de pouvoir s'y
connecter par <code>ssh</code>.
</p>

<p>
Pour ouvrir un fichier distant, il suffit d'utiliser le raccourci
<code>C-x C-f</code>, puis d'écrire dans le <code>minibuffer</code>
</p>
<div class="org-src-container">
<pre class="src src-bash">/sshx:username@hostname:
</pre>
</div>
<p>
À partir de là, si on presse <code>RET</code>, Emacs ouvrira un <code>dired</code> <i>buffer</i> (c'est
à dire un buffer permettant de manipuler les fichiers du répertoire
<code>HOME</code> de l'utilisateur sur la machine distante. On peut aussi utiliser
<code>TAB</code> pour voir alors la liste des fichiers accessibles dans le
<i>minibuffer</i>, la complétion fonctionnant comme en local.
</p>

<p>
Une fois un fichier ouvert, il est manipulé classiquement dans le
<i>buffer</i> et seule la sauvegarde du fichier nécessite la connexion.
</p>
</div>
</div>

<div id="outline-container-orgc27f06a" class="outline-3">
<h3 id="orgc27f06a"><span class="section-number-3">4.9</span> Recherche</h3>
<div class="outline-text-3" id="text-4-9">
<table id="orgbfc33b6" border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
    <col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-s</code></td>
<td class="org-left">Recherche une chaîne dans le <i>buffer</i> vers le <b>bas</b></td>
</tr>

<tr>
<td class="org-left"><code>C-r</code></td>
<td class="org-left">Recherche une chaîne dans le <i>buffer</i> vers le <b>haut</b></td>
</tr>

<tr>
<td class="org-left"><code>C-s C-w</code></td>
<td class="org-left">Complète la chaîne à chercher avec le mot courant</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><code>C-M-s</code></td>
<td class="org-left">Recherche une expression régulière vers le <b>bas</b></td>
</tr>

<tr>
<td class="org-left"><code>C-M-r</code></td>
<td class="org-left">Recherche une expression régulière vers le <b>haut</b></td>
</tr>
</tbody>
</table>
<p>
Une fois une occurrence trouvée, on peut poursuivre la recherche vers
le bas ou vers le haut, en faisant respectivement <code>C-s</code> ou
<code>C-r</code>. Puisqu'on utilise pas le mode standard de recherche d'Emacs, mais
le mode <code>swiper</code>, il est possible de naviguer dans le <i>minibuffer</i> avec
les flèches pour se déplacer d'une occurrence à l'autre.
</p>

<p>
Noter qu'en mode recherche (on a déjà pressé <code>C-s</code>) le raccourci <code>C-w</code>
ajoute le mot suivant le curseur à la recherche. On recherche ainsi
rapidement une suite de mots (les mots cherchés doivent être sur une
même ligne).
</p>

<p>
Quand la recherche est terminée,
</p>
<ul class="org-ul">
<li>soit on utilise <code>C-g</code> pour revenir où on était quand on a commencé
la recherche,</li>
<li>soit <code>RET</code> pour continuer l'édition du <i>buffer</i> à la position de
l'occurrence.</li>
</ul>

<p>
Une autre particularité intéressante de <code>swiper</code> est son utilisation de
<code>SPC</code> qui sert de joker pendant les saisies. Voir par exemple, la
figure <a href="#orgc86c6f8">5</a>, où on a lancé une recherche puis tapé
<code>y t x(</code> dans le <i>minibuffer</i>, les lignes correspondantes y sont
affichées. On peut parcourir cette liste à l'aide des flèches du
clavier, le <i>buffer</i> de recherche suit l'occurrence sélectionnée.
    </p>


<div id="orgc86c6f8" class="figure">
<p><img src="emacs-swiper-search.png" alt="emacs-swiper-search.png" />
</p>
<p><span class="figure-number">Figure&nbsp;5&nbsp;: </span>Exemple de recherche avec `swiper`</p>
</div>

<p>
Attention si on utilise <code>C-S-s C-w</code>, on n'utilise pas <code>swiper</code> pour la
recherche, mais l'outil recherche incrémentale classique d'Emacs. Il
est possible d'ajouter des mots à la recherche en faisant à nouveau
<code>C-w</code>.
</p>
</div>
</div>

<div id="outline-container-orgbdac216" class="outline-3">
<h3 id="orgbdac216"><span class="section-number-3">4.10</span> Remplacement de texte</h3>
<div class="outline-text-3" id="text-4-10">
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>M-%</code></td>
<td class="org-left">Remplacer les occurrences d'une chaîne par une autre</td>
</tr>
</tbody>
</table>
<p>
La recherche des chaînes à remplacer se déroule depuis la position du
curseur vers la fin du <i>buffer</i>.
</p>

<p>
Il s'agit d'un mode <b>interactif</b>. Pour chaque occurrence de la chaîne à
remplacer, Emacs attend une validation.
</p>
<ul class="org-ul">
<li>Pour remplacer l'occurrence trouvée, taper <code>y</code>.</li>
<li>Pour ne pas la remplacer, presser <code>n</code>.</li>
<li>Pour interrompre le processus de remplacement, taper <code>q</code> ou <code>C-g</code>.</li>
<li>Pour tout remplacer, jusqu'à la fin du <i>buffer</i>, taper <code>!</code>.</li>
</ul>
<p>
Noter que le mode de remplacement est <i>intelligent</i> au sens où il
respecte la casse si possible.
</p>

<p>
Si on demande le remplacement de <code>foo</code> par <code>bar</code> on obtient les résultats
suivants.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
    <col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Chaîne initiale</th>
<th scope="col" class="org-left">Résultat</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>foobar</code></td>
<td class="org-left"><code>barbar</code></td>
</tr>

<tr>
<td class="org-left"><code>barfooFoobar</code></td>
<td class="org-left"><code>barbarBarbar</code></td>
</tr>

<tr>
<td class="org-left"><code>Foobar</code></td>
<td class="org-left"><code>Barbar</code></td>
</tr>

<tr>
<td class="org-left"><code>FOO</code></td>
<td class="org-left"><code>BAR</code></td>
</tr>
</tbody>
</table>
</div>
</div>

<div id="outline-container-orgd58f9ea" class="outline-3">
<h3 id="orgd58f9ea"><span class="section-number-3">4.11</span> Répétitions et macros</h3>
<div class="outline-text-3" id="text-4-11">
<p>
Il existe de nombreuses façons d'automatiser des actions dans Emacs.
Les deux plus simples consistent à répéter une action (<b>macro</b> ou autre)
ou à créer une macro <i>interactivement</i>.
</p>

<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-u</code> <i>nombre</i> <i>commande</i></td>
<td class="org-left">Exécute la commande <i>commande</i>, <i>nombre</i> de fois</td>
</tr>
</tbody>
</table>
<p>
Par exemple, si on tape <code>C-u 10 C-n</code>, on se déplace de 10 lignes vers le
bas dans le fichier.
</p>

    <p>
L'autre manière basique est la création et l'utilisation de macros
<i>clavier</i>.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-(</code></td>
<td class="org-left">Débute la création d'une macro</td>
</tr>

<tr>
<td class="org-left"><code>f3</code></td>
<td class="org-left">Débute la création d'une macro ou insère le compteur</td>
</tr>

<tr>
<td class="org-left"><code>C-)</code></td>
<td class="org-left">Termine la définition d'une macro</td>
</tr>

<tr>
<td class="org-left"><code>C-x e</code> ou <code>f4</code></td>
<td class="org-left">Exécute la dernière macro créée</td>
</tr>
</tbody>
</table>
<p>
Il est donc très facile de créer et d'exécuter une macro clavier avec
Emacs. Mais on peut aller facilement un peu plus loin en utilisant les
commandes suivantes. On rappelle que pour exécuter la commande <i>cmd</i>, il
suffit de taper <code>M-x cmd</code>.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Commande</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>insert-kbd-macro</code></td>
<td class="org-left">Écrit le code (<code>ELisp</code>) de la dernière macro définie</td>
</tr>

<tr>
<td class="org-left"><code>name-last-kbd-macro</code></td>
<td class="org-left">Donne un nom à la dernière macro définie</td>
</tr>
    </tbody>
</table>
</div>
</div>

<div id="outline-container-orgf90567b" class="outline-3">
<h3 id="orgf90567b"><span class="section-number-3">4.12</span> Complétion</h3>
<div class="outline-text-3" id="text-4-12">
<p>
Emacs propose de nombreux moyens de compléter un mot afin d'accélérer
la saisie de texte.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>M-/</code></td>
<td class="org-left">Complète le mot ou propose une nouvelle complétion</td>
</tr>
</tbody>
</table>

<p>
Les complétions proposées sont les mots qui composent les <i>buffers</i>
actifs. Cela n'est pas toujours suffisant mais permet d'éviter
certaines erreurs de frappe.
</p>

<p>
En fait, cette configuration utilise <code>company</code> qui est un moteur de
complétion plus souple et configurable. Le fonctionnement de <code>company</code>
est très intuitif. En effet pendant la saisie de texte, si des
complétion sont possibles, une fenêtre <i>pop-up</i> qui les propose apparaît
(voir figure <a href="#orgfadb32c">6</a>).
</p>

<div id="orgfadb32c" class="figure">
<p><img src="emacs-company.png" alt="emacs-company.png" />
</p>
<p><span class="figure-number">Figure&nbsp;6&nbsp;: </span><i>Pop-up</i> présentant les complétions possibles</p>
</div>

<p>
Pour compléter le texte, plusieurs possibilités sont offertes :
</p>
<ul class="org-ul">
<li>l'utilisation de la touche <code>TAB</code> complète le mot au maximum
(s'arrêtant après complétion de la partie commune à toutes les
alternatives). On peut alors continuer la saisie en entrant le
caractère suivant, et ainsi de suite.</li>
<li>Une autre possibilité consiste à se déplacer dans le menu <i>pop-up</i>
pour choisir une entrée.</li>
</ul>
<p>
Si l'entrée n'est pas dans la liste, le <i>pop-up</i> se ferme
automatiquement lors de la saisie.
</p>

    <p>
Enfin, il est possible de quitter le <i>pop-up</i> en pressant <code>C-g</code> ou en
déplaçant le curseur vers la droite ou vers la gauche.
</p>

<p>
À noter qu'avec cette configuration, la complétion peut-être beaucoup
plus évoluée selon le mode majeur actif. Par exemple, les modes de
programmation proposent une complétion contextuelle. En mode <code>LaTeX</code>,
les commandes LaTeX (qui commencent par un <code>\</code>) sont proposées (même si
elles ne sont pas présentes dans les <i>buffers</i> ouverts). De même, en <code>C++</code>
ou en <code>Python</code> par exemple, la complétion est contextuelle (les types et
variables accessibles, les fonctions ou fonctions membres sont
proposées). Dans certains cas, la complétion donne accès à un mode de
remplissage interactif des arguments de fonctions. On passe d'un
argument à l'autre en tapant <code>TAB</code> et <code>S-TAB</code> (suivant et précédent).
</p>
</div>
</div>
</div>

<div id="outline-container-org39dda89" class="outline-2">
<h2 id="org39dda89"><span class="section-number-2">5</span> Modes utiles</h2>
<div class="outline-text-2" id="text-5">
<p>
On présente ici quelques modes particulièrement utiles. La liste
compète des modes utilisés dans cette configuration (ainsi que
quelques raccourcis basiques est accessible dans le fichier
<a href="Configuration.html">Configuration.org</a>).
</p>

<p>
De plus, on ne décrit que brièvement les modes en question, une
description complète étant hors de portée d'un tel document et
deviendrait inévitablement obsolète.
</p>
</div>

<div id="outline-container-org8edc7d1" class="outline-3">
<h3 id="org8edc7d1"><span class="section-number-3">5.1</span> Modes utilitaires</h3>
<div class="outline-text-3" id="text-5-1">
</div>
<div id="outline-container-org89cbbb4" class="outline-4">
<h4 id="org89cbbb4"><span class="section-number-4">5.1.1</span> Flyspell</h4>
<div class="outline-text-4" id="text-5-1-1">
<p>
Il s'agit d'un mode mineur qui vérifie l'orthographe (uniquement
lexicale) dans un document à la volée.
</p>

<p>
Il est actif dans cette configuration pour certains modes. Par défaut
on a choisi le dictionnaire <i>american</i> qui est finalement souvent le
plus utile.
</p>

<p>
On peut cependant facilement choisir localement le dictionnaire dans
un <i>buffer</i> en utilisant la commande <code>M-x ispell-change-dictionary</code> et en
choisissant le dictionnaire adéquate ou en définissant une variable
locale dans le <i>buffer</i> pour que ce changement intervienne à chaque fois
que le fichier sera ouvert. Par exemple en LaTeX, on pourra mettre le
bloc suivant en fin de fichier.
</p>
<div class="org-src-container">
<pre class="src src-emacs-lisp">% Local Variables&#58;
% ispell-local-dictionary: <span class="org-string">"francais"</span>
% End:
</pre>
</div>
    <p>
Pour désactiver le <code>flyspell</code> dans un fichier, on peut utiliser la
configuration locale. Par exemple en <code>Python</code>, on écrit
</p>
<div class="org-src-container">
<pre class="src src-python"><span class="org-comment-delimiter"># </span><span class="org-comment">Local Variables&#58;</span>
<span class="org-comment-delimiter"># </span><span class="org-comment">eval: (flyspell-mode -1)</span>
<span class="org-comment-delimiter"># </span><span class="org-comment">End:</span>
</pre>
</div>
</div>
</div>

<div id="outline-container-org57f7c02" class="outline-4">
<h4 id="org57f7c02"><span class="section-number-4">5.1.2</span> FlyCheck</h4>
<div class="outline-text-4" id="text-5-1-2">
<p>
Ce mode mineur permet de vérifier la validité du code à la volée. Il
fonctionne pour les langages LaTeX, <code>C++</code>, <code>Python</code>, les scripts
<code>shell</code>,&#x2026;
</p>

<p>
Généralement, ce mode n'est pas très consommateur de CPU car la
compilation est très légère. Il est cependant possible de le déactiver
localement dans un <i>buffer</i>, soit en utilisant la commande
<code>M-x flycheck-mode</code>, soit en définissant une variable locale. En
<code>C++</code>, on peut par exemple utiliser
</p>
<div class="org-src-container">
<pre class="src src-C++"><span class="org-comment-delimiter">// </span><span class="org-comment">Local Variables&#58;</span>
<span class="org-comment-delimiter">// </span><span class="org-comment">eval: (flycheck-mode -1)</span>
<span class="org-comment-delimiter">// </span><span class="org-comment">End:</span>
</pre>
</div>
</div>
</div>
</div>

<div id="outline-container-org73f7f8c" class="outline-3">
<h3 id="org73f7f8c"><span class="section-number-3">5.2</span> Interfaces avec <code>git</code></h3>
<div class="outline-text-3" id="text-5-2">
<p>
Emacs possède différentes interfaces à <code>git</code>. Les deux plus abouties
sont probablement <code>magit</code> et <code>GitGutter</code>. Ces deux modes sont
complémentaires, <code>GitGutter</code> permet d'afficher dans le <i>buffer</i> quelles
lignes ont été modifiées et de voir rapidement ce qu'on a
changé. Quant à <code>magit</code>, c'est une excellente interface à <code>git</code>. En fait
le mode <code>magit</code> à lui seul justifie l'utilisation d'Emacs.
</p>
</div>

<div id="outline-container-org2ce2cb9" class="outline-4">
<h4 id="org2ce2cb9"><span class="section-number-4">5.2.1</span> GitGutter</h4>
<div class="outline-text-4" id="text-5-2-1">
<p>
Le principe de <code>GitGutter</code> est d'afficher (en marge de gauche) les
modifications faites au fichier. La mise à jour (pour ne pas
surcharger l'outil est effectuée à la sauvegarde du fichier).
</p>

<p>
Cette configuration interface <code>GitGutter</code> avec <code>Hydra</code> ce qui permet de
simplifier l'utilisation des raccourcis clavier.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />
    
<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>M-g M-g</code></td>
<td class="org-left">Ouvre le <i>pop-up</i> <code>Hydra</code> pour <code>GitGutter</code></td>
</tr>
</tbody>
</table>

<p>
Une fois qu'on a tapé <code>M-g M-g</code> une fenêtre <i>pop-up</i> apparaît et on peut
alors suivre les indications pour effectuer les commandes de révision
de la version. C'est-à-dire, qu'on peut parcourir les changements,
afficher les changements, ou annuler des changements.
</p>

<p>
On peut également <b>ajouter</b> des zones particulières pour préparer un
commit <code>git</code> mais pour ce genre d'opérations, on préférera utiliser
<code>Magit</code>.
</p>
</div>
</div>

<div id="outline-container-orgd629488" class="outline-4">
<h4 id="orgd629488"><span class="section-number-4">5.2.2</span> Magit</h4>
<div class="outline-text-4" id="text-5-2-2">
<p>
<code>Magit</code> est une superbe interface à <code>git</code> pour Emacs. Encore une fois, il
ne serait pas raisonnable de tenter de fournir une documentation
complète du mode dans ce tutoriel. On se contentera de décrire
simplement quelques éléments de son fonctionnement. Pour une
description plus précise, on se référera au site <a href="https://magit.vc/">web</a> de <code>Magit</code>. Enfin
il est important de préciser que l'aide en ligne de <code>Magit</code> est
simplement excellente.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-x g</code></td>
<td class="org-left">Lance git dans un autre <i>buffer</i></td>
</tr>
</tbody>
</table>
<p>
Le <i>buffer</i> <code>Magit</code> (obtenu en tapant donc <code>C-x g</code>) n'est pas un <i>buffer</i>
d'édition, mais un <i>buffer</i> spécial. Dans ce <i>buffer</i>, les touches du
clavier sont directement surchargées. On a ainsi accès à des nouveaux
raccourcis très simples.
    </p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci <code>Magit</code></th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>h</code></td>
<td class="org-left">Affiche l'aide en ligne</td>
</tr>

<tr>
<td class="org-left"><code>TAB</code></td>
<td class="org-left">(dé)plie la zone du curseur</td>
</tr>

<tr>
<td class="org-left"><code>RET</code></td>
<td class="org-left">Affiche la zone du curseur</td>
</tr>

<tr>
<td class="org-left"><code>g</code></td>
<td class="org-left">Rafraîchit le <i>buffer</i></td>
</tr>

<tr>
<td class="org-left"><code>s</code></td>
<td class="org-left"><i>Stage</i> des modifications (<code>git add</code>)</td>
</tr>

<tr>
<td class="org-left"><code>u</code></td>
<td class="org-left"><i>Unstage</i> des modifications</td>
</tr>

<tr>
<td class="org-left"><code>c</code></td>
<td class="org-left">Démarre un <code>git commit</code> (propose plusieures options)</td>
</tr>

<tr>
<td class="org-left"><code>F</code></td>
<td class="org-left">Lance un <code>git pull</code> (propose plusieures options)</td>
</tr>

<tr>
<td class="org-left"><code>p</code></td>
<td class="org-left">Lance un <code>git push</code> (peut proposer plusieures options)</td>
</tr>

<tr>
<td class="org-left"><code>k</code></td>
<td class="org-left">Annule des modifications ou efface un fichier non suivi</td>
</tr>
</tbody>
</table>
<p>
On insiste sur le fait qu'on n'a listé ici que quelques raccourcis des
plus utiles. L'aide en ligne, accessible donnée par <code>h</code> est très
    complète. Il est par exemple très facile de choisir quelques lignes à
ajouter (<i>stager</i>) en sélectionnant une zone.
</p>
</div>
</div>
</div>

<div id="outline-container-org6d15d06" class="outline-3">
<h3 id="org6d15d06"><span class="section-number-3">5.3</span> Rédaction de documents LaTeX</h3>
<div class="outline-text-3" id="text-5-3">
<p>
La rédaction d'un document LaTeX s'apparente plus à de la
programmation qu'à de l'édition simple de fichiers. De nombreux outils
existent maintenant pour éditer des documents LaTeX, mais il est
également possible de bénéficier de la puissance d'Emacs et de
nombreuses années d'expériences qui ont permis le développement de
modes qui permettent une excellente intégration Emacs/LaTeX.
</p>

<p>
Avant de décrire les principaux modes, rappelons que cette
configuration utilise <code>FlyCheck</code> de sorte que les erreurs de syntaxe
LaTeX sont indiquées à la saisie, ce qui facilite grandement
l'écriture. Cette configuration propose aussi le mode <code>Preview-LaTeX</code>
qui ne sera pas abordé dans ce tutoriel.
</p>
</div>

<div id="outline-container-org6d6c20b" class="outline-4">
<h4 id="org6d6c20b"><span class="section-number-4">5.3.1</span> AUCTeX</h4>
<div class="outline-text-4" id="text-5-3-1">
<p>
<a href="https://www.gnu.org/software/auctex/?lang=fr">AUCTeX</a> est un ensemble de macros Emacs qui permet d'éditer facilement
(et efficacement) des fichiers LaTeX. C'est le mode qui offre la
plupart des fonctionnalités utiles à l'édition LaTeX.
</p>

<p>
Nous rappelons ici quelques raccourcis de base. Pour aller accéder à
la documentation complète d'<code>AUCTeX</code>, on peut parcourir l'aide intégrée
d'Emacs en tapant <code>C-h i</code> et en consultant la rubrique qui lui est
associée.
</p>
</div>

<ol class="org-ol">
<li><a id="org3b3185f"></a>Typographie<br />
<div class="outline-text-5" id="text-5-3-1-1">
<p>
Pour les changements de styles typographiques, tous les raccourcis
débutent par la séquence <code>C-c C-f</code>.  Le changement de fonte dépend du
contexte de saisie : texte ou mathématique. Noter que si on saisit
<code>C-c C-f</code> suivi de n'importe quel caractère Emacs affiche la liste des
possibilités.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />

<col  class="org-left" />

<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
    <tr>
<th scope="col" class="org-left">Raccourcis</th>
<th scope="col" class="org-left">Style</th>
<th scope="col" class="org-left">Comm. (texte)</th>
<th scope="col" class="org-left">Style</th>
<th scope="col" class="org-left">Comm. (math)</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-c C-f C-a</code></td>
<td class="org-left">--</td>
<td class="org-left">--</td>
<td class="org-left">calligraphique</td>
<td class="org-left"><code>\mathcal</code></td>
</tr>

<tr>
<td class="org-left"><code>C-c C-f C-b</code></td>
<td class="org-left">gras</td>
<td class="org-left"><code>\textbf</code></td>
<td class="org-left">gras</td>
<td class="org-left"><code>\mathbf</code></td>
</tr>

<tr>
<td class="org-left"><code>C-c C-f C-c</code></td>
<td class="org-left">petites capitales</td>
<td class="org-left"><code>\textsc</code></td>
<td class="org-left">--</td>
<td class="org-left">--</td>
</tr>

<tr>
<td class="org-left"><code>C-c C-f C-e</code></td>
<td class="org-left">emphase</td>
<td class="org-left"><code>\emph</code></td>
<td class="org-left">emphase</td>
<td class="org-left"><code>\emph</code></td>
</tr>

<tr>
<td class="org-left"><code>C-c C-f C-f</code></td>
<td class="org-left">sans serif</td>
<td class="org-left"><code>\textsf</code></td>
<td class="org-left">sans serif</td>
<td class="org-left"><code>\mathsf</code></td>
</tr>

<tr>
<td class="org-left"><code>C-c C-f TAB</code></td>
<td class="org-left">italique</td>
<td class="org-left"><code>\textit</code></td>
<td class="org-left">italique</td>
<td class="org-left"><code>\mathit</code></td>
</tr>

<tr>
<td class="org-left"><code>C-c C-f C-n</code></td>
<td class="org-left">normal</td>
<td class="org-left"><code>\textnormal</code></td>
<td class="org-left">normal</td>
<td class="org-left"><code>\mathnormal</code></td>
</tr>

<tr>
<td class="org-left"><code>C-c C-f C-r</code></td>
<td class="org-left">roman</td>
<td class="org-left"><code>\textrm</code></td>
<td class="org-left">roman</td>
    <td class="org-left"><code>\mathrm</code></td>
</tr>

<tr>
<td class="org-left"><code>C-c C-f C-s</code></td>
<td class="org-left">penché</td>
<td class="org-left"><code>\textsl</code></td>
<td class="org-left">symbole</td>
<td class="org-left"><code>\mathbb</code></td>
</tr>

<tr>
<td class="org-left"><code>C-c C-f C-t</code></td>
<td class="org-left">machine à écrire</td>
<td class="org-left"><code>\texttt</code></td>
<td class="org-left">machine à écrire</td>
<td class="org-left"><code>\mathtt</code></td>
</tr>

<tr>
<td class="org-left"><code>C-c C-f C-d</code></td>
<td class="org-left">supprime le style</td>
<td class="org-left">--</td>
<td class="org-left">supprime le style</td>
<td class="org-left">--</td>
</tr>

<tr>
<td class="org-left"><code>C-c C-f C-k</code></td>
<td class="org-left">--</td>
<td class="org-left">--</td>
<td class="org-left">eufrak</td>
<td class="org-left"><code>\mathfrak</code></td>
</tr>
</tbody>
</table>
<p>
Noter que si une région est sélectionnée, la commande est appliquée à
la région, sinon, le curseur est positionné entre les accolades.
</p>

<p>
Enfin, si on préfixe les raccourcis précédents par <code>C-u</code> alors, le style
est remplacé par le style demandé. Par exemple, si on avait le texte
suivant
</p>
<div class="org-src-container">
<pre class="src src-latex"><span class="org-font-latex-sedate"><span class="org-keyword">\emph</span></span>{<span class="org-font-latex-italic">Un texte</span>}
</pre>
</div>
<p>
si on utilise la commande <code>C-u C-c C-f C-b</code>, il sera transformé en
</p>
<div class="org-src-container">
<pre class="src src-latex"><span class="org-font-latex-sedate"><span class="org-keyword">\textbf</span></span>{<span class="org-font-latex-bold">Un texte</span>}
</pre>
</div>
</div>
</li>

<li><a id="orgcfdff5b"></a>Sections<br />
<div class="outline-text-5" id="text-5-3-1-2">
<p>
AUCTeX propose moyen de créer les éléments structurants du document.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />
    
<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-c C-s</code></td>
<td class="org-left">Crée une section</td>
</tr>
</tbody>
</table>
<p>
Une fois ce raccourci utilisé, une interaction dans le <i>minibuffer</i>
permet d'entrer son titre et éventuellement le label à lui attribuer.
Comme toujours en LaTeX, il est recommandé d'indiquer des noms
explicites. On préférera utiliser le caractère <code>-</code> plutôt que <code>_</code> pour
éventuellement séparer les termes qui composent le label.
</p>
</div>
</li>

<li><a id="org71f8349"></a>Environnements<br />
<div class="outline-text-5" id="text-5-3-1-3">
<p>
De la même manière, on écrit des environnements simplement en
utilisant des raccourcis.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-c C-e</code></td>
<td class="org-left">Ajoute un environnement</td>
</tr>
</tbody>
</table>
<p>
Ici encore, quand le raccourci a été utilisé, les environnements
possibles sont proposés dans le <i>minibuffer</i> et éventuellement, on
propose de saisir un label.
</p>

<p>
Comme dans le cas des changements typographiques, si une région était
sélectionnée, les balises <code>begin</code> et <code>end</code> entourent la zone. Sinon, le
curseur est placé entre les balises.
</p>
</div>
</li>

<li><a id="org9c53c97"></a>Compilation et visualisation<br />
<div class="outline-text-5" id="text-5-3-1-4">
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
    

<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-c C-c</code> ou <code>C-c C-z</code></td>
<td class="org-left">Accède à une commande LaTeX</td>
</tr>

<tr>
<td class="org-left"><code>C-c C-k</code></td>
<td class="org-left">Tue le processus LaTeX actif</td>
</tr>

<tr>
<td class="org-left"><code>C-c C-l</code></td>
<td class="org-left">Affiche la sortie de compilation</td>
</tr>
</tbody>
</table>
<p>
En fait, lorsqu'on invoque <code>C-c C-c</code> ou <code>C-c C-z</code>, la liste des commandes
proposées comprend la compilation du document, la compilation de la
bibliographie, la visualisation du document produit,&#x2026; Par défaut
<code>AUCTeX</code> propose l'action qu'il juge naturelle. Par exemple, si le
document n'a pas besoin d'être recompilé il proposera sa
visualisation.
</p>

<p>
Cette configuration utilise <code>pdf-tools</code> pour visualiser les documents
produits. Cela a plusieurs avantages, les <code>pdf</code> sont affichés
directement dans Emacs (dans une nouvelle <b>fenêtre</b>, mais on peut
évidemment utiliser un autre <b>cadre</b>. De plus, on utilise <code>synctex</code> qui
permet de synchroniser le source <code>tex</code> et le <code>pdf</code> produit. Ainsi si on
utilise <code>C-mouse1</code> ou le double-clic (<code>mouse1 mouse1</code>) sur une zone du
document <code>pdf</code> produit, Emacs positionne le curseur sur la partie du
source LaTeX associé. De même, on peut visualiser la zone du document
<code>pdf</code> correspondant au curseur dans les sources en utilisant le
raccourci <code>C-c C-g</code>. On rappelle dans le tableau suivant quelques
raccourcis utiles pour la visualisation.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><i>Dans les sources</i></td>
<td class="org-left">&#xa0;</td>
    </tr>

<tr>
<td class="org-left"><code>C-c C-a</code></td>
<td class="org-left">Génère et affiche le <code>pdf</code> (enchaîne toutes les commandes)</td>
</tr>

<tr>
<td class="org-left"><code>C-c C-v</code></td>
<td class="org-left">Affiche le <code>pdf</code> s'il existe</td>
</tr>

<tr>
<td class="org-left"><code>C-c C-g</code></td>
<td class="org-left">Synchronise la vue du <code>pdf</code> avec les sources au curseur</td>
</tr>
</tbody>
<tbody>
<tr>
<td class="org-left"><i>Dans le</i> <i><code>pdf</code></i></td>
<td class="org-left">&#xa0;</td>
</tr>

<tr>
<td class="org-left"><code>C-mouse1</code> (ou double clic)</td>
<td class="org-left">Positionne le curseur dans les sources correspondantes</td>
</tr>

<tr>
<td class="org-left"><code>PageUp</code></td>
<td class="org-left">Aller à la page précédente</td>
</tr>

<tr>
<td class="org-left"><code>PageDown</code></td>
<td class="org-left">Aller à la page suivante</td>
</tr>

<tr>
<td class="org-left"><code>SPC</code></td>
<td class="org-left">Avance dans le document</td>
</tr>

<tr>
<td class="org-left"><code>DEL</code></td>
<td class="org-left">Recule dans le document</td>
</tr>

<tr>
<td class="org-left"><code>B</code></td>
<td class="org-left">Retourne en arrière (page précédemment visitée)</td>
</tr>

<tr>
<td class="org-left"><code>N</code></td>
<td class="org-left">Retourne en avant (inverse de <code>B</code>)</td>
</tr>
</tbody>
</table>
</div>
</li>
</ol>
</div>

<div id="outline-container-org4b74bdf" class="outline-4">
<h4 id="org4b74bdf"><span class="section-number-4">5.3.2</span> RefTeX</h4>
<div class="outline-text-4" id="text-5-3-2">
<p>
<code>AUCTeX</code> est distribué avec <code>RefTeX</code> qui est un mode mineur qui permet une
gestion simplifiée des références. Que ce soient des références à des
    équations, des figures, des tables ou des citations
bibliographiques. <code>RefTeX</code> analyse le fichier source (ou les fichiers si
nécessaire) pour déterminer les références possibles.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-c (</code></td>
<td class="org-left">Ajoute un label</td>
</tr>

<tr>
<td class="org-left"><code>C-c )</code></td>
<td class="org-left">Crée une référence</td>
</tr>

<tr>
<td class="org-left"><code>C-c [</code></td>
<td class="org-left">Insère une référence bibliographique</td>
</tr>

<tr>
<td class="org-left"><code>C-c /</code></td>
<td class="org-left">Ajoute une référence à un index ou un glossaire</td>
</tr>
</tbody>
</table>
<p>
Une fois la commande activée, l'interaction est classique et se
déroule soit dans le <i>minibuffer</i> soit dans un <i>buffer</i> annexe.
</p>
</div>
</div>
</div>

<div id="outline-container-org064b31d" class="outline-3">
<h3 id="org064b31d"><span class="section-number-3">5.4</span> Programmation</h3>
<div class="outline-text-3" id="text-5-4">
<p>
On l'a déjà dit, cette configuration d'Emacs propose par défaut
l'utilisation de <code>flycheck</code> qui active une compilation (légère) à la
volée du <i>buffer</i>, ce qui aide à rapidement trouver les erreurs de
syntaxe.
</p>

<p>
La plupart des modes de programmation nécessitent l'installation
d'outils annexes pour fonctionner. On se reportera donc au fichier
<a href="Installation.html">Installation.org</a> pour des détails à ce sujet.
</p>
</div>

<div id="outline-container-org2fab2f8" class="outline-4">
<h4 id="org2fab2f8"><span class="section-number-4">5.4.1</span> Python</h4>
<div class="outline-text-4" id="text-5-4-1">
<p>
On utilise le paquet <code>jedi</code> qui gère la complétion dans Emacs pour
    <code>Python</code>. On se reportera donc à la documentation en ligne
<a href="http://tkf.github.io/emacs-jedi/latest/">http://tkf.github.io/emacs-jedi/latest/</a>, pour plus d'informations.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-c C-c</code></td>
<td class="org-left">Exécute le script</td>
</tr>

<tr>
<td class="org-left"><code>C-c C-z</code></td>
<td class="org-left">Passe du <i>buffer</i> du code à la console d'exécution ou inversement</td>
</tr>

<tr>
<td class="org-left"><code>S-TAB</code> ou <code>backtab</code></td>
<td class="org-left">Supprime une indentation</td>
</tr>
</tbody>
</table>
<p>
Il existe également, une interface à <code>Jupyter</code>, mais cette dernière ne
fait pas partie de cette configuration.
</p>

<p>
Enfin, si on exécute les scripts dans Emacs <code>C-c C-c</code>, le terminal
occupe un <i>buffer</i> interactif (c'est-à-dire qu'on peut y entrer des
commandes comme dans n'importe quel terminal), où il est possible,
comme dans les <i>buffers</i> de compilation de cliquer sur les lignes
d'erreur pour positionner le curseur dans la ligne correspondante des
sources.
</p>
</div>
</div>

<div id="outline-container-orgaa1c6cc" class="outline-4">
<h4 id="orgaa1c6cc"><span class="section-number-4">5.4.2</span> C++</h4>
<div class="outline-text-4" id="text-5-4-2">
<p>
Pour la complétion et la correction syntaxique à la volée, on utilise
le paquet <code>lsp</code>. Il est nécessaire pour cette fonctionnalité de
configurer correctement le système et en particulier de disposer d'une
version adaptée d <code>clangd</code> (voir les consignes d'installation).
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
    <th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-c C-c</code></td>
<td class="org-left">Affiche l'invite de compilation dans le <i>minibuffer</i></td>
</tr>

<tr>
<td class="org-left"><code>C-c `</code></td>
<td class="org-left">Positionne le curseur à la première erreur de compilation</td>
</tr>

<tr>
<td class="org-left"><code>M-&lt;down&gt;</code></td>
<td class="org-left">Positionne le curseur à la prochaine erreur de compilation</td>
</tr>

<tr>
<td class="org-left"><code>M-&lt;up&gt;</code></td>
<td class="org-left">Positionne le curseur à l'erreur de compilation précédente</td>
</tr>
</tbody>
</table>
<p>
Le <i>buffer</i> de compilation est interactif : si on clique sur un message
d'erreur, les sources sont ouvertes et le curseur est positionné à
l'endroit correspondant. Il est donc très pratique de compiler dans
Emacs plutôt que dans un terminal.
</p>

<p>
On notera également que si on laisse le curseur positionné sur un mot
du code source, le <i>minibuffer</i> affiche des informations concernant le
type ou l'objet en question.
</p>

<p>
Si on positionne le curseur de la souris sur un élément, son type (ou
sa signature) est affiché dans une fenêtre <i>popup</i>.
</p>

<p>
Il est aussi possible de naviguer simplement dans les sources en
utilisant par exemple les raccourcis suivants.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>M-.</code> ou <code>C-&lt;mouse1&gt;</code></td>
<td class="org-left">Se rend à la déclaration de l'élément sous le curseur</td>
</tr>

<tr>
<td class="org-left"><code>M-?</code></td>
<td class="org-left">Affiche les références à l'élément sous le curseur</td>
    </tr>

<tr>
<td class="org-left"><code>C-l</code></td>
<td class="org-left">Débute l'interaction <code>hydra</code></td>
</tr>

<tr>
<td class="org-left"><code>C-&lt;mouse3&gt;</code></td>
<td class="org-left">Menu contextuel</td>
</tr>
</tbody>
</table>
<p>
D'autres actions plus puissantes, d'aide au <i>refactoring</i> sont également
possibles. Il est possible de renommer un élément dans tout le projet
par exemple.
</p>
</div>
</div>

<div id="outline-container-orgc444ccd" class="outline-4">
<h4 id="orgc444ccd"><span class="section-number-4">5.4.3</span> YASnippet</h4>
<div class="outline-text-4" id="text-5-4-3">
<p>
Il n'est pas envisageable d'écrire un tutoriel Emacs sans évoquer les
<code>snippets</code>. Commençons donc par rappeler de quoi il s'agit. Les <code>snippets</code>
(littéralement <b>fragments</b> en français) sont des patrons (<i>template</i>) de
code qui évitent de taper toujours et encore des motifs de code qui se
répètent. Emacs offre depuis très longtemps des <code>snippets</code> qui
permettent souvent de n'écrire que les zones du code faisant
sens. <code>YASnippet</code> s'est imposé comme la version la plus aboutie et est
maintenant la plus utilisée.
</p>

<p>
Il faut bien intégrer le fait que les <code>snippets</code> ne sont pas des
morceaux de code simplement insérés mais de véritables modèles. Quand
on les utilise, Emacs invite l'utilisateur à renseigner certains
champs (en ligne) ce qui permet d'obtenir directement le code
correspondant au patron sans autre modification.
</p>

<p>
Notons également que <code>YASnippet</code> est livré avec une collection
impressionnante de modèles. Ces patrons sont accessibles selon le
contexte d'édition : les patrons utiles au <code>Python</code>, à la rédaction
LaTeX ou au <code>C++</code>, par exemple ne sont proposés que dans leur mode. Au
vu de leur nombre, il serait impensable d'en faire une quelconque
liste ici, mais on peut en avoir la liste dans le menu <code>YASnippet</code> ou en
tapant la commande <code>M-x yas-describe-tables</code> qui ouvre un buffer
contenant tous les <code>snippets</code> disponibles.
</p>

<p>
Un autre avantage de <code>YASnippet</code> est qu'il est très facile d'ajouter de
nouveaux modèles, mais nous ne décrivons pas la procédure ici (voir
<a href="http://joaotavora.github.io/yasnippet">http://joaotavora.github.io/yasnippet</a> pour les détails).
</p>

<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
    <th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-RET</code></td>
<td class="org-left">Développe le modèle</td>
</tr>
</tbody>
</table>
<p>
Dans cette configuration, on a désactivé le raccourci usuel <del><code>TAB</code></del>, qui
pouvait avoir des effets inattendus et désagréables, au profit de
<code>C RET</code>. En effet, l'effet principal de <code>TAB</code> est l'indentation du code,
mais si le <i>mini-mode</i> de <code>YASnippet</code> interceptait un développement de
modèle possible, il prenait la main et remplaçait l'indentation
demandée par une expansion de modèle. Le nouveau raccourci reste
simple et n'interfère plus avec les fonctions usuelles.
</p>

<p>
On termine cette courte introduction en donnant un exemple
d'utilisation en <code>C++</code>. Si on écrit <code>cls</code> et si on utilise immédiatement
le raccourci <code>C-RET</code>, le modèle (simple) de <b>classe</b> est utilisé. On
obtient alors
</p>
<div class="org-src-container">
<pre class="src src-C++"><span class="org-keyword">class</span> <span class="org-type">Name</span>
<span class="org-rainbow-delimiters-depth-1">{</span>
<span class="org-keyword">public</span>:
  <span class="org-function-name">Name</span><span class="org-rainbow-delimiters-depth-2">()</span>;
  <span class="org-keyword">virtual</span> ~<span class="org-function-name">Name</span><span class="org-rainbow-delimiters-depth-2">()</span>;
<span class="org-rainbow-delimiters-depth-1">}</span>;
</pre>
</div>
<p>
Le curseur est alors positionné sur le premier <code>Name</code> qui est en fait
éditable. On est toujours en train d'appliquer le modèle et il suffit
maintenant (sans autre action) d'entrer le nom de la classe. Par
exemple, si on écrit <code>Tableau</code> (une seule fois), on obtient
</p>
<div class="org-src-container">
<pre class="src src-C++"><span class="org-keyword">class</span> <span class="org-type">Tableau</span>
<span class="org-rainbow-delimiters-depth-1">{</span>
<span class="org-keyword">public</span>:
  <span class="org-function-name">Tableau</span><span class="org-rainbow-delimiters-depth-2">()</span>;
  <span class="org-keyword">virtual</span> ~<span class="org-function-name">Tableau</span><span class="org-rainbow-delimiters-depth-2">()</span>;
<span class="org-rainbow-delimiters-depth-1">}</span>;
</pre>
</div>
<p>
On n'a modifié qu'un champ pour obtenir ce résultat. <code>TAB</code> permet de
passer au champ suivant s'il y en a d'autres et <code>S-TAB</code> (ou <code>backtab</code>)
permet de revenir à l'édition d'un champ précédent. Pour obtenir ce
résultat, on a simplement pressé la suite de touches suivantes.
</p>
<pre class="example">
c l s C-RET T a b l e a u
</pre>
<p>
Cet exemple simple illustre bien l'efficacité de l'approche.
</p>
</div>
</div>
</div>
</div>

<div id="outline-container-orgcc3782a" class="outline-2">
<h2 id="orgcc3782a"><span class="section-number-2">6</span> Pour aller plus loin</h2>
    <div class="outline-text-2" id="text-6">
</div>
<div id="outline-container-orgcfcb89f" class="outline-3">
<h3 id="orgcfcb89f"><span class="section-number-3">6.1</span> Org-mode</h3>
<div class="outline-text-3" id="text-6-1">
<p>
Une fois encore, il est inenvisageable de faire un tour complet de ce
mode dans un tel document. On va donc seulement en tracer les grandes
lignes et décrire certaines de ses fonctionnalités. Pour vraiment en
appréhender les possibilités, il faut consulter les multiples
ressources disponibles sur le net, et en particulier des vidéos de
démonstrations.
</p>

<p>
Initialement, <code>Org-mode</code> est un outil conçu pour la gestion, le suivi et
l'archivage de tâches personnelles. La gestion d'agenda n'en est plus
aujourd'hui qu'un aspect mineur. Son intégration à Emacs est
extrêmement poussée<sup><a id="fnr.1" class="footref" href="#fn.1">1</a></sup> et tire profit de l'interopérabilité des
différents modes d'Emacs. Il bénéficie donc d'une extensibilité assez
spectaculaire.  <code>Org-mode</code> définit un véritable langage de
(méta-)programmation et utilise son propre format de fichier <code>.org</code>.
</p>

<p>
Même si un document <code>Org-mode</code> est <b>lisible</b> avec n'importe quel éditeur
de texte, de nombreux rendus sont possibles : <code>Markdown</code>, texte (ASCII
ou UTF-8), <code>PDF</code> (générés en LaTeX), <code>HTML</code>, <code>OpenDocument</code>,&#x2026; On peut
publier des <i>blogs</i>, générer des présentations (<code>Beamer</code> ou autres). Et
<code>Org-mode</code> permet beaucoup d'autres choses encore.
</p>

<p>
L'une des forces d'<code>Org-mode</code> est la possibilité d'insérer des blocs de
code (dans de nombreux langages) directement dans le
document. <code>Org-mode</code> peut alors les évaluer en les compilant ou en les
exécutant par exemple. Dans un même document, on peut par exemple
utiliser des programmes <code>C++</code> ou <code>Python</code>, des script <code>shell</code>, des commandes
LaTeX, des instructions <code>gnuplot</code>, tracer des graphes ou des diagrammes
avec <code>dot</code>,&#x2026; <code>Org-mode</code> permet en plus de faire communiquer ces
différents programmes. Dans un document <code>Org-mode</code>, il est possible
d'afficher des images en ligne. On peut aussi créer des tableaux
dynamiques (provenant d'évaluations de blocs de code par exemple) ou
statiques. On peut écrire des formules mathématiques en ligne, c'est à
dire sans définir des zones de code source, en utilisant directement
des formules LaTeX (<code>$(a+b)^2 = a^2+2ab+b^2$</code> est interprété directement
\((a+b)^2 = a^2+2ab+b^2\)),&#x2026;
</p>

<p>
Ce document (et ce n'est qu'un exemple <b>très</b> simple) est rédigé en
<code>Org-mode.</code> C'est aussi le cas du fichier de configuration
<a href="Configuration.html">(Configuration.org</a>). Cette pratique est devenue un standard de nos
jours. On préfère écrire une configuration en <code>Org-mode</code> plutôt que
directement en <code>Elisp</code>.  Cela donne une véritable structure au document
et donc, en améliore beaucoup la lisibilité. Au delà, on peut même
exporter le contenu (en <code>HTML</code> par exemple) pour obtenir une véritable
documentation de la configuration. Notons aussi que <code>Gitlab</code> et <code>Github</code>
affichent raisonnablement le contenu des fichiers <code>.org</code> (sans toute
fois interpréter les zones de code ou les équations LaTeX). C'est
commode pour partager une configuration.
</p>

<p>
Dans le cas d'un fichier de configuration, ces blocs sont
principalement des morceaux de codes <code>ELisp</code> dont l'évaluation modifie
le comportement d'Emacs. Mais, en général, il est aussi possible de
récupérer le résultat de l'exécution et de l'insérer automatiquement
dans le document. De ce fait, le document est extrêmement
dynamique. La rédaction de documentations ou de tutoriels par exemple
    est donc grandement facilitée, puisqu'Emacs vérifie par l'évaluation
du document <code>Org-mode</code> que tous les morceaux de code sont valides et met
à jour les résultats.
</p>

<p>
Par certains aspects, <code>Org-mode</code> est similaire à certains langages de
description de contenus comme par exemple <code>Markdown</code>, puisqu'il est très
simple de définir des hiérarchies de sections, des listes, des
hyperliens, de créer des tableaux,&#x2026;
</p>

<p>
Par exemple pour créer une section de niveau \(n\), on débute une ligne
avec \(n\) étoiles (\(\star\)) consécutives suivies d'un espace et du
titre. La création d'une liste est tout aussi simple, il suffit par
exemple de commencer les lignes par un tiret (\(-\)), l'indentation
définit le niveau de l'item.
</p>

<p>
On termine cette très brève introduction par un rappel de quelques
raccourcis basiques.
</p>

<p>
Les raccourcis suivants fonctionnent pour les sections et les
listes. Les mêmes raccourcis ont des effets voisins dans les tableaux,
voir plus bas.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>M-up</code></td>
<td class="org-left">Échange l'élément avec l'élément précédent (de même niveau)</td>
</tr>

<tr>
<td class="org-left"><code>M-down</code></td>
<td class="org-left">Échange l'élément avec l'élément suivant (de même niveau )</td>
</tr>

<tr>
<td class="org-left"><code>M-left</code></td>
<td class="org-left">Diminue le niveau de l'élément (plus haut dans la hiérarchie)</td>
</tr>

<tr>
<td class="org-left"><code>M-right</code></td>
<td class="org-left">Augmente le niveau de l'élément (plus bas dans la hiérarchie)</td>
</tr>

<tr>
<td class="org-left"><code>TAB</code></td>
<td class="org-left">Plie ou déplie le contenu</td>
</tr>

    <tr>
<td class="org-left"><code>S-left</code> ou <code>S-right</code></td>
<td class="org-left">Modifie le statut de l'élément (<code>TODO</code>, <code>DONE</code>,&#x2026;)</td>
</tr>

<tr>
<td class="org-left"><code>M-RET</code></td>
<td class="org-left">Crée un élément de même niveau que l'élément courant</td>
</tr>
</tbody>
</table>
<p>
Dans le cas des listes, <code>S-left</code> et <code>S-right</code> modifient le type d'élément
de la liste (et des éléments de même niveau), on peut ainsi obtenir
une numérotation par exemple.
</p>

<p>
Enfin, si on utilise <code>M-RET</code> au milieu d'un élément, il est décomposé en
deux éléments, le contenu reste associé à la seconde partie de l'élément.
</p>

<p>
Insistons sur le fait qu'en cas de déplacement d'un élément, son
contenu lui reste attaché (les sous items en particulier). Dans le cas
des listes numérotées, la numérotation est maintenue à jour par toutes
les opérations.
</p>

<p>
Dans le cas des tableaux, comme on l'a dit, ces raccourcis sont
réutilisés avec des effets très voisins
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>M-up</code></td>
<td class="org-left">Échange la ligne avec la ligne précédente</td>
</tr>

<tr>
<td class="org-left"><code>M-down</code></td>
<td class="org-left">Échange la ligne avec la ligne suivante</td>
</tr>

<tr>
<td class="org-left"><code>M-left</code></td>
<td class="org-left">Échange la colonne avec la colonne précédente</td>
</tr>

<tr>
<td class="org-left"><code>M-right</code></td>
<td class="org-left">Échange la colonne avec la colonne suivante</td>
</tr>

<tr>
<td class="org-left"><code>TAB</code></td>
    <td class="org-left">Positionne le curseur sur la cellule suivante (ajoute une ligne si nécessaire)</td>
</tr>

<tr>
<td class="org-left"><code>S-TAB</code> ou <code>backtab</code></td>
<td class="org-left">Positionne le curseur sur la cellule précédente</td>
</tr>
</tbody>
</table>
<p>
En fin de ligne (après le dernier <code>|</code>), si on presse <code>TAB</code>, alors le
tableau est réaligné. Il existe de nombreux autres raccourcis pour les
tableaux, (suppression/ajout de lignes ou de colonnes) mais comme
certains sont dangereux nous ne les rappelons pas ici. Ces raccourcis
sont rappelés dans le menu <code>Tbl</code>.
</p>

<p>
Nous terminons cette description des tableaux en donnant <b>un</b> moyen de
les créer. Il est extrêmement simple. Il suffit de commencer une ligne
par un <code>|</code> puis de séparer les colonnes par d'autres <code>|</code>. Pour ajouter une
ligne de séparation, il suffit de commencer une ligne par la séquence
<code>|-</code> puis de presser <code>TAB</code> n'importe où dans la zone du tableau.
</p>

<p>
Finalement, on donne quelques raccourcis plus généraux pour
<code>Org-mode</code>. On ne décris pas ici comment générer des zones de code, ni
autres comportements dynamiques. Les fonctionnalités basiques sont
accessibles dans le menu, mais il est préférable pour cela de
consulter des documentations dédiées (voir par exemple <a href="https://orgmode.org/">orgmode.org</a>).
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-c C-c</code></td>
<td class="org-left">Évalue une zone de code et met à jour le résultat</td>
</tr>

<tr>
<td class="org-left"><code>C-c C-v C-b</code></td>
<td class="org-left">Évalue tout le document et met à jour les résultats</td>
</tr>

<tr>
<td class="org-left"><code>C-c C-e</code></td>
<td class="org-left">Lance le menu <code>Hydra</code> pour déclencher les exports</td>
</tr>

<tr>
<td class="org-left"><code>C-c '</code></td>
<td class="org-left">Édite une zone de code dans le mode approprié</td>
</tr>
</tbody>
</table>
<p>
Ce dernier raccourci : <code>C-c '</code> est <b>extrêmement</b> important pour la
    modification des blocs de codes. Il faut éviter de modifier
directement ces éléments avec le mode <code>Org</code>.
</p>
</div>
</div>

<div id="outline-container-orgd0cb9bc" class="outline-3">
<h3 id="orgd0cb9bc"><span class="section-number-3">6.2</span> Pliage et dépliage avec <code>narrow-or-widen-dwim</code></h3>
<div class="outline-text-3" id="text-6-2">
<p>
Emacs propose des fonctions de (dé)-pliage de zones. La dénomination
pour ces fonctionnalités dans Emacs est <i>narrowing</i> (pliage) et <i>widening</i>
(dépliage).
</p>

<p>
Il s'agit d'un outil très puissant pour l'édition avec Emacs. Son
fonctionnement n'est pas de cacher des zones de texte comme le
proposent de nombreux outils, mais de modifier le <i>buffer</i> pour qu'il ne
contienne plus que la région sélectionnée. Le <i>buffer</i> <b>n'est donc plus</b>
le reflet du fichier édité, mais simplement le reflet de la zone.
</p>

<p>
Les modifications apportées à la zone sont donc bien sauvées dans le
fichier, mais on ne peut plus modifier le reste du fichier. C'est donc
très pratique lorsqu'on veut appliquer une série de modifications sans
avoir à se préoccuper de leur impact hors de la région. Un bon exemple
est l'utilisation d'une macro clavier.
</p>

<p>
Dans cette configuration, on utilise <code>narrow-or-widen-dwim</code> qui
simplifie la sélection des régions à éditer, c'est l'effet <i>dwin</i> (<i>Do
What I Mean</i>).
Un seul raccourci est nécessaire à l'activation du pliage ou du
dépliage d'une zone.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">


<colgroup>
<col  class="org-left" />

<col  class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Raccourci</th>
<th scope="col" class="org-left">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left"><code>C-x n</code></td>
<td class="org-left">Active ou déactive le pliage</td>
</tr>
</tbody>
</table>
<p>
Là où ce mode est intelligent c'est en sa façon de reconnaître quelle
est la région qui sera éditée. En fait, si une région est sélectionnée
c'est cette région qui sera considérée, mais sinon, c'est le
paragraphe, la section ou la fonction courante (dans un mode de
programmation) même qui occupera tout le <i>buffer</i>.
</p>
</div>
</div>

<div id="outline-container-org6f718b1" class="outline-3">
    <h3 id="org6f718b1"><span class="section-number-3">6.3</span> Autres modes installés</h3>
<div class="outline-text-3" id="text-6-3">
<p>
En dehors des modes internes fournis avec Emacs, on pourra consulter
le fichier de configuration (<a href="Configuration.html">Configuration.org</a>) où sont décrits
succinctement des modes plutôt utiles comme <code>WGrep</code>, <code>iedit</code>, <code>Dumb Jump</code>,
<code>AutoYASnippet</code>, <code>Avy</code>, <code>projectile</code>, &#x2026;
</p>

<p>
Ils ne sont pas abordés dans ce tutoriel.
</p>
</div>
</div>

<div id="outline-container-orgf346812" class="outline-3">
<h3 id="orgf346812"><span class="section-number-3">6.4</span> Personnalisation</h3>
<div class="outline-text-3" id="text-6-4">
</div>
<div id="outline-container-orgd23a4f3" class="outline-4">
<h4 id="orgd23a4f3"><span class="section-number-4">6.4.1</span> custom.el</h4>
<div class="outline-text-4" id="text-6-4-1">
<p>
Même si on souhaite pouvoir suivre les développements de cette
configuration et les mettre à jour avec <code>git</code>, il est possible de la
personnaliser un peu.
</p>

<p>
Pour cela, les modifications doivent être apportées au fichier
<code>~/.emacs.d/custom.el</code>. En fait, ce fichier particulier est ignoré
par <code>git</code>, mais il est généré au lancement d'Emacs s'il n'existe pas.
</p>

<p>
Une façon de <b>supprimer</b> toutes les personnalisations est donc de
l'effacer puis de relancer Emacs. Si des personnalisations sont
importantes, il convient donc de les sauvegarder ailleurs.
</p>
</div>
</div>

<div id="outline-container-org5923d3c" class="outline-4">
<h4 id="org5923d3c"><span class="section-number-4">6.4.2</span> Emacs lisp</h4>
<div class="outline-text-4" id="text-6-4-2">
<p>
Rappelons le, Emacs n'est pas un simple éditeur. C'est en fait une
véritable machine interprétant le langage <code>ELisp</code> dont des
fonctionnalités sont adaptées à l'édition de sources.
</p>

<p>
Donc pour une personnalisation (extrêmement) poussée, ou pour
développer de nouveaux modes, il est indispensable de connaître
suffisamment <code>ELisp</code>. Évidemment, on ne couvre pas cet aspect des choses
dans ce document. Il faudra donc se référer aux nombreuses
documentations disponibles sur internet.
</p>

<p>
Voici quelques références, classées par ordre croissant de complexité.
</p>
<ul class="org-ul">
<li><a href="https://github.com/chrisdone/elisp-guide">Un guide rapide des bases d'ELisp</a></li>
<li><a href="http://ergoemacs.org/emacs/elisp.html">Practical Emacs Lisp</a></li>
<li><a href="https://www.gnu.org/software/emacs/elisp-manual/elisp.html">Manuel de référence</a></li>
</ul>
</div>
</div>
</div>
    </div>
<div id="footnotes">
<h2 class="footnotes">Notes de bas de page: </h2>
<div id="text-footnotes">

<div class="footdef"><sup><a id="fn.1" class="footnum" href="#fnr.1">1</a></sup> <div class="footpara"><p class="footpara">
<code>Org-mode</code> n'existe que dans Emacs. Il n'y a pas d'application
autonome qui offre les mêmes fonctionnalités. Cela n'aurait pas
vraiment de sens.
</p></div></div>


</div>
</div></div>
<div id="postamble" class="status">
<p class="date">Created: 2021-02-02 mar. 07:52</p>
<p class="validation"><a href="http://validator.w3.org/check?uri=referer">Validate</a></p>
</div>
</body>
</html>