path: root/Master/texmf-dist/doc/latex/guide-latex-fr/Chapitres/p3-tableaux.tex

\chapter{Tableaux \& boîtes}

\label{chap-table-details}\lettrine{I}{l} est possible d'obtenir des tableaux plus élaborés avec quelques commandes supplémentaires, sans parler des décorations avec des boîtes.

\section{Autres formats de cellules}

Dans la partie précédente de ce guide, j'ai présenté les formats par défaut pour les cellules d'un \verb?tabular? : \verb?l?, \verb?c? et \verb?r?. Grâce au package \verb?array?, il en existe d'autres, qui permettent de prendre en compte une longueur comme argument : les formats \verb?p{<longueur>}?, \verb?m{<longueur>}? et \verb?b{<longueur>}?.

\verb?p? (comme \textit{paragraph}) permet de définir une colonne de largeur définie par \verb?longueur? et dont le contenu est aligné en haut à gauche ; \verb?m? (comme \textit{middle}) aligne le contenu à gauche et le centre verticalement ; \verb?b? (comme \textit{bottom}) aligne aussi le contenu à gauche mais le fixe en bas de la cellule.

\textbf{Il n'est pas possible de cumuler des formats différents} (limite du package \verb?array? vraisemblablement). Il ne faut donc pas s'étonner si le résultat ne correspond pas à tes attentes si tu définis une colonne au format \verb?p? et une autre au format \verb?m?. \\

Si, comme nous le verrons par la suite, la commande \verb?linebreak? est utile pour écrire du texte sur une nouvelle ligne (dans la même cellule), elle peut parfois créer de grandes espaces blancs entre les mots (justification du texte forcée lors du retour à la ligne).

La meilleure solution, valable uniquement pour ces nouveaux formats, est d'utiliser la commande \verb?\newline?, qui permet donc d'éviter tous ces désagréments. Par exemple, cette solution peut se révéler pratique quand tu veux renseigner plusieurs dates dans une même cellule :

\begin{codedisplay}{Le format de cellule \verb?p?}
% Ajout au préambule
% \usepackage{array}


\begin{tabular}{p{0.5\linewidth}|p{0.3\linewidth}}
Du texte \linebreak Un très très très long texte & {\hspace*{\fill}Titre centré\hspace*{\fill}} \\ \hline
Nouvel essai \newline Meilleur espacement & OK
\end{tabular}
\end{codedisplay}

\begin{codedisplay}{Le format de cellule \verb?m?}
% Ajout au préambule
% \usepackage{array}


\begin{tabular}{m{0.3\linewidth}m{0.5\linewidth}}
2018 \newline 2017 & Responsable de projet (ligne de production)
\end{tabular}
\end{codedisplay}

\begin{attention}{\textit{Nota Bene} : centrage et retour à la ligne}
Pour une raison que j'ignore, le centrage horizontal du texte dans une cellule au format \verb?p / m / b? ne fonctionne pas avec la commande usuelle \verb?\hfill?.

La meilleur solution consiste à utiliser la commande \verb?\hspace*? combinée avec \verb?\fill? de la manière suivante :

\begin{code}{}
\begin{tabular}{p{0.3\linewidth}}
{\hspace*{\fill}Texte / Titre\hspace*{\fill}} \\
Blablabla
\end{tabular}
\end{code}

\textbf{Cette solution doit vraiment être utilisée de manière ponctuelle !} Si tu veux la généraliser à toute la colonne, je te recommande d'aller lire la section suivante. \\

Enfin, le retour forcé à la ligne avec \verb?\newline? (ou \verb?\linebreak?) n'est bel et bien valide seulement pour les formats \verb?p / m / b?.
\end{attention}

\section{Cellules centrées verticalement et horizontalement}

Le format de colonne \verb?c? ou \verb?m? n'est pas suffisant pour centrer à lui tout seul verticalement et horizontalement le contenu d'une cellule. Le plus simple est d'utiliser le format \verb?m? (centrage vertical) et de le combiner avec un descripteur pour appeler la commande \verb?\centering? (centrage horizontal).

La définition de la colonne dans l'environnement \verb?tabular? se fait alors de la manière suivante :

\begin{code}{}
>{\centering\arraybackslash}m{<longueur_case>}
\end{code}

Très clairement, le code devient illisible et pénible à reprendre si tu dois copier-coller ce long format à chaque fois. 

Grâce au package \verb?array?, il est possible de créer son propre format de colonne grâce à la commande \verb?newcolumntype?.\footnote{Je préconise même d'appeler cette commande dans le préambule, pour regrouper toutes les commandes personnelles et y revenir plus facilement par la suite.} La syntaxe de cette commande est la suivante :

\begin{code}{Appel de la commande \texttt{\textbackslash}\verb?newcolumntype?}
\newcolumntype{<nom_format>}[<nbre_arg>]{<def_format>}
\end{code}

Un exemple d'utilisation serait alors :

\begin{coderesult}{Un exemple avec un \textit{SWOT}}
\documentclass[a4paper, 12pt]{report}

\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

% Ajout dans le préambule
\usepackage{graphicx} % Pour la commande rotatebox
\usepackage{array}
\newcolumntype{C}[1]{>{\centering\arraybackslash}m{#1}}


\begin{document}

\begin{tabular}{C{0.1\linewidth}*{2}{|C{0.4\linewidth}}}
~ & {\Large{}Atouts} & {\Large{}Handicaps} \\ \hline
\rotatebox{90}{\Large{}Interne} & \textbf{Forces (Strengths)} \begin{itemize}
\item point SA
\item point SB
\end{itemize} & \textbf{Faiblesses (Weaknesses)} \begin{itemize}
\item point WA
\item point WB
\end{itemize} \\ \hline
\rotatebox{90}{\Large{}Marché} & \textbf{Opportunités (Opportunities)} \begin{itemize}
\item point OA
\item point OB
\end{itemize} & \textbf{Menaces (Threats)} \begin{itemize}
\item point TA
\item point TB
\end{itemize}
\end{tabular}

% Ajuster les listes à puce selon ton bon vouloir

\end{document}
\end{coderesult}

Le raccourci pour définir $N$ colonnes identiques est toujours utilisable. La formulation ne change pas : c'est toujours \verb?*{<nbre_col>}{<format>}?, comme vu dans l'exemple précédent.

\section{Fusion et coloriage de cellules}

Si la fusion des colonnes et des lignes est comprise de base avec le package \verb?array?, la fusion des lignes laisse un peu à désirer. C'est pourquoi il vaut mieux utiliser le package \verb?multirow?. \\

Pour fusionner des colonnes, il faut employer la commande \verb?\multicolumn?, avec la syntaxe suivante : \verb?\multicolumn{<nbre_col>}{position}{texte}?. Pour avoir un séparateur adapté, une ligne partielle peut être insérée grâce à la commande \verb?\cline{<col_debut>-<col_fin>}?.

Pour la fusion des lignes, il faut utiliser la commande \verb?\multirow? et la syntaxe suivante : \verb?\multirow{<nbre_ligne>}{*}{Texte}?. L'emploi de \verb?{*}? permet d'avoir les cellules fusionnées avec la bonne largeur et d'éviter les problèmes de centrage. \\

Afin de pouvoir colorier les cellules, il faut ajouter le package \verb?xcolor? dans le préambule, avec l'option \verb?table?. Grâce à la commande \verb?\rowcolor{<couleur>}?, tu peux colorier une ligne entière. 

\verb?\columncolor{<couleur>}? et \verb?\cellcolor{<couleur>}? font de même respectivement pour une colonne et une cellule. Voyons tous ces éléments dans un petit exemple :

\begin{coderesult}{Coloriage et fusion}
\documentclass[a4paper, 12pt]{report}

\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

% Ajout dans le préambule
\usepackage{array} 
\usepackage{multirow} % Pour fusionner des lignes d'un tableau
\newcolumntype{C}[1]{>{\centering\arraybackslash}m{#1}}
\renewcommand{\arraystretch}{1.3} % Meilleure lisibilité
\usepackage[table]{xcolor} % [table] : pour colorer les cellules (package colortbl)


\begin{document}

\begin{tabular}{|*{4}{C{0.2\linewidth}|}}
\hline
\rowcolor{orange!80!yellow} \multicolumn{4}{|c|}{\textbf{Comparaison des configurations}} \linebreak \\ \hline
\multirow{2}{*}{\textbf{Critères}} & \multicolumn{3}{c|}{\textbf{Structures}} \linebreak \\ \cline{2-4}
~& \textbf{Fonctionnelle} & \textbf{Divisionnelle} & \textbf{Matricielle} \\ \hline \hline
Stabilité & ++ & + & - \\ \hline
Flexibilité \& Adaptabilité & - & - & ++ \\ \hline
\rowcolor{black} ~ & ~ & ~ & ~ \\ \hline
\textbf{Cas pratiques} & \multicolumn{3}{|c|}{\textbf{Qui réussira le mieux à répondre aux besoins ?}} \\ \hline
Projet (long) à réaliser & - & - & ++ \\ \hline
Fabrication en grande série & ++ & - & -- \\ \hline
\end{tabular}

\end{document}
\end{codedisplay}

Il se peut que la visualisation des bordures noires du tableau ne s'affiche pas bien avec la cellule colorée. Il s'agit juste d'un problème d'affichage avec ton écran d'ordinateur, tellement la ligne est fine.

Sinon, tu peux aussi augmenter l'épaisseur des traits de ton tableau, grâce à la commande \verb?\setlength\arrayrulewidth{<épaisseur>}?.

\section{\texttt{longtable} \& \texttt{booktabs}}

J'ai découvert ces deux packages -- \verb?longtable? et \verb?booktabs? -- en 2017, et depuis je ne m'en passe plus ! \\

Le premier se révèle très utile pour des tableaux dont la longueur dépasse une page. Il suffit simplement de remplacer l'environnement \verb?tabular? par \verb?longtable? et tout le reste fonctionne de la même façon, y compris les formats de colonnes définis par l'utilisateur ou la mise en place d'une légence (\verb?\caption?).

Tu peux aussi mettre une note en bas de page pour indiquer que le tableau se poursuit en page suivante, rappeler lors du changement de page les titres des colonnes ou encore indiquer quand le tableau est terminé ! 

Bref, ce package offre pas mal de possibilités, que je te laisse aller découvrir dans l'exemple qui suit et compléter le cas échéant grâce à la documentation officielle : \url{https://www.ctan.org/pkg/longtable}. \\

Quant au second package, c'est le seul à ma connaissance qui permette d'obtenir des tableaux de qualité, suffisamment aérés, avec de bons séparateurs. En théorie, la commande \verb?\renewcommand{\arraystretch}{1.3}? permet de modifier la hauteur de ligne, pour tous les tableaux créés après cette commande. 

Mais, avec des fractions, impossible de modifier quoi que ce soit\dots{} sauf avec \verb?booktabs? ! Pourquoi ? Je n'en sais rien. Le rendu est meilleur et convient.

\begin{coderesult}{Un exemple d'utilisation du package \verb?longtable?}
\documentclass[a4paper, 12pt]{report}

\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage{lipsum}

\usepackage{array, longtable}
\renewcommand{\arraystretch}{1.3}


\begin{document}

\lipsum[1] \\

\begin{center}
\begin{longtable}{p{0.4\linewidth}p{0.3\linewidth}}
% Définition des headers & footers du longtable
{\hspace*{\fill}\textbf{Colonne A}\hspace*{\fill}} & {\hspace*{\fill}\textbf{Colonne B}\hspace*{\fill}} \\ \hline
\endhead
\multicolumn{2}{r}{\textit{(suite sur la page suivante)}} \\
\endfoot
\multicolumn{2}{@{\hrulefill}c@{\hrulefill}}{\raisebox{-3pt}{~~\textsc{Fin du tableau}~~}}
\endlastfoot
% Contenu du longtable
\lipsum[2] & \'Evident ! \\
\lipsum[3] & Limpide même !!!
\end{longtable}
\end{center}

\end{document}
\end{coderesult}

\begin{coderesult}{Un exemple d'utilisation du package \verb?booktabs?}
\documentclass[a4paper, 12pt]{report}

\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage{amsmath, amsfonts, amssymb}
\newcommand{\module}[1]{\left\lvert #1 \right\rvert}

\usepackage{array, booktabs}
\renewcommand{\arraystretch}{1.3}
\newcolumntype{C}[1]{>{\centering\arraybackslash}m{#1}}


\begin{document}

\everymath{\displaystyle}

\vspace*{\fill}

\begin{center}
\begin{tabular}{*{2}{C{0.3\linewidth}}} \toprule
$f(x)$ & $\int f(x)\,dx$ \\ \midrule % \midrule : commande propre à booktabs - Création d'une ligne horizontale (= \hline)
$x^\alpha$, avec $\alpha \neq -1$ & $\frac{x^{\alpha + 1}}{\alpha + 1}$ \\ \midrule
$\frac{1}{x}$ & $\ln \module{x}$ \\ \midrule
$\cos (ax)$, avec $a \neq 0$ & $\frac{\sin (ax)}{a}$ \\ \midrule
$\sin x$ & $-\cos x$ \\ \midrule
$\frac{1}{1 + x^2}$ & $\arctan x$ \\ \midrule
$\cosh x$ & $\sinh x$ \\ \midrule
$\sinh x$ & $\cosh x$ \\ \midrule
$e^{\omega x}$, avec $\omega \neq 0$ & $\frac{e^{\omega x}}{\omega}$ \\ \midrule
$\frac{u'}{u}$ & $\ln \module{u}$ \\ \midrule
$\tan x$ & $-\ln ( \module{\cos x})$ \\ \midrule
$\frac{1}{\sqrt{1 - x^2}}$ & $\arcsin x$ \\ \midrule
$\frac{-1}{\sqrt{1 - x^2}}$ & $\arccos x$ \\ \midrule
$\frac{1}{\sqrt{x^2 + 1}}$ & $\mathrm{argsinh}~x$ \\ \midrule
$\frac{1}{\sqrt{x^2 - 1}}$ & $\mathrm{argcosh}~x$ \\ \midrule
$\frac{1}{1 - x^2}$ & $\mathrm{argtanh}~x$
\end{tabular}
\end{center}

\vspace*{\fill}

\end{document}
\end{coderesult}

Ici, j'ai séparé l'emploi de \verb?longtable? et de \verb?booktabs? pour bien distinguer les deux exemples mais rien n'empêche d'utiliser l'environnement \verb?longtable? avec des commandes de \verb?booktabs? (comme \verb?\toprule? ou \verb?\midrule?).

\section{Créer sa propre boîte}

Le package \verb?tcolorbox? propose de très nombreux outils pour créer des boîtes. Il propose même une commande pour créer soi-même son propre environnement, et donc sa propre boîte entièrement personnalisable.

La structure est très particulière et propre à \verb?tcolorbox? mais permet de respecter la philosophie \LaTeX{} : séparer le fond de la forme par l'intermédiaire de commandes. 

Un changement sur la commande entraîne alors un changement sur tout le document. Tu admettras que c'est nettement plus pratique que de devoir revenir sur tout le document et le corriger. \\

La création d'une nouvelle boîte repose sur une syntaxe identique à celle utilisée lors de la création d'une nouvelle commande, avec \verb?[<nbre_arg>]? absent s'il n'y a pas d'argument pour notre boîte : 

\begin{code}{Création d'une nouvelle boîte sous \verb?tcolorbox?}
\newtcolorbox{<nom_boite>}[<nbre_arg>]{<options>}
\end{code}

Il est préconisé de définir toutes ses boîtes dans le préambule, là encore pour faciliter les modifications futures et centraliser, regrouper toutes ces commandes. \\

De plus, il est possible, comme pour la création de commandes, de définir un argument optionnel selon la syntaxe suivante, avec l'argument optionnel qui correspond automatiquement au choix \verb?#1? dans la définition de la commande : 

\begin{code}{Utilisation d'un argument optionnel}
\nextcolorbox{<nom_boite>}[<nbre_arg>][<defaut>]{<options>}
\end{code}

Si \verb?<defaut>? est présent, alors le premier argument spécifié par \verb?<nbre_arg>? soit \verb?#1? est optionnel avec une valeur par défaut fixée à \verb?<defaut>?.

Ainsi, si tu renseignes \verb?<defaut>? par une valeur vide, ta boîte ne souffrira pas d'un changement dans ses options, à moins de les notifier lors de son appel ! Je pense qu'un premier exemple simple ne sera pas de trop pour comprendre cette nouvelle notion :

\begin{codedisplay}{Nouvelle commande \& argument par défaut}
\newcommand{\format}[2][\textbf]{Je trouve que \LaTeX{} est #1{#2 !}}

\format{merveilleux} \\
\format[\textit]{fantastique} \\
\format[\textsc]{incroyable}
\end{codedisplay}


Nous avons donc le code complet suivant pour la création\footnote{Je ne vais pas revenir en détail sur toutes les options \verb?tcolorbox? utilisées. Elles sont décrites dans la documentation officielle, disponible sur \url{https://www.ctan.org/pkg/tcolorbox}. \`A toi aussi de faire des essais !}, suivi de quelques exemples. Attention à ne pas oublier d'appeler le package \verb?tcolorbox? avec les options \verb?breakable? et \verb?skins? !

\begin{code}{Ma petite boîte personnelle}
\usepackage[breakable, skins]{tcolorbox}

% Boîte type générique
\newtcolorbox{boitetype}[4][]{enhanced, breakable, before upper = {\parindent17.6pt}, beforeafter skip = \baselineskip, colframe = #3, colback = #4, boxrule = 2pt, arc = 4mm, fonttitle = \bfseries, title = {#2}, coltitle = black, #1}

% La boîte utilisée
\newenvironment{boite}[3][]{\begin{boitetype}[#1]{#2}{#3}{white}}{\end{boitetype}}
\end{code}

\begin{codedisplay}[sidebyside = false, listing and text]{Application}
\begin{boite}{Un premier exemple}{orange}
C'est pratique, n'est-ce pas ?
\end{boite}

\begin{boite}[colback = violet!50, coltitle = white]{Un deuxième exemple}{violet}
Apportons quelques petits changements, juste pour cette fois.
\end{boite}

\begin{boite}{Un troisième exemple}{cyan}
Retour sur un cas normal d'utilisation.
\end{boite}
\end{codedisplay}

Le principe est donc de créer une nouvelle boîte (syntaxe très similaire à celle employée pour créer une commande) pour chaque cas (boîte pour les définitions, boîte pour les remarques, etc.). 

Pour t'éviter de devoir changer les options à chaque fois, le mieux reste de créer une boîte type puis de créer tes différentes boîtes à partir de cette boîte générique.

Et avec l'astuce de l'argument optionnel, tu laisses de la souplesse à ton code, que tu peux donc adapter sur le pouce si tu as un cas exceptionnel à traiter. Pratique et puissant à la fois !

\section{Afficher du code \LaTeX{}}

Il n'y a pas 13 façons d'afficher du code \LaTeX{} simplement\footnote{\'Ecrire \verb?\texttt{\textbackslash}? pour produire \texttt{\textbackslash} n'est vraiment pas une solution viable !}. La première solution requiert d'utiliser l'environnement \verb?verbatim? : tout ce qui est compris dans cet environnement ne sera pas interprété par \LaTeX{} et sera recopié tel quel. 

Cependant, une trop longue commande dépasse des marges voire de la page\dots{} C'est donc vite compliqué de lire la fin ou même de copier un morceau de code. \\

Toutefois, il existe déjà un moyen simple pour les ``petites'' formules : la commande \verb!\verb?<cmde>?!. Il faut juste écrire \verb?\verb? et tout ce qui est compris entre les deux délimiteurs (ici, des \verb!?!) subit le même traitement que sous l'environnement \verb?verbatim? (environnement \verb?verbatim? local en quelque sorte). 

\verb!?! n'est d'ailleurs pas le seul délimiteur envisageable : par exemple, \verb?!? convient tout à fait. \\

Autrement, le seul package qui permette de mettre en forme du code (\LaTeX{}, mais aussi Python, Perl, C, C++, Java, SQL, HTML, etc.) avec un retour à la ligne intégré s'appelle \verb?listings?. 

Beaucoup d'options de mise en forme sont disponibles (numéro de ligne de code sur le côté, commandes en couleur selon le langage\dots{}) mais il y a mieux. Et oui, c'est maintenant que revient le Saint Graal : \verb?tcolorbox? ! Ce dernier intègre le package \verb?listings? et permet de retourner un résultat soigné et personnalisable.

Pour obtenir le code le plus propre et tenir compte des contraintes supplémentaires du package \verb?listings?, il faut procéder en plusieurs étapes : \begin{enumerate}
\item Charger le package \verb?tcolorbox? avec les options \verb?breakable? \& \verb?skins?, pour la personnalisation des boîtes, ainsi que \verb?listings?, pour intégrer le package éponyme.

\item Intégrer les accents avec \verb?\lstset{literate = <accents>}?. Le package \verb?listings? n'interprète pas nativement les accents donc il faut les définir au préalable.

La programmation se fait généralement en anglais donc ne comporte pas d'accents. Mais personnellement, en tant que Français qui rédige un guide en français, mes commentaires contiennent parfois des accents donc il faut mettre en place cette dernière astuce pour s'en sortir.

\item Définir un style pour l'affichage de la boîte, qui contiendra toutes les options liées à sa personnalisation.

En effet, contrairement à la section précédente où nous avons défini une boîte type puis des dépendances, l'ajout d'une couche supplémentaire avec le package \verb?listings? nuit à sa création et entraîne des erreurs irrémédiables actuellement.

Il faut donc ruser et créer autant d'environnements \verb?tcolorbox? avec \verb?listings? que de boîtes différentes pour afficher le code, mais qui vont à chaque fois appeler les styles mis en place. Les définitions deviennent concises et les boîtes peuvent se généraliser facilement.

\item Créer un style \verb?listings?, pour la personnalisation du code à proprement parler.

\item Créer la boîte (environnement \verb?tcolorbox?). \\
\end{enumerate}

Voyons directement avec un exemple les points précédemment abordés, pour découvrir les commandes à utiliser et leur fonctionnement :

\begin{code}{\'Ecrire du code sous \LaTeX{} : paramétrage}
% Chargement de tcolorbox et des options nécessaires
\usepackage[breakable, listings, skins]{tcolorbox}

% Pour résoudre le problème des accents dans le code (listings sous tcolorbox)
\lstset{literate = {à}{{\`a}}1 {â}{{\^a}}1 {é}{{\'e}}1 {è}{{\`e}}1 {ê}{{\^e}}1 {î}{{\^i}}1 {ô}{{\^o}}1 {ù}{{\`u}}1 {û}{{\^u}}1 {ç}{{\c{}c}}1}

% Définition du style de la boîte (affichage)
\tcbset{
codemainoptions/.style = {
	maincolor/.store in = {\tcbmaincol},
	maincolor = LimeGreen,
	rulewidth/.store in = {\tcbrulewidth},
	rulewidth = 2pt,
	enhanced, breakable, beforeafter skip = \baselineskip, sharp corners, boxrule = \tcbrulewidth, colframe = \tcbmaincol, colback = \tcbmaincol!15, drop fuzzy shadow, colbacktitle = \tcbmaincol!50, coltitle = black, fonttitle = \bfseries, title = {#1},
	attach boxed title to top center = {yshift = -\tcbrulewidth/2-\tcboxedtitleheight/2, yshifttext = -\tcboxedtitleheight/2}, boxed title style = {boxrule = \tcbrulewidth, frame code = {
		\path[tcb fill frame] ([xshift = -3mm]frame.west) -- (frame.north west) -- (frame.north east) -- ([xshift = 3mm]frame.east) -- (frame.south east) -- (frame.south west) -- cycle;}, interior code = {
		\path[tcb fill interior] ([xshift = -2mm]interior.west) -- (interior.north west) -- (interior.north east) -- ([xshift = 2mm]interior.east) -- (interior.south east) -- (interior.south west) -- cycle;}}
}
}

% Création du style listings
\lstdefinestyle{mainlststyle}{
language = {[LaTeX]TeX},
style = tcblatex,
texcsstyle = *\color{cyan!65!black},
commentstyle = \color{gray},
tabsize = 4,
keepspaces = true,
breaklines = true,
breakatwhitespace = false,
inputencoding = utf8,
numbers = none,
showspaces = false,
showtabs = false,
showstringspaces = false
}

% Création des boîtes "tcolorbox + listings" (environnement)
\newtcblisting{code}[2][]{codemainoptions = {#2}, listing options = {style = mainlststyle}, listing only, #1}

\newtcblisting{codedisplay}[2][]{codemainoptions = {#2}, listing options = {style = mainlststyle}, listing side text, righthand ratio = 0.4, sidebyside gap = 13mm, bicolor, colbacklower = white, #1}

% N.B. : #2 = titre de la boite
% N.B. : option "breakable" pas bien compatible avec "listing side text" ==> faire des "petits bouts" de code dans ce cas
\end{code}

\begin{codedisplay}[sidebyside = false, listing and text]{Application}
\begin{verbatim}
Très pratique d'écrire du code sous \LaTeX{} \\

Mais c'est plus compliqué quand le code en question est trop long !
\end{verbatim}

\begin{code}{Boîte}
Très pratique désormais d'écrire du code sous \LaTeX{} ! Surtout si le code est extrêmement long.
\end{code}

\`A toi d'essayer l'environnement \verb?codedisplay? !
\end{codedisplay}

\vspace{\baselineskip}

Il est possible d'aller encore plus loin, toujours grâce aux packages \verb?tcolorbox? et \verb?listings?, et de compléter le précédent code pour avoir les options suivantes : numérotation automatique des boîtes et création d'un sommaire dédié à ces boîtes.

La documentation \verb?tcolorbox? fournit toutes les indications nécessaires. Les commandes nécessaires à utiliser sont décrites ci-après :

\begin{code}{Intégrer du code -- Aller encore plus loin}
% Appel de tcolorbox, \lstset & création des styles

\usepackage[]{hyperref} % Obligatoire

% Reprise du style codemainoptions + title = {Code \thetcbcounter{} : #1}
% Ajout : list entry = {\protect\numberline{\thetcbcounter}#1}

% Création d'une boîte numérotée pour le code
\newtcblisting[auto counter, number within = chapter, list inside = LaTeXcode]{code}[2][]{codemainoptions = {#2}, listing options = {style = mainlststyle}, listing only, #1}


\begin{document}

% Ajout du nouveau sommaire (hyperref)
\phantomsection
\addcontentsline{toc}{chapter}{Liste des codes \LaTeX{}} % Ajout dans le sommaire
\tcblistof[\chapter*]{LaTeXcode}{Liste des codes \LaTeX{}} % Sommaire dédié tcolorbox (LaTeXcode = référence)

Rédaction du document et utilisation de l'environnement \verb?code? !

\end{document}
\end{code}

Enfin, il existe un autre package que \verb?listings?, qui peut s'occuper automatiquement du coloriage du code : \verb?minted?. Il fonctionne grâce à \verb?pygments?, une bibliothèque Python. Par contre, même après son installation, je n'ai toujours pas réussi à le faire fonctionner\dots{}