Commandes Spéciales

Introduction

Toutes les commandes de la documentation commencent par une barre oblique inverse (\) ou un arobase (@). Si vous préférez, vous pouvez remplacer toutes les commandes commençant par une barre oblique inverse ci-dessous par leurs équivalents commençant par un arobase.

Certaines commandes ont un ou plusieurs arguments. Chaque argument a une certaine portée :

  • Si des accolades <pointues> sont utilisées, l'argument est un seul mot.
  • Si des accolades (arrondies) sont utilisées, l'argument s'étend jusqu'à la fin de la ligne sur laquelle la commande a été trouvée.
  • Si des accolades {bouclées} sont utilisées, l'argument s'étend jusqu'au paragraphe suivant. Les paragraphes sont délimités par une ligne vide ou par un indicateur de section. Notez que les accolades {curly} sont également utilisées pour les options de commande, ici les accolades sont obligatoires et ne sont que des caractères « normaux ». L'accolade de départ doit suivre directement la commande, donc sans espace.

Si des crochets [carrés] sont utilisés en plus des spécificateurs d'argument ci-dessus, l'argument est facultatif, à moins qu'ils ne soient placés entre guillemets, auquel cas ils constituent une partie obligatoire de l'argument de commande.

Voici une liste alphabétique de toutes les commandes

Les sous-sections suivantes fournissent une liste de toutes les commandes reconnues par Doxygen. Les commandes non reconnues sont traitées comme un texte normal.

--- Indicateurs structurels ---

\addtogroup <name> [(title)]

Définit un groupe comme \defgroup, mais contrairement à cette commande en utilisant le même <name> plus d'une fois ne se traduira pas par un avertissement, mais plutôt un groupe avec une documentation fusionnée et le premier titre trouvé dans l'une des commandes.

Le titre est facultatif, donc cette commande peut également être utilisée pour ajouter un certain nombre d'entités à un groupe existant en utilisant @ { et @} comme ceci : 

/ *! \ addTogroup mygrp 
* Documentation supplémentaire pour le groupe «mygrp» 
* @ { 
* / 

/ *! 
* Une fonction 
* / 
void func1 () 
{ 
} 

/ *! Une autre fonction * / 
void func2 () 
{ 
} 

/ *! @} * /

Voir aussi

Pages grouping, sections \defgroup, \ingroup et \weakgroup.

\callgraph

Lorsque cette commande est placée dans un bloc de commentaires d'une fonction ou d'une méthode et que HAVE_DOT est à YES, Doxygen génère un graphe d'appel pour cette fonction (à condition que l'implémentation de la fonction ou de la méthode appelle d'autres fonctions documentées). Le graphe d'appel sera généré quelle que soit la valeur de CALL_GRAPH.

Note
La complétude (et l'exactitude) du graphe d'appel dépend de l'analyseur de code de Doxygen qui n'est pas parfait.

Voir aussi

section \callergraph, section \hidecallgraph, section \hidecallergraph et option CALL_GRAPH.

\hidecallgraph

Lorsque cette commande est placée dans un bloc de commentaires d'une fonction ou d'une méthode, Doxygen ne génère pas de graphe d'appel pour cette fonction. Le graphe d'appel ne sera pas généré quelle que soit la valeur de CALL_GRAPH.

Note
La complétude (et l'exactitude) du graphe d'appel dépend de l'analyseur de code de Doxygen qui n'est pas parfait.

Voir aussi

section \callergraph, section **\callgraph**, section \hidecallergraph et option CALL_GRAPH.

\callergraph

Lorsque cette commande est placée dans un bloc de commentaires d'une fonction ou d'une méthode et que HAVE_DOT vaut YES, Doxygen génère un graphe d'appelant pour cette fonction (à condition que l'implémentation de la fonction ou de la méthode soit appelée par d'autres fonctions documentées). Le graphe de l'appelant sera généré quelle que soit la valeur de CALLER_GRAPH.

Note
La complétude (et l'exactitude) du graphe d'appel dépend de l'analyseur de code de Doxygen qui n'est pas parfait.

Voir aussi

section \callgraph, section \hidecallgraph, section \hidecallergraph et option CALLER_GRAPH.

\hidecallergraph

Lorsque cette commande est placée dans un bloc de commentaires d'une fonction ou d'une méthode, Doxygen ne génère pas de graphe de l'appelant pour cette fonction. Le graphe de l'appelant ne sera pas généré quelle que soit la valeur de CALLER_GRAPH.

Note
La complétude (et l'exactitude) du graphe d'appel dépend de l'analyseur de code de Doxygen qui n'est pas parfait.

Voir aussi

section \callergraph, section \callgraph, section \hidecallgraph et option CALLER_GRAPH.

\showrefby

Lorsque cette commande est placée dans un bloc de commentaires d'une fonction, d'une méthode ou d'une variable, DOXYGEN générera un aperçu de cette fonction, méthode, variable des fonctions documentées et documentées qui l'appellent / l'utilisent. L'aperçu sera généré quelle que soit la valeur de REFERENCED_BY_RELATION.

Note
La complétude (et l'exactitude) du graphe d'appel dépend de l'analyseur de code de Doxygen qui n'est pas parfait.

Voir aussi

section \showrefs, section \hiderefby, section \hiderefs et option REFERENCED_BY_RELATION.

\hiderefby

Lorsque cette commande est placée dans un bloc de commentaires d'une fonction, d'une méthode ou d'une variable, DOXYGEN ne générera pas de vue d'ensemble pour cette fonction, cette méthode ou cette variable des fonctions et méthodes qui l'appellent / l'utilisent. L'aperçu ne sera pas généré quelle que soit la valeur de REFERENCED_BY_RELATION.

Note
La complétude (et l'exactitude) du graphe d'appel dépend de l'analyseur de code de Doxygen qui n'est pas parfait.

section \showrefs, section \hiderefby, section \hiderefs et option REFERENCED_BY_RELATION.

\showrefs

Lorsque cette commande est placée dans un bloc de commentaires d'une fonction ou d'une méthode, Doxygen génère pour cette fonction ou cette méthode une vue d'ensemble des fonctions et des méthodes qui l'appellent. La synthèse sera générée quelle que soit la valeur de REFERENCES_RELATION.

Note
La complétude (et l'exactitude) du graphe d'appel dépend de l'analyseur de code de Doxygen qui n'est pas parfait.

Voir aussi

section \showrefby, section \hiderefby, section \hiderefs et option REFERENCES_RELATION.

\hiderefs

Lorsque cette commande est placée dans un bloc de commentaires d'une fonction ou d'une méthode, Doxygen ne génère pas d'aperçu pour cette fonction ou méthode des fonctions et méthodes qui l'appellent. La vue d'ensemble ne sera pas générée quelle que soit la valeur de REFERENCES_RELATION.

Note
La complétude (et l'exactitude) du graphe d'appel dépend de l'analyseur de code de Doxygen qui n'est pas parfait.

Voir aussi

section \showrefs, section \showrefby, section \hiderefby et option REFERENCES_RELATION.

\showinlinesource

Lorsque cette commande est placée dans un bloc de commentaires d'une fonction, d'une macro multiligne, d'une énumération ou d'une variable initialisée par une liste, Doxygen génère le source en ligne pour ce membre. Le source en ligne sera généré quelle que soit la valeur de INLINE_SOURCES.

Voir aussi

section \hideinlinesource, option INLINE_SOURCES

\hideinlinesource

Lorsque cette commande est placée dans un bloc de commentaires d'une fonction, d'une macro multiligne, d'une énumération ou d'une variable initialisée par une liste, Doxygen ne génère pas le source en ligne pour ce membre. Le source en ligne ne sera pas généré quelle que soit la valeur de INLINE_SOURCES.

Voir aussi

section \showinlinesource, option INLINE_SOURCES.

\includegraph

Lorsque cette commande est placée dans un bloc de commentaires d'un fichier, Doxygen génère un graphe d'inclusion pour ce fichier. Le graphe d'inclusion sera généré quelle que soit la valeur de INCLUDE_GRAPH.

Voir aussi

section \hideincludegraph, section \includedbygraph, section \hideincludedbygraph et option INCLUDE_GRAPH.

\hideincludegraph

Lorsque cette commande est placée dans un bloc de commentaires d'un fichier, Doxygen ne génère pas de graphe d'inclusion pour ce fichier. Le graphe d'inclusion ne sera pas généré quelle que soit la valeur de INCLUDE_GRAPH.

Voir aussi

section \includegraph, section \includedbygraph, section \hideincludedbygraph et option INCLUDE_GRAPH.

\includedbygraph

Lorsque cette commande est placée dans un bloc de commentaires d'un fichier d'inclusion, Doxygen génère un graphique d'inclusion pour ce fichier d'inclusion. Le graphique d'inclusion sera généré quelle que soit la valeur de INCLUDED_BY_GRAPH.

Voir aussi

section \hideincludedbygraph, section \includegraph, section \hideincludegraph et option INCLUDED_BY_GRAPH.

\hideincludedbygraph

Lorsque cette commande est placée dans un bloc de commentaires d'un fichier d'inclusion, Doxygen ne génère pas de graphe d'inclusion pour ce fichier d'inclusion. Le graphique d'inclusion ne sera pas généré quelle que soit la valeur de INCLUDED_BY_GRAPH.

Voir aussi

section \includedbygraph, section \includegraph, section \hideincludegraph et option INCLUDED_BY_GRAPH.

\directorygraph

Lorsque cette commande est placée dans un bloc de commentaires d'un répertoire (voir la section \dir), Doxygen génère un graphe de répertoire pour ce répertoire. Le graphe de répertoire sera généré quelle que soit la valeur de DIRECTORY_GRAPH.

Voir aussi

section \hidedirectorygraph, option DIRECTORY_GRAPH.

\collaborationgraph

Lorsque cette commande est placée dans un bloc de commentaires d'une classe, Doxygen génère un graphe de collaboration pour cette classe. Le graphe de collaboration sera généré quelle que soit la valeur de COLLABORATION_GRAPH.

Voir aussi

section \hidecollaborationgraph, option COLLABORATION_GRAPH.

\hidecollaborationgraph

Lorsque cette commande est placée dans un bloc de commentaires d'une classe, Doxygen ne génère pas de graphe de collaboration pour cette classe. Le graphe de collaboration ne sera pas généré quelle que soit la valeur de COLLABORATION_GRAPH.

Voir aussi

section \collaborationgraph, option COLLABORATION_GRAPH.

\inheritancegraph['{option}']

Lorsque cette commande est placée dans un bloc de commentaires d'une classe, Doxygen génère un graphe d'héritage pour cette classe conforme à l'option. Le graphe d'héritage sera généré, conformément à l'option, quelle que soit la valeur de CLASS_GRAPH. Les valeurs possibles de l'option sont les mêmes que celles qui peuvent être utilisées avec CLASS_GRAPH. Si aucune option n'est spécifiée, la valeur YES est supposée.

Voir aussi

section \hideinheritancegraph, option CLASS_GRAPH.

\hideinheritancegraph

Lorsque cette commande est placée dans un bloc de commentaires d'une classe, Doxygen ne génère pas de graphe d'héritage pour cette classe. Le graphe d'héritage ne sera pas généré quelle que soit la valeur de CLASS_GRAPH.

Voir aussi

section \inheritancegraph, option CLASS_GRAPH.

\groupgraph

Lorsque cette commande est placée dans un bloc de commentaires d'une commande \defgroup, Doxygen génère un graphe de dépendance de groupe pour ce groupe. Le graphe de groupe sera généré quelle que soit la valeur de GROUP_GRAPHS.

Voir aussi

section \hidegroupgraph, option GROUP_GRAPHS.

\hidegroupgraph

Lorsque cette commande est placée dans un bloc de commentaires d'une commande \ defGroup, alors Doxygen ne générera pas de graphique de dépendance de groupe pour ce groupe. Le graphique de groupe ne sera pas généré quelle que soit la valeur de GROUP_GRAPHS.

Voir aussi

section \groupgraph, option GROUP_GRAPHS.

\showenumvalues

Lorsque cette commande est placée dans un bloc de commentaires d'un enum, alors Doxygen affichera les valeurs d'énumération spécifiées pour cet énumération, quelle que soit la valeur de SHOW_ENUM_VALUES.

Voir aussi

section \hideenumvalues, option SHOW_ENUM_VALUES.

\hideenumvalues

Lorsque cette commande est placée dans un bloc de commentaires d'une énumération, le doxygen ne montrera pas les valeurs d'énumération spécifiées pour cet énumération, quelle que soit la valeur de SHOW_ENUM_VALUES.

Voir aussi

section \showenumvalues, option SHOW_ENUM_VALUES.

\qualifier <label> | "(text)"

Avec cette commande, il est possible d'ajouter des étiquettes de qualification personnalisées aux membres et classes. Ces étiquettes seront affichées dans la sortie de la même manière que les étiquettes générées automatiquement telles que "statique", "en ligne" et "final".

Par exemple, pour indiquer qu'une fonction n'est destinée qu'aux tests, on pourrait ajouter qualifer test.

\category <name> [<header-file>] [<header-name>]

Pour Objective-C uniquement: indique qu'un bloc de commentaires contient une documentation pour une catégorie de classe avec nom <nom>. Les arguments sont égaux à la commande \class.

Voir aussi

section \class.

\class <name> [<en-tête-file>] [<name-name>]

Indique qu'un bloc de commentaires contient une documentation pour une classe avec nom <nom>. Éventuellement, un fichier d'en-tête et un nom d'en-tête peuvent être spécifiés. Si l'en-tête est spécifié, un lien vers une copie textuelle de l'en-tête sera inclus dans la documentation HTML. L'argument <header-name> peut être utilisé pour écraser le nom du lien qui est utilisé dans la documentation de classe à autre chose que <header-file>. Cela peut être utile si le nom d'inclusion n'est pas situé sur le chemin d'inclusion par défaut (comme <x11 / x.h>). Avec l'argument <header-name>, vous pouvez également spécifier à quoi devrait ressembler l'inclusion, en ajoutant des guillemets ou des accolades autour du nom. Des accolades sont utilisés si le nom est donné. Notez que les deux derniers arguments peuvent également être spécifiés à l'aide de la commande \headerfile.

Exemple :

/ * Une classe factice * / 

test de classe 
{ 
}; 

/ *! \ class test class.h "inc / class.h" 
* \ Brief Il s'agit d'une classe de test. 
* 
* Quelques détails sur la classe de test. 
*/
 Cliquez ici pour la documentation HTML correspondante générée par Doxygen.

\concept <name>

Indique qu'un bloc de commentaires contient une documentation pour un concept C ++ 20 avec nom <nom>. Voir également la commande \headerfile pour spécifier l'en-tête qu'un utilisateur doit inclure pour utiliser le concept.

\def <nom>

Indique qu'un bloc de commentaires contient une documentation pour une macro #define.

Exemple :

/ *! \fichier define.h 
     \bref test définit 

     Il s'agit de tester la documentation des définies. 
* / 

/ *! 
    \def MAX (x, y) 
    Calcule le maximum de \a x et \a y. 
* / 

/ *! 
    \brief Calcule la valeur absolue de son argument \a x. 
    \param x valeur d'entrée. 
    \renvoie la valeur absolue de \a x. 
* / 
#define abb (x) (((x)> 0)? (x) :-( x)) 
#define max (x, y) ((x)> (y)? (x) :( y)) 
#define min (x, y) ((x)> (y)? (y) :( x)) 
    / *! <Calcule le minimum de \a x et \a y. * /

Cliquez [ichttps://www.doxygen.nl/manual/examples/define/html/define_8h.html) pour la documentation HTML correspondante générée par Doxygen.

\defgroup <name> (group title)

Indique qu'un bloc de commentaires contient une documentation pour des sujets de classes, modules, concepts, fichiers ou espaces de noms. Cela peut être utilisé pour classer les symboles et documenter ces catégories. Vous pouvez également utiliser des groupes comme membres d'autres groupes, construisant ainsi une hiérarchie de groupes.

L'argument <nom> doit être un identifiant à mot à mot unique.

Voir aussi

pages Grouping, sections \ingroup, \addtogroup et \weakgroup.

\dir [<path fragment>]

Indique qu'un bloc de commentaires contient une documentation pour un répertoire. L'argument "Fragment de chemin" devrait inclure le nom du répertoire et suffisamment de chemin pour être unique en ce qui concerne les autres répertoires du projet. L'option STRIP_FROM_PATH détermine ce qui est éliminé du chemin complet avant qu'il n'apparaisse dans la sortie.

\enum <name>

Indique qu'un bloc de commentaires contient une documentation pour une énumération, avec nom <name>. Si l'enum est membre d'une classe et que le bloc de documentation est situé en dehors de la définition de la classe, la portée de la classe doit également être spécifiée. Si un bloc de commentaires est situé directement devant une déclaration d'énumération, le commentaire \enum peut être omis.

Note
Le type d'énumération anonyme ne peut pas être documenté, mais les valeurs d'une énumération anonyme peuvent.

Exemple :

classe enum_test 
{ 
    public:
        enum TEnum {Val1, Val2}; 

        / *! Une autre énumération, avec des documents en ligne * / 
        enum AnotherEnum
        { 
            V1, / *! <Valeur 1 * / 
            V2 / *! <Valeur 2 * / 
        }; 
}; 

/ *! \class Enum_Test 
* La description de la classe. 
* / 

/ *! \enum Enum_Test :: TEnum 
* Une description du type d'énumération. 
* / 

/ *! \var Enum_Test :: TEnum Enum_Test :: Val1 
* La description de la première valeur d'énumération. 
* /

Cliquez ici pour la documentation HTML correspondante générée par Doxygen.

\example['{lineno}'] <file-name>

Indique qu'un bloc de commentaires contient une documentation pour un exemple de code source. Le nom du fichier source est <file-name>. Le contenu de ce fichier sera inclus dans la documentation, juste après la documentation contenue dans le bloc de commentaires. Vous pouvez ajouter l'option {lineno} pour activer les numéros de ligne pour l'exemple si vous le souhaitez. Tous les exemples sont placés dans une liste. Le code source est analysé pour les membres documentés et les classes. S'il est trouvé, les noms sont référencés avec la documentation. Les fichiers ou répertoires source peuvent être spécifiés à l'aide de la balise EXAMPLE_PATH du fichier de configuration de Doxygen.

Si <file-name> lui-même n'est pas unique pour l'ensemble d'exemples de fichiers spécifiés par la balise EXAMPLE_PATH, vous pouvez inclure une partie du chemin absolu pour supprimer toute embiguïté.

Si plusieurs fichiers source sont nécessaires pour l'exemple, la commande \include peut être utilisée.

Exemple :

/ ** une classe Exemple_Test. 
* Plus de détails sur cette classe. 
* /

class Exemple_Test
{ 
    public: 
    / ** Un exemple de fonction membre. 
      * Plus de détails sur cette fonction. 
      * / 
    void exemple();
};

void Exemple_Test :: Exemple () {}

/ ** \exemple exemple_test.cpp 
* Ceci est un exemple de la façon d'utiliser la classe Exemple_Test. 
* Plus de détails sur cet exemple. 
* /

Où le fichier exemple exemple_test.cpp ressemble à ce qui suit : 

void main()
{
    Exemple_Test t;
    t.exemple();
}

Cliquez ici pour la documentation HTML correspondante générée par Doxygen.

Voir aussi

section \include.

\endinternal

Cette commande termine un fragment de documentation qui a été démarré par une commande \internal. Le texte entre \internal et \endinternal ne sera visible que si INTERNAL_DOCS est défini sur YES.

\extends <name>

Cette commande peut être utilisée pour indiquer manuellement une relation d'héritage, lorsque le langage de programmation ne prend pas en charge ce concept nativement (par exemple C).

Le fichier manual.c dans l'exemple répertoire montre comment utiliser cette commande (voir également \memberof pour le fichier complet).

Cliquez ici pour la documentation HTML correspondante générée par Doxygen.

Voir aussi

section [\implements**] et section \memberof.

\file [<name>]

Indique qu'un bloc de commentaires contient une documentation pour un fichier source ou d'en-tête avec nom <nom>. Le nom de fichier peut inclure (une partie de) le chemin si le nom de fichier seul n'est pas unique. Si le nom du fichier est omis (c'est-à-dire que la ligne après \file est laissée vide), le bloc de documentation qui contient la commande \file appartiendra au fichier dans lequel il se trouve.

Attention
La documentation des fonctions globales, des variables, des typèdes et des énumérations ne sera incluse dans la sortie que si le fichier dans lequel ils se trouvent est également documenté ou si EXTRACT_ALL est défini sur oui.

Exemple :

/ ** \file file.h 
  * Une brève description du fichier. 
  * Une description de fichier plus élaborée. 
  * / 

/ ** 
  * Une valeur entière globale. 
  * Plus de détails sur cette valeur. 
  * / 
extern int globalValue;

Cliquez ici pour la documentation HTML correspondante générée par Doxygen.

Note
Dans l'exemple ci-dessus, JAVADOC_AUTOBRIEF a été défini sur YES dans le fichier de configuration.

\fileInfo ['{' option '}']

Affiche (une partie) du nom de fichier dans lequel cette commande est placée. L'option peut être name, extension, filename, directory ou full, avec

  • name le nom du fichier sans extension
  • extension l'extension du fichier
  • filename le nom de fichier, c'est-à-dire le nom plus l'extension
  • directory le répertoire du fichier donné
  • full le chemin d'accès complet et le nom du fichier donné.

Dans le cas où aucune option n'est spécifiée, filename est utilisé à moins que FULL_PATH_NAMES ne soit défini sur YES, auquel cas full est utilisé.

Note
La commande \fileinfo ne peut pas être utilisée comme argument sur la commande \file

Voir aussi

section \lineinfo.

\lineinfo

Affiche le numéro de ligne à l'intérieur du fichier où cette commande est placée.

Voir aussi

section \fileinfo.

\fn (Déclaration de fonction)

Indique qu'un bloc de commentaires contient une documentation pour une fonction (globale ou en tant que membre d'une classe). Cette commande n'est nécessaire que si un bloc de commentaires n'est pas placé devant (ou derrière) la déclaration ou la définition de la fonction.

Si votre bloc de commentaires est devant la déclaration ou la définition de la fonction, cette commande peut (et pour éviter que la redondance ne soit) omise.

Une déclaration de fonction complète, y compris les arguments, doit être spécifiée après la commande \fn sur une seule ligne, car l'argument se termine à la fin de la ligne !

Cette commande est équivalente à \var, \typedef et \property.

Attention
N'utilisez pas cette commande si elle n'est pas absolument nécessaire, car elle conduira à la duplication des informations et donc à des erreurs.

Exemple : 

class Fn_Test 
{ 
    public : 
        const char * membre (char, int) throw (std :: out_of_range); 
}; 

const char * Fn_Test :: membre (char c, int n) throw (std :: out_of_range) {} 

/ *! \class Fn_Test 
  *  \brief classe Fn_Test
  * 
  *  Détails sur Fn_Test. 
  * / 

/ *! \fn const char * Fn_Test :: membre (char C, int n) 
  * \brief une fonction membre. 
  * \param c un caractère. 
  * \param n un entier. 
  * \exception std :: out_of_range paramètre hors de portée. 
  * \return un pointeur de caractère. 
  * /
  ``` 

Cliquez [ici](https://www.doxygen.nl/manual/examples/func/html/class_fn___test.html) pour la documentation HTML correspondante générée par Doxygen.

**Voir aussi**
>sections[**\var**](#var), [**\property**](#property) et [**\typedef**](#typedef).

---

<a id="headerfile"></a>
### \headerfile &lt;header-file&gt; [&lt;header-name&gt;]

Destiné à être utilisé pour la documentation de classe, de structure ou syndicale, où la documentation est devant la définition. Les arguments de cette commande sont les mêmes que le deuxième et le troisième argument de [**\class**](#class). Le nom &lt;header-file&gt; fait référence au fichier qui doit être inclus par l'application pour obtenir la définition de la classe, de la structure ou de l'union. L'argument &lt;header-name&gt; peut être utilisé pour écraser le nom du lien qui est utilisé dans la documentation de la classe à autre chose que &lt;header-file&gt;. Cela peut être utile si le nom d'inclusion n'est pas situé sur le chemin d'inclusion par défaut (comme `<x11/x.h>`).

Avec l'argument &lt;header-name&gt;, vous pouvez également spécifier à quoi devrait ressembler l'inclusion, en ajoutant des guillemets ou des accolades autour du nom. Par défaut, des accolades  sont utilisés si le nom est donné.

Si une paire de guillemets est donnée pour l'argument &lt;header-file&gt; ou &lt;header-name&gt;, le fichier actuel (dans lequel la commande a été trouvée) sera utilisé mais avec des quotes. Donc, pour un bloc de commentaires avec une commande `\headfile` à l'intérieur d'un fichier `test.h`, les trois commandes suivantes sont équivalentes : 

```doxygen
\headfile test.h "test.h" 
\headfile test.h " "  
\headfile " "

Pour obtenir des chevrons, vous n'avez pas besoin de spécifier quoi que ce soit, mais si vous souhaitez être explicite, vous pouvez utiliser l'un des éléments suivants : 

\headerfile test.h <test.h> 
\headfile test.h <> 
\headerfile <>

Pour inverser globalement la représentation de l'inclusion par défaut vers les inclusions locales, vous pouvez définir FORCE_LOCAL_INCLUDES sur YES.

Pour désactiver les informations réglez SHOW_HEADERFILE sur NO.

\hideinitializer

Par défaut, la valeur d'une définition et l'initialisateur d'une variable sont affichées à moins qu'elles ne soient supérieures à 30 lignes. En mettant cette commande dans un bloc de commentaires d'une définition ou d'une variable, l'initialisateur est toujours caché. Le nombre maximum de lignes d'initialisation peut être modifié au moyen du paramètre de configuration MAX_INITIALIZER_LINES,, la valeur par défaut est de 30.

Voir aussi

section \showinitializer.

\idlexcept <name>

Indique qu'un bloc de commentaires contient une documentation pour une exception IDL avec le nom <name>.

\implements <name>

Cette commande peut être utilisée pour indiquer manuellement une relation d'héritage, lorsque le langage de programmation ne prend pas en charge ce concept nativement (par exemple C).

Le fichier manual.c dans l'exemple répertoire montre comment utiliser cette commande (voir également \memberof pour le fichier complet).

Cliquez ici pour la documentation HTML correspondante générée par Doxygen.

Voir aussi

section \extends et section \memberof.

\ingroup (<groupname> [<groupname>] *)

Si la commande \ingroup est placée dans un bloc de commentaires d'une entité composée (comme la classe, le fichier ou l'espace de noms), il sera ajouté au(x) groupe(s) identifié(s) par le <groupame> (s). Dans le cas des membres (comme la variable, les fonctions, les typedefs et les enums), le membre ne sera ajouté qu'à un seul groupe (pour éviter les cibles de liaison ambiguës au cas où un membre ne serait pas documenté dans le contexte de sa classe, de son espace de noms ou de son fichier, mais uniquement visible dans le cadre d'un groupe).

Voir aussi

page Grouping, sections \defgroup, \addtogroup, and \weakgroup.

\interface <name> [<header-file>] [<header-name>]

Indique qu'un bloc de commentaires contient une documentation pour une interface avec le nom <nom>. Les arguments sont égaux aux arguments de la commande \class.

Voir aussi

section \class.

\internal

Cette commande démarre un fragment de documentation destiné à un usage interne uniquement. Le fragment se termine naturellement à la fin du bloc de commentaires. Vous pouvez également forcer la section interne à se terminer plus tôt en utilisant la commande \endinternal.

Si la commande internalest placée dans une section (voir par exemple \section) toutes les sous-sections après la commande sont également considérées comme internes. Seule une nouvelle section au même niveau mettra fin au fragment qui est considéré comme interne.

Vous pouvez utiliser INTERNAL_DOCS dans le fichier de configuration pour afficher (YES) ou masquer (NO) la documentation interne.

Voir aussi

section \endinternal.

\mainpage [(titre)]

Si a commande \mainpage est placée dans un bloc de commentaires le bloc est utilisé pour personnaliser la page d'index (en html) ou le premier chapitre (dans latex).

L'argument de titre est facultatif et remplace le titre par défaut que Doxygen génère normalement. Si vous ne voulez pas de titre, vous pouvez spécifier notitle comme argument de \mainpage.

Voici un exemple :

/ *! \mainpage Ma Page d'Index Personnel 
  * 
  * \section intro_sec Introduction 
  * 
  * Voici l'introduction. 
  * 
  * \section install_sect  Installation 
  * 
  * \sous-section étape 1 Etape 1: Ouvrir la boîte 
  * 
  * etc... 
  * /

Vous pouvez vous référer à la page principale en utilisant : \ref.

Voir aussi

section \section, section \subsection et section \page.

\memberof <name>

Cette commande fait d'une fonction un membre d'une classe de la même manière que \relates, sauf qu'avec cette commande la fonction est représentée comme un véritable membre de la classe. Cela peut s'avérer utile lorsque le langage de programmation ne prend pas en charge le concept de fonctions membres de manière native (par exemple en C).

Il est également possible d'utiliser cette commande avec \public, \protected ou \private.

Exemple : Le fichier manual.c dans l'exemple de répertoire montre comment utiliser cette commande : 

/ ** 
  * \ File manual.c 
  * / 

TypEDEF Struct Object Object; //! <Type d'objet 
Typedef Struct Vehicle Vehicle; //! <Type de véhicule 
TypeDef Struct Car Car; //! <Type de voiture 
Truck Truck Trumpef Struct; //! <Type de camion 

/ *! 
  * Classe d'objets de base. 
  * / 
struct Objet
{ 
    int ref;    //! <\ private  Compteur de Référence 
}; 

/ *! 
  * Incrémente le nombre de référence d'objet par un. 
  * \public \memberof Objet 
* / 
static Objet * objRef (Objet * obj); 

/ *! 
  * Décrémente le nombre de référence un par un . 
  * \public \memberof Objet 
  * / 
static Objet * objUnref (Objet * obj); 

/ *! 
  * Classe Véhicule
  * \extends Objet 
  * / 
struct Vehicule
{ 
    Objet base //! <\protected classe de base.
}; 

/ *! 
  * Démarre le véhicule. 
 * \public \memberof Vehicule 
* / 
void vehicleStart(Vehicule *obj);

/ *! 
  * Arrête le véhicule. 
  * \public \memberof Vehicule 
  * / 
void vehiculeStop(Vehicule *obj);


/ *! 
  * Classe voiture. 
  * \extends Vehicule 
  * / 
struct voiture
{ 
    Vehicule base //! <\protected classe de base. 
}; 

/ *! 
  * Classe de camions. 
  * \extends le véhicule 
  * / 
struct camion
{ 
    Vehicule base //! <\protected classe de base. 
}; 

/ *! 
  * Fonction principale. 
  * 
  * Ref VehicLestart (), objref (), objunref (). 
  * / 
int main (void) 
{ 
    Vehicule C; 
    vehiculeStart ((Vehicule *) & c); 
}

Cliquez ici pour la documentation HTML correspondante générée par Doxygen.

Voir aussi

sections \extends, \implements, \public, \protected et \private.

\module <name>

Indique qu'un bloc de commentaires contient une documentation pour un module C ++ 20 avec nom <name>.

\name [(header)]

Cette commande transforme un bloc de commentaires en une définition d'en-tête d'un groupe de membres. Le bloc de commentaires doit être suivi d'un bloc @ {... @} contenant les membres du groupe.

Voir la section groupes de membres pour un exemple.

\namespace <name>

Indique qu'un bloc de commentaires contient une documentation pour un espace de noms avec nom <name>.

\nosubgrouping

Cette commande peut être placée dans la documentation d'une classe. Elle peut être utilisé en combinaison avec le regroupement des membres pour éviter que Doxygen mette un groupe de membres en tant que sous-groupe d'une section Public/Protected/Private/. ...

Voir aussi

sections \publicsection, \protectedsection et \privatesection.

\overload [(function declaration)]

Cette commande peut être utilisée pour générer le texte standard suivant pour une fonction de membre surchargé :

Il s'agit d'une fonction membre surchargée, fournie pour des raisons de commodité. Elle ne diffère de la fonction ci-dessus que par les arguments qu'elle accepte.

Si la documentation de la fonction de membre surchargé n'est pas située devant la déclaration ou la définition de la fonction, l'argument facultatif doit être utilisé pour spécifier la déclaration correcte de la fonction surchargée. Bien sûr, lorsque la commande \overload est directement devant la fonction de membre surchargé et que l'argument facultatif est utilisé, cela devrait également être la déclaration correcte de la fonction surchargée.

Toute autre documentation dans le bloc de documentation sera annexée après le message généré.

Remarque 1 :

Vous êtes responsable du fait qu'il existe effectivement un membre documenté précédemment qui est surchargé par celui-ci. Pour éviter que ce document ne réorganise la documentation, vous devez définir SORT_MEMBER_DOCS sur NO dans ce cas.

Remarque 2 :

Une seule commande \ surcharge peut être présente dans un bloc de commentaires.

Exemple :

Class Overload_test 
{ 
    public: 
        void drawRect (int, int, int, int); 
        void drawRect (const Rect & r); 
}; 

void Overload_Test :: drawRect (int x, int y, int w, int h) {} 
void Overload_Test :: drawRect (const Recct & r) {} 

/ *! \class Overload_Test 
  * \brief une brève description. 
  * 
  * Plus de texte. 
  * / 

/ *! \fn void Overload_Test :: drawRect (int x, int y, int w, int h) 
  * Cette commande dessine un rectangle avec un coin supérieur gauche à (\a x, \a y), 
  * largeur \a w et hauteur \a h. 
  * / 

/ *! 
  * \Overload void Overload_Test :: drawRect (const Rect & r) 
  * /

Cliquez ici pour la documentation HTML correspondante générée par Doxygen.

\package <name>

Indique qu'un bloc de commentaires contient une documentation pour un package Java avec nom <name>.

\page <name> (title)

Indique qu'un bloc de commentaires contient un morceau de documentation qui n'est pas directement lié à une classe, un fichier ou un membre spécifique. Le générateur HTML crée une page contenant la documentation. Le générateur latex démarre une nouvelle section dans la « documentation de la page » du chapitre.

Exemple : 

/ *! \page page1 Une page de documentation 
    \table des matières 
    Texte principal. 
    \section sec Un exemple de section 
    Cette page contient les sous-sections \ref sous-section1 et \ref sous-section2. 
    Pour plus d'informations, voir page \ref page2. 
    \sous-section sous-section1 La première sous-section 
    Texte. 
    \sous-section sous-section2 La deuxième sous-section 
    Plus de texte. 
  * / 

  / *! \page page2 Une autre page 
    Encore plus d'informations. 
  * /

Cliquez ici pour la documentation HTML correspondante générée par Doxygen.

Note : L'argument <name> consiste en une combinaison de lettres et de chiffres numériques. Si vous souhaitez utiliser des lettres supérieures (par exemple MyPage1), ou des lettres de cas mixtes (par exemple MyPage1) dans l'argument <name>, vous devez définir CASE_SENSE_NAMES à YES. Cependant, cela n'est conseillé que si votre système de fichiers est sensible à la casse. Sinon (et pour une meilleure portabilité), vous devez utiliser toutes les lettres en minuscule (par exemple MyPage1) pour <name> dans toutes les références à la page.

Voir aussi

section \section, section \subsection et section \ref.

\private

Indique que le membre documenté par le bloc de commentaires est privé, c'est-à-dire ne devrait être accessible que par d'autres membres de la même classe.

Notez que Doxygen détecte automatiquement le niveau de protection des membres dans les langues orientées objet. Cette commande est destinée à une utilisation uniquement lorsque la langue ne prend pas en charge le concept de niveau de protection nativement (par exemple C, PHP 4).

Pour démarrer une section de membres privés, d'une manière similaire au marqueur de classe "privé:" en C ++, utilisez \privatesection.

Voir aussi

sections \memberof, \public, \protected et \privatesection.

\privatesection

Démarrage d'une section de membres privés, d'une manière similaire au marqueur de classe "privé:" en C ++. Indique que le membre documenté par le bloc de commentaires est privé, c'est-à-dire ne devrait être accessible que par d'autres membres de la même classe.

Voir aussi

sections \member, \public, \protected et \private.

\property (qualified property name)

Indique qu'un bloc de commentaires contient une documentation pour une propriété (globale ou en tant que membre d'une classe). Cette commande est équivalente à \fn, \typedef et \var.

Voir aussi

sections \fn, \typedef et \var.

\protected

Indique que le membre documenté par le bloc de commentaires est protégé, c'est-à-dire ne doit être accessible que par d'autres membres dans les mêmes classes ou dérivées.

Notez que Doxygen détecte automatiquement le niveau de protection des membres dans les langues orientées objet. Cette commande est destinée à une utilisation uniquement lorsque la langue ne prend pas en charge le concept de niveau de protection nativement (par exemple C, PHP 4).

Pour démarrer une section des membres protégés, d'une manière similaire au marqueur de classe "protégé:" en C ++, utilisez \protectedsection.

Voir aussi

sections \memberof, \public, \private et \protectedsection.

\protectedsection

Démarrage d'une section des membres protégés, d'une manière similaire au marqueur de classe "protégé:" en C ++. Indique que le membre documenté par le bloc de commentaires est protégé, c'est-à-dire ne doit être accessible que par d'autres membres dans les mêmes classes ou dérivées.

Voir aussi

sections \member, \public, \private et \protected.

\protocole <name> [<header-file>] [<header-name<]

Indique qu'un bloc de commentaires contient une documentation pour un protocole dans Objective-C avec nom <name>. Les arguments sont égaux à la commande \class.

Voir aussi

section \class.

\public

Indique que le membre documenté par le bloc de commentaires est public, c'est-à-dire peut être accessible par toute autre classe ou fonction.

Notez que Doxygen détecte automatiquement le niveau de protection des membres dans les langues orientées objet. Cette commande est destinée à une utilisation uniquement lorsque la langue ne prend pas en charge le concept de niveau de protection nativement (par exemple C, PHP 4).

Pour lancer une section de membres publics, d'une manière similaire au marqueur de classe « public : » en C++, utilisez \publicsection.

Voir aussi

sections \memberof, \protected, \private et \publicsection.

\publicsection

Démarrage d'une section des membres du public, d'une manière similaire au marqueur de classe "public:" en C ++. Indique que le membre documenté par le bloc de commentaires est public, c'est-à-dire peut être accessible par toute autre classe ou fonction.

Voir aussi

sections \memberof, \protected, \private et \public.

\pure

Indique que le membre documenté par le bloc de commentaires est pur virtuel, c'est-à-dire qu'il est abstrait et n'a aucune implémentation qui lui est associée.

Cette commande est destinée à une utilisation uniquement lorsque le langage ne prend pas en charge le concept de méthodes virtuelles pures nativement (par exemple C, PHP 4).

\relates <name>

Cette commande peut être utilisée dans la documentation d'une fonction non membre <name>. Il met la fonction à l'intérieur de la section « fonction associée » de la documentation de classe. Cette commande est utile pour documenter les fonctions non amies qui sont néanmoins fortement couplées à une certaine classe. Il empêche la nécessité d'avoir à documenter un fichier, mais ne fonctionne que pour les fonctions.

Exemple : 

/ *! 
  * Une classe de type String. 
  * / 

class String
{ 
    friend int strcmp (const String &, const String &); 
}; 

/ *! 
  * Compare deux chaînes. 
  * / 

int strcmp (const String & s1, const String & s2) 
{ 
} 

/ *! \relates String 
  * Une fonction de débogage de chaîne. 
  * / 
void StringDebug () 
{ 
}

Cliquez ici pour obtenir la documentation HTML correspondante générée par Doxygen.

Équivalent à \relates

\relatesalso <name>

Cette commande peut être utilisée dans la documentation d'une fonction non membre <name>. Il met la fonction à la fois dans la section « fonction associée » de la documentation de classe ainsi que la laissant à son emplacement de documentation de fichier normal. Cette commande est utile pour documenter les fonctions non amies qui sont néanmoins fortement couplées à une certaine classe. Il ne fonctionne que pour les fonctions.

\relatedalso <name>

Équivalent à \relatealso

\showInitializer

Par défaut, la valeur d'une définition et l'initialisateur d'une variable ne sont affichées que si elles font moins de 30 lignes. En mettant cette commande dans un bloc de commentaires d'une définition ou d'une variable, l'initialisateur est affiché inconditionnellement. Le nombre maximum de lignes d'initialisation peut être modifié au moyen du paramètre de configuration MAX_INITIALIZER_LINES,, la valeur par défaut est de 30.

Voir aussi

section \hideinitializer.

\static

Indique que le membre documenté par le bloc de commentaires est statique, c'est-à-dire qu'il fonctionne sur une classe, plutôt que sur une instance de la classe.

Cette commande est destinée à une utilisation uniquement lorsque le langage ne prend pas en charge le concept de méthodes statiques nativement (par exemple C).

\struct <name> [<header-file>] [<header-name>]

Indique qu'un bloc de commentaires contient une documentation pour une structure avec nom <name>. Les arguments sont égaux aux arguments de la commande \class.

Voir aussi

section\class.

\typedef (typedef declaration)

Indique qu'un bloc de commentaires contient une documentation pour un typedef (global ou en tant que membre d'une classe). Cette commande est équivalente à \fn, \property et \var.

Voir aussi

section \fn, \property et \var.

\union <name> [<header-file>] [<header-name>]

Indique qu'un bloc de commentaires contient une documentation pour une union avec nom <name> . Les arguments sont égaux aux arguments de la commande \class.

Voir aussi

section\class.

\var (variable declaration)

Indique qu'un bloc de commentaires contient une documentation pour une valeur de variable ou d'énumération (globale ou en tant que membre d'une classe). Cette commande est équivalente à \fn, \property et \typedef.

Notez que pour PHP, on peut également spécifier le type de variable. La syntaxe est similaire à celle du phpDocumentor, mais la description doit commencer à la ligne suivante, c'est-à-dire :

@var dataType $ varname
Description

Voir aussi

sections \fn, \property et \typedef.

\vhdlflow [(title for the flow chart)]

Il s'agit d'une commande spécifique VHDL, qui peut être placée dans la documentation d'un processus pour produire un graphique de flux de la logique dans le processus. Facultativement, un titre pour le graphique de flux peut être donné.

Note
Actuellement, le graphique de débit n'apparaîtra que dans la sortie HTML.

\weakgroup <name> [(title)]

Peut être utilisé exactement comme \addtogroup, mais a une priorité plus faible lorsqu'il s'agit de résoudre des conflits de définition de groupe.

Voir aussi : page Grouping et la section \addtogroup.

--- Indicateurs de section ---

\attention { attention text }

Démarre un paragraphe où un message qui a besoin d'attention peut être saisi. Le paragraphe sera en retrait. Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes attention adjacentes seront jointes à un seul paragraphe. La commande \attention se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée.

\author { list of authors }

Démarre un paragraphe où un ou plusieurs noms d'auteur peuvent être entrés. Le paragraphe sera en retrait. Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes adjacentes \author seront jointes à un seul paragraphe. Chaque description de \author commencera une nouvelle ligne. Alternativement, une commande \author peut mentionner plusieurs auteurs. La commande \author se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée.

Exemple : 

/ *! 
  * \brief       Une assez jolie classe. 
  * \details     Cette classe est utilisée pour démontrer un certain nombre de commandes de section. 
  * \author      John Doe 
  * \author      Jan Doe 
  * \version     4.1a 
  * \date        1990-2011 
  * \pre         Premier initialise le système. 
  * \bug         Toutes les mémoire ne sont pas libérées lors de la suppression d'un objet de cette classe. 
  * \warning     Une mauvaise utilisation peut faire planter  
  * \copyright   GNU Licence publique. 
  * / 
classe SomeNiceClass {};

Cliquez ici pour la documentation HTML correspondante générée par Doxygen.

\authors { list of authors }

Équivalent à \author.

\brief { brief description }

Commence un paragraphe qui sert de brève description. Pour les classes et les fichiers, la brève description sera utilisée dans les listes et au début de la page de documentation. Pour les membres de la classe et du fichier, la brève description sera placée à la déclaration du membre et a été apparentée à la description détaillée. Une brève description peut s'étendre sur plusieurs lignes (bien qu'il soit conseillé de le garder bref !). Une brève description se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée. Si plusieurs commandes \brief sont présentes, elles seront jointes. Voir la section \author pour un exemple.

Synonyme à \short.

\bug { bug description }

Commence un paragraphe où un ou plusieurs bugs peuvent être signalés. Le paragraphe sera en retrait. Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes adjacentes \ bug seront jointes à un seul paragraphe. Chaque description de bogue commencera sur une nouvelle ligne. Alternativement, une commande bug peut mentionner plusieurs bogues. La commande \bug se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée. Voir la section \author pour un exemple.

La description ajoutera également un élément à une liste de bogues distincte et les deux instances de la description seront référencées. Chaque élément de la liste des bogues sera précédé d'un en-tête qui indique l'origine de l'élément.

La liste des bogues et les entrées correspondantes peuvent être désactivées en définissant le GENERATE_BUGLIST sur NO.

\cond [(section-label)]

Démarre une section conditionnelle qui se termine par une commande \endcond correspondante, qui se trouve généralement dans un autre bloc de commentaires. L'objectif principal de cette paire de commandes est d'exclure (conditionnellement) une partie d'un fichier du traitement (dans la version plus ancienne de Doxygen, cela n'a pu être obtenu qu'à l'aide de commandes de prérocesseur C).

La section entre \cond et \endcond peut être incluse en ajoutant son étiquette de section à l'option de configuration ENABLED_SECTIONS. Si l'étiquette de section est omise, la section sera exclue du traitement sans condition. L'étiquette de section peut être une expression logique composée d'étiquettes de section, de parenthèses, de && (AND), || (OR) et ! (NOT). Si vous utilisez une expression, vous devez la mettre entre parenthèses, c'est-à-dire \cond (!LABEL1 && LABEL2).

Pour les sections conditionnelles dans un bloc de commentaires, il faut utiliser un bloc \if ... \endif. Lorsque vous utilisez \cond et que la condition n'est pas satisfaite, le bloc de commentaires actuel est terminé et tout jusqu'à ce que la correspondance \endcond soit supprimée et qu'un nouveau bloc de commande soit démarré là-bas.

Les sections conditionnelles peuvent être imbriquées. Dans ce cas, une section imbriquée ne sera affichée que si elle et sa section contenant sont incluses.

Voici un exemple montrant les commandes en action :

/ ** Une interface * /
clas Intf
{ 
    public: 
    / ** Une méthode * / 
        virtual void func () = 0; 

    /// @cond TEST 

    / ** Une méthode utilisée pour tester * / 
    virtual void test () = 0; 

    /// @endcond
};

/// @cond dev
/ * 
  * L'implémentation de l'interface 
  * /
class Implementation : public Intf
{ 
    public: 
        void func (); 

    /// @cond test 
    void test (); 
    /// @endcond 

    /// @cond 
    / ** Cette méthode est obsolète et fait 
      * Ne pas apparaître dans la documentation. 
      * / 
    void obsolete (); 
    /// @endcond
};

/// @endcond

La sortie sera différente selon que ENABLED_SECTIONS contiennent ou non le TEST, ou DEV.

Voir aussi

sections \if, \ifnot, \else, \elseif, \endif, \endcond, et ENABLED_SECTIONS.

Note
En raison du moment d'analyse, les commandes \cond et \endcond ne peuvent pas être utilisées dans les alias.

Commence un paragraphe où le droit d'auteur d'une entité peut être décrit. Ce paragraphe sera en retrait. Le texte du paragraphe n'a pas de structure interne spéciale. Voir la section \author pour un exemple.

\date { date description }

Commence un paragraphe dans lequel une ou plusieurs dates peuvent être saisies. Le paragraphe est indenté. Le texte du paragraphe n'a pas de structure interne particulière. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes \date adjacentes seront réunies en un seul paragraphe. Chaque description de date commence sur une nouvelle ligne. Une seule commande \date peut également mentionner plusieurs dates. La commande \date se termine lorsqu'une ligne blanche ou une autre commande de section est rencontrée. Voir la section \author pour un exemple.

\showdate "<format>" [ <date_time> ]

Affiche la date et l'heure basées sur le <format> et <date_time>. Où le <format> est une chaîne dans laquelle les jetons suivants ont une signification particulière :

CodeDesciption
%yAnnée sans siècle sous la forme d'un nombre décimal complété par un zéro..
%YAnnée avec le siècle sous forme de nombre décimal.
%mMois sous forme de nombre décimal complété par des zéros.
%-mLe mois sous forme de nombre décimal.
%bMois en tant que nom régional.
%BMois comme le nom complet régional.
%dJour du mois sous la forme d'un nombre décimal complété par des zéros.
%-dJour du mois sous forme de nombre décimal.
%uLe jour de la semaine sous forme de nombre décimal (1-7), le lundi valant 1.
%wLe jour de la semaine sous forme de nombre décimal (0-6), le dimanche valant 0.
%aJour de la semaine sous forme de nom abrégé.
%AJour de la semaine sous forme de nom complet.
  
%HHeure (horloge de 24 heures) sous la forme d'un nombre décimal complété par un zéro.
%-HHeure (horloge de 24 heures) sous forme de nombre décimal complété par un zéro.
%IHeure (horloge de 12 heures) sous forme de nombre décimal.
%-IHeure (horloge de 12 heures) sous forme de nombre décimal complété par un zéro .
%MMinute sous forme de nombre décimal complété par un zéro.
%-MMinute sous forme de nombre décimal.
%SSeconde sous forme de nombre décimal complété par un zéro.
%-SSeconde sous forme de nombre décimal.
%pÉquivalent local de AM ou PM.
  
%%Le caractère %


Notez que le <format> doit être entre guillemets doubles.

Dans le cas où le <date_time> est spécifié, il doit avoir la représentation suivante :

  • date facultative où la date est :
    • 4 chiffres pour l'année
    • un signe moins
    • un ou 2 chiffres pour le mois
    • un signe moins
    • un ou 2 chiffres pour la journée
  • time facultatif où time est :
    • espace blanc
    • un ou 2 chiffres pour les heures
    • ponctuation deux points
    • un ou 2 chiffres pour les minutes
    • Lorsque le format contient %s ou%-s
      • ponctuation deux points
      • 2 chiffres pour les secondes

Dans le cas où le <date_time> n'est pas spécifié, la date et l'heure actuelles sont utilisées.

Voici un exemple :

- \showdate "%A %d-%m-%Y" 2015-3-14
- \showdate "%a %d-%m-%y" 2015-3-14
- \showdate "%-m.%d%y" 2015-3-14
- \showdate "%A %d-%m-%Y %H:%M:%S" 2015-3-14 03:04:15
- \showdate "%A %d-%m-%Y %H:%M" 2015-3-14 03:04

Dans le cas de OUTPUT_LANGUAGE=english, cela se traduit par :

  • Saturday 14-03-2015
  • Sat 14-03-15
  • 3.1415
  • Saturday 14-03-15 03:04:15
  • Saturday 14-03-15 03:04

Dans le cas de OUTPUT_LANGUAGE=dutch, cela se traduit par :

  • Zaterdag 14-03-15
  • ZA 14-03-2015
  • 3.1415
  • Zaterdag 14-03-15 03:04:15
  • Zaterdag 14-03-15 03:04

\deprecated { description }

Démarre un paragraphe indiquant que ce bloc de documentation appartient à une entité dépréciée. Peut être utilisé pour décrire des alternatives, une durée de vie attendue, etc. Le paragraphe sera en retrait. Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes adjacentes \deprecated seront jointes à un seul paragraphe. Chaque description de dépréciation commencera sur une nouvelle ligne. La commande \deprecated se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée.

La description ajoutera également un élément à une liste distincte et les deux instances de la description seront référencées. Chaque élément de la liste obsolète sera précédé d'un en-tête qui indique l'origine de l'élément.

La liste dépréciée et les entrées correspondantes peuvent être désactivées en définissant la liste GENERATE_DEPRECATEDLIST sur NO.

\details { detailed description }

Tout comme \brief démarre une brève description, \details démarre la description détaillée. Vous pouvez également démarrer un nouveau paragraphe (ligne vide), puis la commande \details n'est pas nécessaire.

\noop ( text to be ignored )

Tout le texte, y compris la commande, jusqu'à la fin de la ligne est ignoré. Cette commande sera le plus souvent utilisée en combinaison avec ALIASES pour ignorer les commandes non prises en charge qui sont présentes, par exemple ,dans d'autres outils de traitement.

\raisewarning ( text to be shown as warning )

Tout le texte, à l'exclusion de la commande, jusqu'à la fin de la ligne, est littéralement affiché comme un avertissement de documentation. Le texte, y compris la commande, est supprimé de la sortie. La commande sera le plus souvent utilisée en combinaison avec des ALIASES pour montrer un avertissement spécifique.

Exemple :

\raisewarning Mon avertissement spécifique

\warnNoDoc

\warnNoDoc{Mon avertissement spécifique}

avec :

ALIASES  = warnNoDoc="\raisewarning Documentation manquante"
ALIASES += warnNoDoc{1}="\raisewarning Documentation incomplète: \1"

entraînera : 

ex_1.md:1: avertissement: mon avertissement spécifique 
ex_1.md:3: avertissement: documentation manquante 
ex_1.md:5: avertissement: documentation incomplète: mon avertissement spécifique

\else

Démarre une section conditionnelle si la section conditionnelle précédente n'a pas été activée. La section précédente aurait dû être démarrée par une commande \if, \ifnot, ou\elseif.

Voir aussi

sections \if, \ifnot, \elseif et \endif.

\elseif (section-label)

Démarre une section de documentation conditionnelle si la section précédente n'a pas été activée. Une section conditionnelle est désactivée par défaut. Pour l'activer, vous devez mettre la section-label après la balise ENABLED_SECTIONS dans le fichier de configuration. L'étiquette de section peut être une construction d'expression logique des noms de section, des supports ronds, && (AND), || (OR) et ! (NOT). Les blocs conditionnels peuvent être imbriqués. Une section imbriquée n'est activée que si toutes les sections de fermer sont également activées.

Voir aussi

sections \if, \ifnot, \elseif et \endif.

\endcond

Termine une section conditionnelle qui a été lancée par \cond.

Voir aussi

section \cond.

Note
En raison du moment d'analyse, les commandes \endcond et \cond ne peuvent pas être utilisées dans les \aliases.

\endif

Termine une section conditionnelle qui a été lancée par \if ou \ifnot pour chaque \if ou \ifnot une et une seule correspondance \endif doit suivre.

Voir aussi

sections \if, \ifnot, \else et \elseif.

\exception <exception-object> {exception description}

Démarre une description d'exception pour un objet d'exception avec nom <exception-object> . Suivi d'une description de l'exception. L'existence de l'objet d'exception n'est pas vérifiée. Le texte du paragraphe n'a pas de structure interne particulière. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes \exception adjacentes seront réunies en un seul paragraphe. Chaque description d'exception commence sur une nouvelle ligne. La description de \exception se termine lorsqu'une ligne blanche ou une autre commande de découpage est rencontrée. Voir la section[] \fn](#fn) pour un exemple.

\if (section-label)

Démarre une section de documentation conditionnelle. La section se termine par une commande correspondante \endif. Une section conditionnelle est désactivée par défaut. Pour l'activer, vous devez mettre la section-label après la balise ENABLED_SECTIONS dans le fichier de configuration.

L'étiquette de section peut être une construction d'expression logique des noms de section, des accolades, && (AND), || (OR) et ! (NOT). Si vous utilisez une expression, vous devez l'envelopper dans des accolades c'est-à-dire if (! Label1 && label2).

Les blocs conditionnels peuvent être imbriqués. Une section imbriquée n'est activée que si toutes les sections qui l'entourent le sont également.

Le \if et le \endif correspondant doivent se trouver dans le même bloc de commentaires. Lorsqu'un bloc conditionnel doit s'étendre sur plus d'un bloc de commentaires, il faut utiliser \cond ... \endcond.

Exemple :

/ *! Documentation sans condition. 
  * \if Cond1 
  *     Inclus uniquement si Cond1 est défini. 
  * \endif 
  * \ifi Cond2 
  *     Inclus uniquement si Cond2 est défini. 
  *         \if Cond3 
  *             Inclus uniquement si Cond2 et Cond3 sont définis. 
  *         \endif 
  *         Plus de texte. 
  *     \endif 
  *     Texte inconditionnel. 
  * /

Vous pouvez également utiliser des commandes conditionnelles à l'intérieur des alias. Pour documenter une classe en deux langues, vous pouvez par exemple utiliser :

Exemple 2 :

/*! \english
  *  This is English.
  *  \endenglish
  *  \dutch
  *  Dit is Nederlands.
  *  \enddutch
  */
class Example
{
};

où les alias suivants sont définis dans le fichier de configuration :

ALIASES  = "english=\if english" \
           "endenglish=\endif" \
           "dutch=\if dutch" \
           "enddutch=\endif"

et ENABLED_SECTIONS peut être utilisé pour activer l'anglais ou le néerlandais.

Voir aussi

sections \endif, \ifnot, \else, \elseif, \cond, \endcond et ENABLED_SECTIONS .

\ifnot (section-label)

Démarre une section de documentation conditionnelle. La section se termine par une commande correspondante \endif. Cette section conditionnelle est activée par défaut. Pour la désactiver, vous devez mettre la section-label après la balise ENABLED_SECTIONS dans le fichier de configuration. L'étiquette de section peut être une construction d'expression logique des noms de section, des accolades, && (AND), || (OR) et ! (NOT).

Voir aussi

sections \endif, \if, \else, \elseif, \cond, \endcond et ENABLED_SECTIONS .

\important { important text }

Démarre un paragraphe où un message qui a besoin du message important peut être entré. Le paragraphe sera indenté. Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes adjacentes \important seront jointes à un seul paragraphe. La commande \important se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée.

\invariant { description of invariant }

Commence un paragraphe où l'invariant d'une entité peut être décrit. Le paragraphe sera indenté. Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes \invariant adjacentes seront jointes à un seul paragraphe. Chaque description \invariant commencera sur une nouvelle ligne. Alternativement, une commande \invariant peut mentionner plusieurs invariants. La commande \invariant se termine lorsqu'une ligne vierge ou une autre commande de coupe est rencontrée.

\note {text}

Démarre un paragraphe où une note peut être entrée. Le paragraphe sera indenté. Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes adjacentes \note seront jointes à un seul paragraphe. Chaque description de la note commencera sur une nouvelle ligne. Alternativement, une commande \note peut mentionner plusieurs notes. La commande \note se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée. Voir la section \par pour un exemple.

\par [(paragraph title)] { paragraph }

Si un titre de paragraphe est donné, cette commande démarre un paragraphe avec un titre défini par l'utilisateur. Le titre s'étend jusqu'à la fin de la ligne. Le paragraphe suivant la commande sera indenté.

Si aucun titre de paragraphe n'est donné, cette commande commencera un nouveau paragraphe. Cela fonctionnera également à l'intérieur d'autres commandes de paragraphe (comme \param ou **\warning) sans mettre fin à cette commande.

Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. La commande \par se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée.

Exemple : 

/ *! \ class Par_Test 
  * Texte normal. 
  * 
  * \par Paragraphe défini par l'utilisateur:
  * Contenu du paragraphe. 
  * 
  * \par 
  * Nouveau paragraphe sous le même titre. 
  * 
  * \note 
  * Cette note se compose de deux paragraphes. 
  * Il s'agit du premier paragraphe. 
  * 
  * \par 
  * Et c'est le deuxième paragraphe. 
  * 
  * Texte suivant. 
  * / 

class Par_Test {};

Cliquez ici pour la documentation HTML correspondante générée par Doxygen.

\param [<dir>] <parameter-name> { parameter description }

Démarre une description du paramètre pour un paramètre de fonction avec le nom <parameter-name> , suivi d'une description du paramètre. L'existence du paramètre est vérifiée et un avertissement est donné si la documentation de ce paramètre (ou de tout autre) est manquante ou non présente dans la déclaration ou la définition de la fonction.

La commande \param a un attribut facultatif, <dir>, spécifiant la direction du paramètre. Les valeurs possibles sont "[in]", "[out]" et "[in, out]"; Notez les [corchets] de cette description. Pour les valeurs bidirénionales, les instructions "dans" et "out" peuvent être spécifiées dans n'importe quel ordre, et elles peuvent soit être écrites, soit séparées avec une virgule (,) ou un espace. Cela signifie que par exemple les valeurs "[outin]" ou "[in out]" sont également valides. Notez qu'il est également possible de mettre des espaces blancs entre la commande et le <dir>, . Lorsqu'un paramètre est à la fois entrée et sortie, [in, out] est utilisé comme attribut. Voici un exemple pour la fonction memcpy :

/ *! 
  * Copie des octets d'une zone de mémoire source à une zone de mémoire de destination, 
  * ou les deux zones peuvent ne pas se chevaucher. 
  * @param [out]    dest    la zone de mémoire ou copier. 
  * @param [in]     src     la zone de mémoire à copier. 
  * @param [en]     n       le nombre d'octets à copier.
  * /
void memcpy (void * dest, const void * src, size_t n);

La description des paramètres est un paragraphe sans structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe.

Plusieurs commandes adjacentes \param seront jointes à un seul paragraphe. Chaque description du paramètre commencera sur une nouvelle ligne. La description \param se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée. Voir la section \fn pour un exemple.

Notez que vous pouvez également documenter plusieurs paramètres avec une seule commande \param à l'aide d'une liste séparée par des virgules. Voici un exemple :

/ ** Régle la position. 
  *  @param x, y, z  coordonnées de la position dans l'espace 3D. 
  * /
void setPosition(double x,double y,double z,double t)
{
}

Notez que pour PHP, on peut également spécifier le type (ou les types si vous les séparez avec un symbole de tuyau) qui sont autorisés pour un paramètre (car cela ne fait pas partie de la définition). La syntaxe est la même que pour le phpDocumentor, c'est-à-dire :

@param  datatype1|datatype2 $paramname description

\parblock

Pour les commandes qui s'attendent à un seul paragraphe comme argument (tel que \par, \param et \warning), la commande \parblock permet de démarrer une description qui couvre plusieurs paragraphes, qui se termine ensuite par \endparblock.

Exemple :

/ ** Exemple d'une commande param avec une description composée de deux paragraphes 
  * \param p 
  * \parblock 
  * Premier paragraphe de la description de param. 
  * 
  * Deuxième paragraphe de la description de param. 
  * \endparblock 
  * Le reste du bloc de commentaires se poursuit. 
  * /

Notez que la commande \parblock peut également apparaître directement après le premier argument de \param.

\endparblock

Cela termine un bloc de paragraphes commencés avec \parblock.

### \tparam <template-parameter-name> { description }

Démarre un paramètre de modèle pour une classe ou un paramètre de modèle de fonction avec le nom <template-parameter-name>, suivi d'une description du paramètre de modèle.

Sinon, similaire à \param.

\post { description of the postcondition }

Commence un paragraphe dans lequel la postcondition d'une entité peut être décrite. Le paragraphe est indenté. Le texte du paragraphe n'a pas de structure interne particulière. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes \post adjacentes seront réunies en un seul paragraphe. Chaque postcondition commencera sur une nouvelle ligne. Une commande \post peut également mentionner plusieurs postconditions. La commande\postse termine lorsqu'une ligne blanche ou une autre commande de section est rencontrée.

\pre { description of the precondition }

Commence un paragraphe où la condition préalable d'une entité peut être décrite. Le paragraphe sera indenté. Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes adjacentes \pre seront jointes à un seul paragraphe. Chaque condition préalable commencera sur une nouvelle ligne. Alternativement, une commande \pre peut mentionner plusieurs conditions préalables. La commande \pre se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée.

\remark { remark text }

Commence un paragraphe où une ou plusieurs remarques peuvent être entrées. Le paragraphe sera indenté. Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes adjacentes \remark seront jointes à un seul paragraphe. Chaque remarque commencera sur une nouvelle ligne. Alternativement, une commande \remark peut mentionner plusieurs remarques. La commande \ramark se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée.

\remarks { remark text }

Équivalent à \remark.

\result { description of the result value }

Équivalent à \return.

\return { description of the return value }

Démarre une description de valeur de retour pour une fonction. Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes adjacentes \return seront jointes à un seul paragraphe. La description \return se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée. Voir la section \fn pour un exemple.

\returns { description of the return value }

Équivalent à \return.

\retval <return value> { description }

Démarre une description de la valeur de retour d'une fonction avec le nom <return value> suivie d'une description de la valeur de retour. Le texte du paragraphe qui forme la description n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes adjacentes \retval seront jointes à un seul paragraphe. Chaque description de la valeur de retour commencera sur une nouvelle ligne. La description \retval se termine lorsqu'une ligne vierge ou une autre commande de sectionnement est rencontrée.

\sa { references }

Démarre un paragraphe où une ou plusieurs références croisées aux classes, fonctions, méthodes, variables, fichiers ou URL peuvent être spécifiées. Deux noms rejoints par :: ou # sont compris comme faisant référence à une classe et à l'un de ses membres. L'une des nombreuses méthodes ou constructeurs surchargés peut être sélectionné en incluant une liste entre parenthèses de types d'arguments après le nom de la méthode.

Synonyme de \see.

Voir aussi

section autolink pour plus d'informations sur la façon de créer des liens vers des objets.

\see { references }

Equivalent to \sa. Introduit pour compatibilité avec Javadoc.

\short { short description }

Équivalent à \brief.

\since { text }

Cette commande permet de spécifier depuis quand (version ou heure) une entité est disponible. Le paragraphe qui suit \since n'a pas de structure interne particulière. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe.

\test { paragraph describing a test case }

Commence un paragraphe où un ou plusieurs cas de test peuvent être décrits. Le paragraphe sera indenté. Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes \test adjacentes seront jointes à un seul paragraphe. Chaque description de \test commencera sur une nouvelle ligne. Alternativement, une commande \test peut mentionner plusieurs cas de test. La commande \test se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée.

La description ajoutera également un élément à une liste Test distincte et les deux instances de la description seront référencées. Chaque élément de la liste Test sera précédé d'un en-tête qui indique l'origine de l'élément.

La liste Test et les entrées correspondantes peuvent être désactivées en définissant GENERATE_TESTLIST sur NO.

\throw { exception description }

Synonyme à \exception.

Note :

la commande \throws est un synonyme de cette commande.

Voir aussi

section \exception.

\throws <exception-object> { exception description }

Équivalent à \throw.

\todo { paragraph describing what is to be done }

Commence un paragraphe où un ou plusieurs articles todo sont décrits. Le paragraphe sera indenté. Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes adjacentes \todo seront jointes à un seul paragraphe. Chaque description de todo commencera sur une nouvelle ligne. Alternativement, une commande \todo peut mentionner plusieurs descriptions de todo. La commande \todo se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée.

La description ajoutera également un élément à une liste Todo distincte et les deux instances de la description seront référencées. Chaque élément de la liste Todo sera précédé d'un en-tête qui indique l'origine de l'élément.

La liste Todo et les entrées correspondantes peuvent être désactivées en définissant le GENERATE_TODOLIST sur NO.

\version { version number }

Démarre un paragraphe où une ou plusieurs chaînes de version peuvent être saisies. Le paragraphe sera indenté. Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes adjacentes \version seront jointes à un seul paragraphe. Chaque description de la version commencera sur une nouvelle ligne. Alternativement, une commande \version peut mentionner plusieurs chaînes de version. La commande \version se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée. Voir la section \author pour un exemple.

\warning { warning message }

Démarre un paragraphe où un ou plusieurs messages d'avertissement peuvent être entrés. Le paragraphe sera indenté. Le texte du paragraphe n'a pas de structure interne spéciale. Toutes les commandes d'amélioration visuelle peuvent être utilisées à l'intérieur du paragraphe. Plusieurs commandes \warning adjacentes seront jointes à un seul paragraphe. Chaque description d'avertissement commencera sur une nouvelle ligne. Alternativement, une commande \warning peut mentionner plusieurs avertissements. La commande \warning se termine lorsqu'une ligne vierge ou une autre commande de section est rencontrée. Voir la section \author pour un exemple.

\xrefitem <key> "heading" "list title" { text }

Cette commande est une généralisation de commandes telles que \todo et \bug. Elle peut être utilisée pour créer des sections de texte définies par l'utilisateur qui sont automatiquement croisées entre le lieu d'occurrence et une page connexe, qui sera générée. Sur la page associée, toutes les sections du même type seront collectées.

Le premier argument <key> est un identifiant représentant de manière unique le type de la section. Le deuxième argument est une chaîne citée représentant le titre de la section en vertu duquel le texte est passé au quatrième argument. Le troisième argument (titre de liste) est utilisé comme titre pour la page associée contenant tous les éléments avec la même clé. L'argument de deuxième et troisième chaîne ne peut pas contenir une nouvelle ligne. Les clés "todo", "test", "bug" et "deprecated" sont prédéfinies.

Pour avoir une idée sur la façon d'utiliser la commande \xrefittem et quel est son effet, considérez la liste todo, qui (pour une sortie en anglais) peut être considérée comme un alias de la commande :

\xrefitem todo "Todo" "Todo List"

Comme il est très fastidieux et source d'erreurs de répéter les trois premiers paramètres de la commande pour chaque section, la commande est destinée à être utilisée en combinaison avec l'option **ALIASES dans le fichier de configuration. Pour définir une nouvelle commande \reminder, par exemple, il faut ajouter la ligne suivante au fichier de configuration :

ALIASES += "reminder=\xrefitem reminders \"Reminder\" \"Reminders\""

Remarquez l'utilisation des guillemets échappés pour les deuxième et troisième arguments de la commande \xrefitem.

Dans le cas où le paramètre "(en-tête)" est la chaîne vide qu'aucune rupture n'est générée. Cela peut être utile lorsqu'il est utilisé en combinaison avec la commande \page, par exemple :

/ ** @page my_errors Mes erreurs 
  *  @brief Page d'erreurs 
  * 
  *  Contenu des pages d'erreurs. 
  * /

/ ** \error ERREUR 101: Dans le cas où un fichier ne peut pas être ouvert. 
     Vérifiez l'accès à la lecture / écriture du système de fichiers. * /
#define MY_ERR_CANNOT_OPEN_FILE                   101

/ ** \error ERREUR 102: Dans le cas où un fichier ne peut pas être fermé. 
     Vérifiez l'accès à la lecture / écriture du système de fichiers. * /
#define MY_ERR_CANNOT_CLOSE_FILE                  102

avec \error définie comme :

ALIASES += "error=\xrefitem my_errors \"\" \"\""

--- Commandes pour créer des liens ---

\addIndex (text)

Cette commande ajoute (texte) à l'index latex, DocBook et RTF.

\anchor

Cette commande place une ancre invisible, nommée dans la documentation à laquelle vous pouvez vous référer avec la commande \ref.

Voir aussi

section \ref.

\cite['{'[option]'}'] <label>

Ajoute une référence bibliographique dans le texte et dans la liste des références bibliographiques. Le <label> doit être une étiquette BibTex valide que l'on peut trouver dans l'un des fichiers .bib répertoriés dans CITE_BIB_FILES. Pour la sortie latex, le formatage de la référence dans le texte peut être configuré avec LATEX_BIB_STYLE. Pour d'autres formats de sortie, une représentation fixe est utilisée. Notez que l'utilisation de cette commande nécessite que l'outil bibtex soit présent dans le chemin de recherche.

Il existe un certain nombre d'options possibles :

  • number, shortauthor, year, ces options s'excluent mutuellement, si aucune d'entre elles n'est spécifiée, number est supposé.
    • number créer une référence numérique
    • shortauthor uniquement le nom de famille du premier auteur est donné, et au cas où plusieurs auteurs sont présents le texte "et al". est ajouté
    • year, l'année de publication est mentionnée (lorsqu'elle est spécifiée dans le fichier bibtex).
  • nopar, aucun crochet n'est ajouté
  • nocite, aucun lien vers une citation dans la bibliographie n'est fait (et la référence n'est pas ajoutée à la bibliographie en fonction de cet élément)

Cette commande termine un lien qui est démarré avec la commande \link.

Voir aussi

section \link.

Les liens générés automatiquement par Doxygen ont toujours le nom de l'objet auquel ils pointent comme texte de liaison.

La commande \link peut être utilisée pour créer un lien vers un objet (un fichier, une classe ou un membre) avec un texte de liaison spécifié par l'utilisateur. La commande link doit se terminer par une commande \endlink. Tout le texte entre les commandes \link et \endlink sert de texte pour un lien vers <link-object> spécifié comme le premier argument de \link.

Voir aussi

section autoLink pour plus d'informations sur les liens générés automatiquement et les objets de liens valides.

\ref <name> ["(texte)"]

Crée une référence à un symbole, un fichier, une section, une sous-section, une page ou une ancre nommés.

Pour la documentation HTML, la commande de référence générera un lien vers la section. Pour une section ou une sous-section, le titre de la section sera utilisé comme texte du lien. Pour une ancre, le texte facultatif entre les citations sera utilisé ou <name> si aucun texte n'est spécifié.

Dans le cas où <name> a des espaces (par exemple s'il fait référence à un nom de fichier contenant des espaces), vous devez ajouter des guillemets autour du <name>, par ex. "mon fichier.md".

Pour la documentation latex, la commande de référence sera la même, sauf si l'option PDF_HYPERLINKS a été définie sur NO, dans ce cas, elle génère le titre de section pour les sections ou le texte si <name> fait référence à une ancre suivie d'un numéro de page.

Voir aussi:

section \page pour un exemple de la commande \ref.

\refitem <name>

Tout comme la commande \ref, cette commande crée une référence à une section nommée, mais cette référence apparaît dans une liste démarrée par \secreflist et se termine par \endsecreflist. Un exemple d'une telle liste peut être vu en haut de la page.

\secreflist

Démarre une liste d'index d'éléments, créés avec \refitem, qui renvoient chacun à une section nommée.

\endsecreflist

Terminer une liste d'index démarrée avec \secreflist.

\subpage <name> ["(text)"]

Cette commande peut être utilisée pour créer une hiérarchie de pages. La même structure peut être réalisée en utilisant les commandes \defgroup et \ingroup, mais pour les pages, la commande \subpage est souvent plus pratique. La page principale (voir \mainpage) est généralement la racine de la hiérarchie.

Cette commande se comporte comme \ref dans le sens où elle crée une référence à une page intitulée <name> avec le texte de lien optionnel spécifié dans le deuxième argument.

Elle diffère de la commande \ref en ce qu'elle fonctionne uniquement pour les pages, et crée une relation parent-enfant entre les pages, où la page de l'enfant (ou sous-page) est identifiée par étiquette <name>.

Voir les commandes \section et \subsection si vous souhaitez ajouter de la structure sans créer plusieurs pages.

Note
Chaque page ne peut être la sous-page que d'une seule autre page et aucune relation cyclique n'est autorisée, c'est-à-dire que la hiérarchie des pages doit avoir une structure arborescente.

Voici un exemple :

/ *! \mainpage Un manuel simple

Quelques informations générales.

Ce manuel est divisé dans les sections suivantes :
- \subpage  intro
- \subpage  avancée "Utilisation avancée" 
* /

// -----------------------------------------------------------

/ *! \page intro Introduction
Cette page présente le sujet à l'utilisateur.
Vous pouvez maintenant passer à la \ref avancée "section avancée ".
* /

// -----------------------------------------------------------

/ *! \page avancée Utilisation avancée
Cette page est destinée aux utilisateurs avancés.
Assurez-vous que vous avez d'abord lu \ref intro "Introduction".
* /

\tableofcontents['{'[option[:level]][,option[:level]]*'}']

Crée une table des matières en haut d'une page, répertoriant toutes les sections et sous-sections de la page. L'option peut être HTML ou Latex ou XML ou DocBook. Lorsqu'un level est spécifié, il s'agit du niveau d'imbrication maximal qui est affiché. La valeur de level doit être compris entre 1 et 6, les valeurs en dehors de cette plage étant considérées comme 6. Si aucun level n'est spécifié, level est fixé à 6 (tout afficher). Si aucune option n'est spécifiée, \tableofcontents agit comme si seule l'option HTML et XML avait été spécifiée. En cas de commandes \tableofcontents multiples dans une page, la ou les option(s) seront utilisées en plus des option(s) déjà spécifiées, mais seul le dernier level d'une option est valide.

Avertissement
Cette commande ne fonctionne qu'à l'intérieur de la documentation de la page concernée et non dans d'autres blocs de documentation, et n'a d'effet que dans la sortie spécifiée !

\section <section-name> (section title)

Crée une section avec le nom <section-name>. Le titre de la section doit être spécifié comme deuxième argument de la commande \section.

Avertissement
Cette commande ne fonctionne que dans la documentation de la page connexe et non dans d'autres blocs de documentation !

Voir aussi

section \page pour un exemple de la commande \section.

\subsection <subsection-name> (subsection title)

Crée une sous-section avec le nom <subsection-name> . Le titre de la sous-section doit être spécifié comme deuxième argument de la commande \subsection.

Avertissement
Cette commande ne fonctionne que dans une section d'un bloc de documentation de page connexe et non dans d'autres blocs de documentation !

Voir aussi

section \page pour un exemple de la commande \subsection.

\subsubsection <subsubsection-name> (subsubsection title)

Crée une sous-section portant le nom <subsubsection-name>. Le titre de la sous-section doit être spécifié comme deuxième argument de la commande \subsubsection.

Avertissement
Cette commande ne fonctionne que dans une sous-section d'un bloc de documentation de page connexe et non dans d'autres blocs de documentation !

Voir aussi

section \page pour un exemple de la commande \section et \subsection.

\paragraph <paragraph-name> (paragraph title)

Crée un paragraphe nommé avec le nom <paragraph-name>. Le titre du paragraphe doit être spécifié comme deuxième argument de la commande \paragraph.

Avertissement
Cette commande ne fonctionne que dans une sous sous-section d'un bloc de documentation de page connexe et non dans d'autres blocs de documentation !

\subparagraph <subparagraph-name> (subparagraph title)

Crée un alinéa nommé avec le nom <subparagraph-name>. Le titre de l'alinéa doit être spécifié comme deuxième argument de la commande \subparagraph>.

Avertissement
Cette commande ne fonctionne que dans un paragraphe d'un bloc de documentation de page connexe et non dans d'autres blocs de documentation !

\subsubparagraph <subsubparagraph-name> (subsubparagraph title)

Crée un sous alinéa nommé avec nom <subsubparagraph-name>. Le titre du sous alinéa doit être spécifié comme deuxième argument de la commande\ subsubparagraph.

Avertissement
Cette commande ne fonctionne que dans un sous alinéa d'un bloc de documentation de page connexe et non dans d'autres blocs de documentation !

--- Commandes pour afficher des exemples ---

\dontinclude['{lineno}'] <file-name>

Cette commande peut être utilisée pour analyser un fichier source sans réellement textuellement, y compris dans la documentation (comme le fait la commande \include). Ceci est utile si vous souhaitez diviser le fichier source en pièces plus petites et ajouter de la documentation entre les pièces. Les fichiers ou répertoires sources peuvent être spécifiés à l'aide de la balise EXAMPLE_PATH du fichier de configuration de Doxygen.

Vous pouvez ajouter l'option lineno pour activer les numéros de ligne pour le code inclus si vous le souhaitez.

Vous pouvez ajouter l'option strip qui masquera toujours tous les commentaires spéciaux du code inclus, en remplacement du paramètre STRIP_CODE_COMMENTS , ou ajouter l'option nostrip pour toujours afficher les commentaires spéciaux.

Les déclarations et définitions de classe et de membres à l'intérieur du fragment de code sont "rappelé'' lors de l'analyse du bloc de commentaires qui contenait la commande \dontinclude.

Pour les descriptions ligne par ligne des fichiers sources, une ou plusieurs lignes de l'exemple peuvent être affichées à l'aide des commandes, \line, \skip, \skipline et \until . Un pointeur interne est utilisé pour ces commandes. La commande \dontinclude place le pointeur sur la première ligne de l'exemple.

Exemple :

/ *! Une classe de test. * /

class Inclure_Test
{ 
    public:
    /// une fonction membre 
    void example();
};

/ *! \page pag_example
  * \dontinclude include_test.cpp 
  * Notre fonction principale commence comme ceci: 
  * \skip main 
  *  \until { 
  * Nous créons d'abord un objet \c t de la classe Include_Test. 
  * \skipline Include_Test 
  * Ensuite, nous appelons la fonction membre example
  * \line example
  * Après cela, notre petite routine de test se termine. 
  *  \line } 
  * /
  ```

où l'exemple de fichier `include_test.cpp` ressemble à ceci :

```cpp
void main () 
{ 
    Include_Test t; 
    t.example (); 
}

Cliquez ici pour obtenir la documentation HTML correspondante générée par Doxygen.

Voir aussi

sections \line, \skip, \skipline, \until et \include.

\include['{'option'}'] <file-name>

Cette commande peut être utilisée pour inclure un fichier source en tant que bloc de code. La commande prend le nom d'un fichier include comme argument. Les fichiers ou répertoires source peuvent être spécifiés à l'aide de la balise EXAMPLE_PATH du fichier de configuration de Doxygen.

Si <file-name> lui-même n'est pas unique pour l'ensemble d'exemples de fichiers spécifiés par la balise EXAMPLE_PATH, vous pouvez inclure une partie du chemin absolu pour le rendre moins embigüe.

L'utilisation de la commande \include est équivalente à l'insertion du fichier dans le bloc de documentation et à l'entourer avec les commandes \code et \endcode.

L'objectif principal de la commande \include est d'éviter la duplication de code en cas d'exemples de blocs qui se composent de plusieurs fichiers source et d'en-tête.

Pour une description ligne par ligne d'un fichier source, utilisez la commande \dontinclude en combinaison avec les commandes \line, \skip, \skipline, et \until.

Alternativement, la commande \snippet peut être utilisée pour inclure uniquement un fragment d'un fichier source. Pour que cela fonctionne, le fragment doit être marqué.

Note
Les commandes spéciales de Doxygen ne fonctionnent pas à l'intérieur des blocs de code. Il est cependant autorisé à nidifier les commentaires de style C dans un bloc de code.

L' option peut être soit lineno soit doc, et il est également possible de spécifier local.

  • L'option lineno peut être utilisée pour activer les numéros de ligne pour le code inclus si vous le souhaitez.
  • L'option doc peut être utilisée pour traiter le fichier comme une documentation plutôt que du code.
  • L'option local peut être utilisée pour que Doxygen interprète le code comme s'il était dans la classe ou l'espace de noms dans lequel la commande include apparaît, plutôt que l'espace de noms global.
  • L'option strip peut être utilisée pour toujours masquer les commentaires spéciaux du code inclus, lce qui annule le paramètre STRIP_CODE_COMMENTS, et l'option nostrip peut être utilisée pour toujours afficher les commentaires spéciaux. Ces options n'ont aucun effet en combinaison avec l'option doc

Lorsque l'option doc est utilisée, il existe également l'option raise qui peut être spécifiée pour augmenter toutes les sections trouvées dans le fichier référencé d'un certain montant. Par exemple :

\include{doc,raise=1} file.dox

Traitera n'importe quelle \section de niveau 1 trouvée dans file.dox en tant que subsection de niveau 2 , et toute \subsection de niveau 2 dans un niveau 3 \subsubsection, etc. De même, pour Markdown, une section # sera traitée comme une section ##.

De plus, il existe l'option \prefix qui peut être utilisée pour ajouter un préfixe à chaque étiquette des sections incluses, afin qu'elles restent uniques. Par exemple : 

\include{doc,prefix=fn_} file.dox

traitera par \section s1 trouvée dans file.dox comme si elle était spécifiée comme \section fn_s1.

Note
La documentation incluse ne devrait pas contenir de panneaux de commentaires car ils apparaîtront également dans la documentation.

Voir aussi

sections \example, \dontinclude, \verbatim, \includedoc et \snippet.

\includelineno <file-name>

Cette commande est obsolète et est toujours prise en charge pour des raisons de retro-compatibilité, elle fonctionne de la même manière que \include {lineno}.

Voir aussi

section \include {lineno}.

\includedoc['{'option'}'] <file-name>

Cette commande est obsolète et est toujours prise en charge pour des raisons de retro-compatibilité, elle fonctionne de la même manière que \include {doc}.

Les option(s) sont les mêmes qui peuvent être utilisées avec \include. lors de l'utilisation de l'option doc.

Voir aussi

section \include {doc}.

\line ( pattern )

Cette commande effectue une recherche ligne par ligne dans l'exemple qui a été inclus pour la dernière fois à l'aide de \include ou \dontinclude jusqu'à ce qu'elle trouve une ligne non vide. Si cette ligne contient le motif spécifié, elle est écrite sur la sortie.

Le pointeur interne qui est utilisé pour garder une trace de la ligne actuelle dans l'exemple, est placé sur le début de la ligne suivant la ligne non verbale trouvée (ou à la fin de l'exemple si aucune ligne ne pouvait être trouvée).

Voir la section \dontinclude pour un exemple.

\skip ( pattern )

Cette commande recherche ligne par ligne à travers l'exemple qui a été inclus pour la dernière fois en utilisant \include ou \dontinclude jusqu'à ce qu'il trouve une ligne qui contient le modèle spécifié.

Le pointeur interne qui est utilisé pour garder une trace de la ligne actuelle dans l'exemple, est palcé sur le début de la ligne qui contient le motif spécifié (ou à la fin de l'exemple si le motif n'a pas pu être trouvé).

Voir la section \dontinclude pour un exemple.

\skipline (pattern)

Cette commande recherche ligne par ligne à travers l'exemple qui a été inclus pour la dernière fois en utilisant \include ou \dontinclude jusqu'à ce qu'il trouve une ligne qui contient le modèle spécifié. Il écrit ensuite la ligne à la sortie.

Le pointeur interne qui est utilisé pour garder une trace de la ligne actuelle dans l'exemple, est placé sur le début de la ligne suivant la ligne écrite (ou à la fin de l'exemple si le motif n'a pas pu être trouvé).

Note :

La commande :

\skipline pattern

équivaut à: 

\skip pattern
\line pattern

Voir la section \dontinclude pour un exemple.

\snippet['{'option'}'] <file-name> ( block_id )

Lorsque la commande \include peut être utilisée pour inclure un fichier complet comme code source, cette commande peut être utilisée pour citer uniquement un fragment de fichier source. Dans le cas où cela est utilisé comme <file-name>, le fichier actuel est selectionné pour extraire le fragment.

Par exemple, l'insertion de la commande suivante dans la documentation fait référence à un extrait du fichier example.cpp résidant dans un sous-répertoire qui doit être désigné par EXAMPLE_PATH.

  \snippet snippets/example.cpp Ajoute une resource

Le texte qui suit le nom du fichier est l'identifiant unique de l'extrait. Il est utilisé pour délimiter le code cité dans le fichier d'extrait concerné, comme le montre l'exemple suivant, qui correspond à la commande \snippet ci-dessus :

QImage image(64, 64, QImage::Format_RGB32);
image.fill(qRgb(255, 160, 128));

//! [Ajoute une resource]
    document->addResource(QTextDocument::ImageResource,
        QUrl("mydata://image.png"), QVariant(image));
//! [Adding a resource]
    ...

Notez que les lignes contenant les marqueurs de bloc ne seront pas incluses, donc la sortie sera :

document->addResource(QTextDocument::ImageResource,
    QUrl("mydata://image.png"), QVariant(image));

Notez également que les marqueurs [block_id] doivent apparaître exactement deux fois dans le fichier source.

L'option peut être lineno, trimleft ou doc, et en outre, local peut être spécifié.

  • L'option lineno peut être utilisée pour activer les numéros de ligne pour le code inclus si vous le souhaitez.
  • L'option trimleft peut être utilisée pour supprimer l'espacement commun devant toutes les lignes (en prenant également compte le réglage de la balise TAB_SIZE).
  • L'option doc peut être utilisée pour traiter le fichier comme une documentation plutôt que du code.
  • L'option local peut être utilisée pour que Doxygen interprète le code comme s'il était dans la classe ou l'espace de noms dans lequel la commande inclue apparaît, plutôt que l'espace de noms global.
  • L'option skip peut être utilisée pour toujours masquer les commentaires spéciaux du code inclus, la remplacement du paramètre [STRIP_CODE_COMMENTS] , et l'option nostrip peut être utilisée pour toujours afficher les commentaires spéciaux. Ces options n'ont aucun effet en combinaison avec l'option doc.

Lorsque l'option doc est utilisée, il existe également l'option raise qui peut être spécifiée pour augmenter toutes les sections trouvées dans le fichier référencé d'un certain montant. Par exemple :

\snippet{doc,raise=1} file.dox XXX
 ```

traitera toute `\section` de niveau 1 trouvée dans l'extrait comme une `\subsection` de niveau 2, et toute `\subsection` de niveau 2 comme une `\subsubsection` de niveau 3, etc. De même, pour Markdown, une section `#` sera traitée comme une section `##`.

En outre, l'option préfixe peut être utilisée pour ajouter un préfixe à chaque étiquette des sections incluses, afin qu'elles restent uniques. Par exemple :

```doxygen
 \include{doc,prefix=fn_} file.dox

traitera par \section s1 trouvée dans file.dox comme si elle était spécifiée comme \section fn_s1.

Note
La documentation incluse ne devrait pas contenir de panneaux de commentaires car ils apparaîtront également dans la documentation.

Voir la section \dontinclude pour une autre façon d'inclure les fragments d'un fichier source qui ne nécessite pas de marqueurs.

\snippetlineno <file-name> ( block_id )

Cette commande est obsolète et est toujours prise en charge pour des raisons de rétro compatibilité, elle fonctionne de la même manière que \snippet {lineno}.

Voir aussi

section\snippet {lineno}.

\snippetdoc['{'option'}'] <file-name> ( block_id )

Cette commande est obsolète et est toujours prise en charge pour des raisons de rétro compatibilité, elle fonctionne de la même manière que \snippet {doc}.

Les options sont les mêmes options qui peuvent être utilisées avec le \snippet lors de l'utilisation de l'option doc.

Voir aussi

section \snippet {doc} et \include {doc}.

\until ( pattern )

Cette commande écrit toutes les lignes de l'exemple qui a été inclus pour la dernière fois en utilisant \include ou \dontcinclude à la sortie, jusqu'à ce qu'il trouve une ligne contenant le modèle spécifié. La ligne contenant le motif sera également écrite.

Le pointeur interne qui est utilisé pour garder une trace de la ligne actuelle dans l'exemple, est placé sur le début de la ligne suivant la dernière ligne écrite (ou à la fin de l'exemple si le modèle n'a pas pu être trouvé).

Voir la section \dontcinclude pour un exemple.

\verbinclude <file-name>

Cette commande inclut le contenu du fichier <file-name> mot pour mot dans la documentation. Cette commande équivaut à coller le contenu du fichier dans la documentation et à placer les commandes \verbatim et \endverbatim autour de ce contenu.

Les fichiers ou répertoires que Doxygen doit rechercher peuvent être spécifiés à l'aide de la balise EXAMPLE_PATH du fichier de configuration de Doxygen.

\htmlinclude['[block]'] <file-name>

Cette commande comprend le contenu du fichier <file-name> tel quel dans la documentation HTML et tagué avec <htmlonly> dans la sortie XML générée. La commande équivaut à coller le contenu du fichier dans la documentation et à placer les commandes \htmlonly et \endhtmlonly autour de lui.

Normalement, le contenu du fichier indiqué par \htmLinclude est inséré tel quel. Lorsque vous voulez insérer un fragment HTML qui a la portée d'un bloc, comme un tableau ou une liste qui devrait apparaître à l'extérieur de <p>...</p>, cela peut conduire à un HTML invalide. Vous pouvez utiliser \htmlinclude[block] pour que Doxygen termine le paragraphe en cours et recommence après l'inclusion du fichier.

Les fichiers ou répertoires que Doxygen doit rechercher peuvent être spécifiés en utilisant la balise EXAMPLE_PATH du fichier de configuration de Doxygen.

Voir auss

section \htmlonly, \latexinclude, \rtfinclude, \maninclude, \docbookinclude et \xmlinclude.

\rtfinclude <file-name>

Cette commande comprend le contenu du fichier <file-name> tel quel dans la documentation RTF et tagué avec <rtfonly> dans la sortie XML générée. La commande équivaut à coller le contenu du fichier dans la documentation et à placer les commandes \ rtfonly et \endrtfonly autour de lui.

Les fichiers ou répertoires que Doxygen doit rechercher peuvent être spécifiés à l'aide de la balise EXAMPLE_PATH du fichier de configuration de Doxygen.

Voir aussi Section \rtfonly, \htmlinclude, \latexinclude, \maninclude, \docbookinclude et \xmlinclude.

\maninclude <file-name>

Cette commande comprend le contenu du fichier <file-name> tel qu'il figure dans la documentation MAN et étiqueté avec <manonly> dans la sortie XML générée. Cette commande équivaut à coller le contenu du fichier dans la documentation et à placer les commandes \manonly et \endmanonly autour de lui.

Les fichiers ou répertoires que Doxygen doivent rechercher peuvent être spécifiés à l'aide de la balise EXAMPLE_PATH du fichier de configuration de Doxygen.

Voir aussi

sections [\manonly], \htmlinclude, \latexinclude, \maninclude, \docbookinclude et \xmlinclude.

\docbookinclude <file-name>

Cette commande comprend le contenu du fichier <file-name> tel quel dans la documentation DocBook et tagué avec <docbookonly> dans la sortie XML générée. La commande équivaut à coller le contenu du fichier dans la documentation et à placer les commandes \docbookonly et \enddocbookonly autour de lui.

Les fichiers ou répertoires que Doxygen doit rechercher peuvent être spécifiés à l'aide de la balise EXAMPLE_PATH du fichier de configuration de Doxygen.

Voir aussi

sections \docbookonly, \latexinclude, \rtfinclude\maninclude, et \xmlinclude.

\xmlinclude <file-name>

Cette commande comprend le contenu du fichier <file-name> tel quel dans la documentation XML. La commande équivaut à coller le contenu du fichier dans la documentation et à placer les commandes \xmlonly et \endxmlonly autour de lui.

Les fichiers ou répertoires que Doxygen doit rechercher peuvent être spécifiés à l'aide de la balise EXAMPLE_PATH du fichier de configuration de Doxygen.

Voir aussi Section \ Xmlonly, \ htmLinclude, \ Latexinclude, \ rtfinclude, \ maninclude et \ docBookinclude.

sections \xmlonly, \htmlinclude\latexinclude, \rtfinclude\maninclude, et \docbookinclude.

--- Commandes pour les améliorations visuelles ---

\a <word>

Affiche l'argument <word> en italique. Utilisez cette commande pour souligner les mots. Utilisez cette commande pour faire référence aux arguments membres dans le texte en cours d'exécution.

Exemple : 

... Les coordonnées \a x et \a y sont utilisées pour ...

Cela se traduira par le texte suivant :

... Les coordonnées x et y sont utilisées pour ...

Équivalent à \e et \em. Pour souligner plusieurs mots, utilisez <em>plusieurs mots</em>.

\arg { item-description }

Cette commande a un argument qui continue jusqu'à la première ligne vide ou jusqu'à ce qu'un autre \arg soit rencontré. La commande peut être utilisée pour générer une liste d'arguments simples et non imbriqués. Chaque argument doit commencer par une commande \arg.

Exemple :

Dactylographie : 

\ arg \ c Alignleft alignement gauche. 
\ arg \ c AlignCenter alignement centré. 
\ arg \ c Alignement alignement droit.

Aucun autre type d'alignement n'est soutenu.

entraînera le texte suivant :

  • AlignLeft alignement gauche.
  • AlignCenter alignement centré.
  • AlignRight alignement droit.

Aucun autre type d'alignement n'est soutenu.

Note :

Pour les listes imbriquées, les commandes HTML doivent être utilisées.

Équivalent à **\li.

\b <word>

Affiche l'argument <word> en utilisant une police audacieuse. Équivalent à <b>word</b>. Pour mettre plusieurs mots en gras, utilisez <b>plusieurs mots</b>.

\c <word>

Affiche l'argument <word> à l'aide d'une police de machine à écrire. Utilisez-le pour faire référence à un mot de code. Équivalent à <tt>word</tt>.

Exemple :

Dactylographie : 

... Cette fonction renvoie \c void et non \c int ...

entraînera le texte suivant :

... Cette fonction renvoie void et non int ...

Équivalent à \p. Pour avoir plusieurs mots dans la police de machine à écrire, utilisez <tt>plusieurs mots</tt>.

\code['{''}']

Démarre un bloc de code. Un bloc de code est traité différemment du texte ordinaire. Il est interprété comme un code source. Les noms des classes et des membres et autres entités documentées sont automatiquement remplacées par des liens vers la documentation.

Par défaut, la langue supposée pour la mise en surbrillance de la syntaxe est basée sur l'emplacement où le bloc \code a été trouvé. Si cette partie d'un fichier Python par exemple, la surmonté de syntaxe se fera en fonction de la syntaxe Python.

Si le contexte ne permet pas de déterminer clairement la langue utilisée (par exemple, le commentaire se trouve dans un fichier .txt ou .markdown), vous pouvez également indiquer explicitement la langue, en plaçant l'extension de fichier typiquement associée par Doxygen à la langue entre crochets après le bloc de code. Voici un exemple :

\code {.py} 
class Python: 
    pass
\endcode 

\code {.cpp} 
class Cpp {}; 
\endcode

Si le contenu du bloc de code est dans un langage que Doxygen ne peut pas analyser, Doxygen affichera la sortie telle quelle. Vous pouvez rendre cela explicite en utilisant .unparsed, ou en donnant une autre extension que Doxygen ne supporte pas, par exemple :

\code {.unparsed} 
Montrez cela tel quel s'il vous plaît 
\endcode 

\code {.sh} 
Echo "Ceci est un script shell" 
\endcode

Voir aussi

sections \endcode et \verbatim.

Copie un bloc de documentation de l'objet spécifié par <link-object> et le colle à l'emplacement de la commande. Cette commande peut être utile pour éviter les cas où un bloc de documentation devrait autrement être dupliqué ou il peut être utilisé pour étendre la documentation d'un membre hérité.

L'objet de liaison peut pointer vers un membre (d'une classe, d'un fichier ou d'un groupe), une classe, un espace de noms, un groupe, une page ou un fichier (vérifié dans cet ordre). Notez que si l'objet pointé est un membre (fonction, variable, typedef, etc.), le composé (classe, fichier ou groupe) qui le contient doit également être documenté pour que la copie fonctionne.

Pour copier la documentation d'un membre d'une classe on peut, par exemple, mettre ce qui suit dans la documentation : 

/ *! @copydoc MyClass :: myfunction () 
  * Plus de documentation. 
  * /

Si le membre est surchargé, vous devez spécifier explicitement les types d'arguments (sans espaces !), comme dans les éléments suivants : 

```doxygen
//! @copydoc MyClass :: myfunction (type1, type2)

Les noms qualifiés ne sont nécessaires que si le contexte dans lequel le bloc de documentation est trouvé le nécessite.

La commande \copydoc peut être utilisée récursivement, mais les cycles dans la relation `\copydoc``seront cassés et signalés comme une erreur.

Notez que \copydoc foo() revient à faire: 

  \brief \copybrief foo()
  \details \copydetails foo()
  ```

Voir [**\copybrief**](#copybrief) et[**\copydetails**](#copydetails) pour copier uniquement la partie brève ou détaillée du bloc de commentaires.

---

<a id="copybrief"></a>
### \copybrief &lt;link-object&gt;

Fonctionne de la même manière que [**\copydoc**](#copydoc) mais ne copiera que la brève description, et non dans la documentation détaillée.

---

<a id="copydetails"></a>
### \copydetails &lt;link-object&gt;

Fonctionne de la même manière que [**\copydoc**](#copydoc) mais ne copiera que la documentation détaillée, pas la brève description.

---

<a id="docbookonly"></a>
### \docbookonly

Démarre un bloc de texte qui sera uniquement inclus dans la documentation DocBook générée et tagué avec `<docookonly>` dans la sortie XML générée. Le bloc se termine par une commande[**\enddocbookonly**](#enddocbookonly).

**Voir aussi**
>sections [**\manonly**](#manonly), [**\latexonly**](#latexonly)[**\rtfonly**](#rtfonly), [**\xmlonly**](#xmlonly)[**\htmlonly**](#htmlonly), et [**\docbookinclude**](#docbookinclude).

---

<a id="dot"></a>
### \dot ["caption"] [&lt;sizeindication&gt;=&lt;size&gt;]

Démarre un fragment de texte qui devrait contenir une description valide d'un graphique de points. Le fragment de texte se termine par [**\enddot**](#enddot). Doxygen transmet le texte sur dot et inclura l'image (et la carte d'image) résultantes dans la sortie.

Le premier argument est facultatif et peut être utilisé pour spécifier la légende affichée sous l'image. Cet argument doit être spécifié entre les citations même s'il ne contient aucun espace. Les citations sont dépouillées avant que la légende ne soit affichée.

Le deuxième argument est également facultatif et peut être utilisé pour spécifier la largeur ou la hauteur de l'image. Pour une description des possibilités, consultez [**l'indication de la taille**](#image_sizeindicator) du paragraphe avec la commande [**\image**](#image).

Les nœuds d'un graphique peuvent être rendus cliquables à l'aide de l'attribut URL. En utilisant la commande [**\ref**](#ref) dans la valeur URL, vous pouvez facilement lier un élément à l'intérieur de Doxygen. Voici un exemple :

<div class="notice info">
    <p><strong>Note</strong><br>
    L'utilisation de cette commande exige que <a href="./configuration.md#have_dot"><strong>HAVE_DOT</strong></a> soit défini sur YES.<br>
    Doxygen crée un fichier temporaire qui est automatiquement supprimé, sauf si la balise <a href="./configuration.md#dot_cleanup"><strong>DOT_CLEANUP</strong></a> est définie sur NO.</p>
</div>


```cpp
/ *! classe b * /
class B {};

/ *! classe C * /
class C {};

/ *! \mainpage 
  * 
  * Relations de classe exprimées via un graphique à points en ligne : 
  * \dot 
  * exemple de digraph { 
  *     nœud [ shape = record, fontname = Helvetica, fontsize = 10 ]; 
  *     b [ label = "class B" URL = "\ref B" ]; 
  *     c [ label = "clase C" URL = "\ref C" ]; 
  *     b -> c [ arrowhead = "open", style = "dashed" ]; 
  *} 
  * \enddot 
  * Notez que les classes du graphique ci-dessus sont cliquables 
  * (dans la sortie HTML). 
  * /

\emoji "name"

Cette commande produira un emoji en fonction de son nom.

Les noms supportés sont ceux également supportés par GitHub et listés ici https://gist.github.com/rxaviers/7360908.

Vous pouvez utiliser le nom avec ou sans les deux points, par exemple \emoji smile est la même chose que d'écrire \emoji :smile :. Lorsqu'un emoji n'est pas supporté, le nom se place dans le texte entre les deux points, par exemple \emoji unsupported produira :unsupported: dans la sortie. Doxygen affichera également un message d'avertissement.

Voir également la page d'assistance Emoji pour plus de détails.

\msc ["caption"] [<sizeindication>=<size>]

Démarre un fragment de texte qui devrait contenir une description valide d'un tableau de séquence de messages. Voir https://www.mcternan.me.uk/mscgen/ pour des exemples. Le fragment de texte se termine par endmsc.

Le premier argument est facultatif et peut être utilisé pour spécifier la légende affichée sous l'image. Cet argument doit être spécifié entre les citations même s'il ne contient aucun espace. Les citations sont dépouillées avant que la légende ne soit affichée.

Le deuxième argument est également facultatif et peut être utilisé pour spécifier la largeur ou la hauteur de l'image. Pour une description des possibilités, consultez l'indication de la taille du paragraphe avec la commande \image.

Note
Le fragment de texte ne doit inclure que la partie du tableau de séquence de messages qui se trouve dans le bloc MSC {...} (ceci est différent de \mscfile).
mscgen est maintenant intégré à Doxygen.
Doxygen crée un fichier temporaire qui est automatiquement supprimé, sauf si la balise DOT_CLEANUP est définie sur NO.

Voici un exemple de l'utilisation de la commande \msc.

/ ** Classe de l'expéditeur. Peut être utilisé pour envoyer une commande au serveur. 
  * Le récepteur reconnaîtra la commande en appelant Ack (). 
  * \msc
  *     Expediteur, Receveur ; 
  *     Expediteur-> Receveur [label = "Command ()", URL = "\ref Receveur :: Command ()"]; 
  *     Expediteur <-Receveur [label = "Ack ()", URL = "\ref Ack ()", ID = "1"]; 
  * \endmsc 
  * /
class Expediteur
{ 
    public:
    / ** Reconnaissance du serveur * / 
    void Ack (bool ok);
};

/ ** Classe de receveur. Peut être utilisé pour recevoir et exécuter des commandes. 
* Après l'exécution d'une commande, le receveur enverra un accusé de réception 
* \msc 
* Receveur, Expediteur; 
* Receveur <-Expediteur [label = "Command ()", URL = "\ref Command ()"]; 
* Receveur-> Expediteur [label = "ack ()", url = "\ref Expediteur :: Ack ()", ID = "1"]; 
* \endmsc 
* /
class Receveur
{ 
    public:
/ ** Exécute une commande sur le serveur * / 
         void Command(int commandId);
};

Voir aussi

section \mscfile.

\startuml ['{' option [, option] '}'] ["caption"] [<sizeindication> = <s>]

Démarre un fragment de texte qui devrait contenir une description valide d'un diagramme PlantUML. Voir https://plantuml.com/ pour des exemples. Le fragment de texte se termine par \enduml*.

Note
Vous devez installer Java et le fichier jar de PlantUML, si vous souhaitez utiliser cette commande. Lorsque vous utilisez PlantUML dans latex vous devez télécharger d'autres fichiers jar, pour plus de détails, consultez la documentation PlantUML. Cela est également valable pour les <engine> latex et math . L'emplacement du fichier PlantUML doit être spécifié à l'aide de PALNTUML_JAR_PATH. Les autres fichiers jar doivent également résider dans ce répertoire. L'utilisation de la <engine> ditaa n'est plus possible dans layex car PlantUML ne supporte que le format png et Doxygen requiert, temporairement, une sortie eps.

Tous les diagrammes ne peuvent pas être créés avec la commande PlantUML @startuml mais nécessitent une autre commande PlantUML @start.... Celle-ci ressemblera à @start<engine> où les <engine> suivants sont actuellement supportés : uml, bpm, wire, dot, ditaa, salt, math, latex,gantt, mindmap, wbs, yaml, creole, json, flow, board, git, hcl, regex, ebnf, files, chen et chronology. Par défaut, le <moteur> est uml. Le <moteur> peut être spécifié en tant qu'option. Le fichier dans lequel écrire l'image résultante peut également être spécifié au moyen d'une option, voir la description du premier argument (facultatif) pour plus de détails.

Le premier argument est optionnel et existe pour la compatibilité avec l'exécution de PlantUML comme une étape de prétraitement avant d'exécuter Doxygen, vous pouvez également ajouter le nom du fichier image après \startuml et à l'intérieur des crochets en tant qu'option, c'est à dire :

@startuml {MyImage.png} "Légende d'image" Largeur = 5cm 
Alice -> Bob: Bonjour 
@enduml

Lorsque le nom de l'image est spécifié, Doxygen générera une image avec ce nom. Sans le nom, Doxygen choisira automatiquement un nom.

Le deuxième argument est facultatif et peut être utilisé pour spécifier la légende affichée sous l'image. Cet argument doit être spécifié entre les citations même s'il ne contient aucun espace. Les citations sont dépouillées avant que la légende ne soit affichée.

Le troisième argument est également facultatif et peut être utilisé pour spécifier la largeur ou la hauteur de l'image. Pour une description des possibilités, consultez l'indication de la taille du paragraphe avec la commande \image.

Note
Doxygen ne supporte pas directement les commandes PlantUML comme @startjson, par conception, mais le support peut être réalisé, par l'utilisateur, en ajoutant au fichier de configuration de Doxygen ce qui suit :

    ALIASES += startjson=@startuml{json}
    ALIASES += endjson=@enduml

Note
Doxygen crée un fichier temporaire qui est automatiquement supprimé à moins que la balise DOT_CLEANUP ne soit définie sur NO.

Voici un exemple de l'utilisation de la commande \startuml.

/ ** Classe Expediteur. Peut être utilisé pour envoyer une commande au serveur. 
  * Le receveur reconnaîtra la commande en appelant Ack (). 
  * \startuml 
  * Expediteur-> Receveur   : Command () 
  * Expéditeur <- Receveur  : Ack () 
  * \enduml
  * /
class Expediteur
{ 
    public:
/ ** Reconnaissance du serveur * / 
        void Ack (bool ok);
};

/ ** Classe Receveur. Peut être utilisé pour recevoir et exécuter des commandes. 
  * Après l'exécution d'une commande, le receveur enverra un accusé de réception 
  * \startuml 
  * Receveur <-Expediteur   : Command () 
  * Receveur -> Expediteur  : Ack () 
  * \enduml
  * /
class Receveur
{ 
    public:
/ ** Exécute une commande sur le serveur * / 
    void Command(int commandId);
};

\dotfile <file> ["caption"] [<sizeindication>=<size>]

Insère une image générée par dot à partir de <file> dans la documentation.

Le premier argument spécifie le nom de fichier de l'image. Doxygen recherchera des fichiers dans les chemins (ou fichiers) que vous avez spécifiés après la balise DOTFILE_DIRS. Si le fichier dot est trouvé, il sera utilisé comme fichier d'entrée dans l'outil dot. L'image résultante sera placée dans le répertoire de sortie correct. Si le nom du fichier dot contient des espaces, vous devrez mettre des guillemets ("...") autour de lui.

Le deuxième argument est facultatif et peut être utilisé pour spécifier la légende affichée sous l'image. Cet argument doit être spécifié entre les citations même s'il ne contient aucun espace. Les guillemets sont retirés avant que la légende ne soit affichée.

Le troisième argument est également facultatif et peut être utilisé pour spécifier la largeur ou la hauteur de l'image. Pour une description des possibilités, consultez l'indication de la taille du paragraphe avec la commande \image.

Note
L'utilisation de cette commande exige que HAVE_DOT soit défini sur YES

Voir aussi

section \dot.

\mscfile <file> ["caption"] [<sizeindication>=<size>]

Insère une image générée par mscgen à partir de <file&gt dans la documentation. Voir https://www.mcternan.me.uk/mscgen/ pour des exemples.

Le premier argument spécifie le nom de fichier de l'image. Doxygen recherchera des fichiers dans les chemins (ou fichiers) que vous avez spécifiés après la balise MSCFILE_DIRS. Si le fichier msc est trouvé, il sera utilisé comme fichier d'entrée dans l'outil mscgen intégré. L'image résultante sera placée dans le répertoire de sortie correct. Si le nom de fichier msc contient des espaces, vous devrez mettre des guillemets ("...") autour de lui.

Le deuxième argument est facultatif et peut être utilisé pour spécifier la légende affichée sous l'image. Cet argument doit être spécifié entre les guillemets même s'il ne contient aucun espace. Les guillemets sont retirés avant que la légende ne soit affichée.

Le troisième argument est également facultatif et peut être utilisé pour spécifier la largeur ou la hauteur de l'image. Pour une description des possibilités, consultez l'indication de la taille du paragraphe avec la commande \image.

Note
Le fragment de texte doit inclure le message de pièce du graphique de séquence ainsi que le msc { (de départ) et celui de fin } (c'est différent de )\msc.

Voir aussi

section \msc.

\diafile <file> ["caption"] [<sizeindication>=<size>]

Insère une image faite en dia à partir de <file> dans la documentation.

Le premier argument spécifie le nom de fichier de l'image. Doxygen recherchera des fichiers dans les chemins (ou fichiers) que vous avez spécifiés après la balise DIAFILE_DIRS. Si le fichier dia est trouvé, il sera utilisé comme fichier d'entrée dia. L'image résultante sera placée dans le répertoire de sortie correct. Si le nom du fichier dia contient des espaces, vous devrez mettre des guillemets ("...") autour de lui.

Le deuxième argument est facultatif et peut être utilisé pour spécifier la légende affichée sous l'image. Cet argument doit être spécifié entre les guillemets même s'il ne contient aucun espace. Les guimmelets sont retirés avant que la légende ne soit affichée.

Le troisième argument est également facultatif et peut être utilisé pour spécifier la largeur ou la hauteur de l'image. Pour une description des possibilités, consultez l'indication de la taille du paragraphe avec la commande \image.

\doxyconfig <config_option>

Affiche la valeur de l'option de configuration <config_option> telle qu'elle est utilisée dans le fichier de configuration de Doxygen qui est utilisé lorsque cette commande est traitée.

Exemple :

Lors de la création de ce manuel, ce qui suit : 

... Project name = \doxyconfig PROJECT_NAME ...

donnera :

... Project name = Doxygen ...

\e <word>

Affiche l'argument <word> en italique. Utilisez cette commande pour souligner les mots.

Exemple :

Dactylographie : 

... c'est un \e très bon exemple ...

entraînera le texte suivant :

... c'est un très bon exemple ...

Équivalent à \a et \em. Pour souligner plusieurs mots, utilisez <em> plusieurs mots </em>.

\em <word>

Affiche l'argument <word> en italique. Utilisez cette commande pour souligner les mots.

Exemple :

Dactylographie : 

... c'est un \em très bon exemple ...

entraînera le texte suivant:

... c'est un très bon exemple ...

Équivalent à \a et \e.. Pour souligner plusieurs mots, utilisez <em> plusieurs mots </em>.

\endcode

Termine un bloc de code.

Voir aussi

sectioncode.

\enddocbookonly

Met fin à un bloc de texte qui a été démarré par une commande \docbookonly.

Voir aussi

section \docbookonly.

\enddot

Termine un bloc qui a été démarré avec \dot.

\endmsc

Termine un bloc qui a été démarré avec \msc.

\enduml

Termine un bloc qui a été démarré avec \startuml.

\plantumlfile <file> ["caption"] [<sizeindication>=<size>]

Insère une image faite dans PlantUML à partir de <file> dans la documentation.

Le premier argument spécifie le nom de fichier de l'image. Doxygen recherchera des fichiers dans les chemins (ou fichiers) que vous avez spécifiés après la balise PLANTUMLFILE_DIRS. Si le fichier PlantUML est trouvé, il sera utilisé comme fichier d'entrée pour le programme PlantUML. L'image résultante sera placée dans le répertoire de sortie correct. Si le nom de fichier PlantUML contient des espaces, vous devrez mettre des guillemets ("...") autour de lui.

Le deuxième argument est facultatif et peut être utilisé pour spécifier la légende affichée sous l'image. Cet argument doit être spécifié entre les guillemets même s'il ne contient aucun espace. Les guillemets sont retirés avant que la légende ne soit affichée.

Le troisième argument est également facultatif et peut être utilisé pour spécifier la largeur ou la hauteur de l'image. Pour une description des possibilités, consultez l'indication de la taille du paragraphe avec la commande \image.

\endhtmlonly

Met fin à un bloc de texte qui a été démarré par une commande \htmlonly.

Voir aussi

section \htmlonly.

\endlatexonly

Termine un bloc de texte qui a été démarré par une commande \latexonly.

Voir aussi

section \latexonly.

\endmanonly

Met fin à un bloc de texte qui a été démarré par une commande \manonly.

Voir aussi

section \manonly.

\endrtfonly

Met fin à un bloc de texte qui a été démarré par une commande \rtfonly.

Voir aussi

section \rtfonly.

\endverbatim

Met fin à un bloc de texte qui a été démarré par une commande \verbatim.

Voir aussi

section \verbatim.

\endxmlonly

Termine un bloc de texte qui a été démarré par une commande

Voir aussi

section \xmlonly.

\f$

Marque le début et la fin d'une formule dans le texte.

Voir aussi

section [\formulas] pour un exemple.

\f(

Marque le début d'une formule dans le texte, mais contrairement à \f$, il n'ouvrira pas explicitement le mode mathématique dans latex.

Voir aussi

sections \f) et \formulas.

\f)

Marque la fin d'une formule dans le texte démarré avec \f(.

Voir aussi

sections \f( et \formulas.

\f[

Marque le début d'une longue formule affichée centrée sur une ligne séparée.

Voir aussi

sections \f] et \formulas.

\f]

Marque l'extrémité d'une longue formule affichée centrée sur une ligne séparée.

Voir aussi

sections \f[ et \formulas.

\f{environment}{

Marque le début d'une formule qui se trouve dans un environnement spécifique.

Note
Le second { est facultatif et est uniquement là pour aider les éditeurs (tels que Vim) à effectuer une mise en évidence syntaxique correcte en faisant en sorte que le nombre d'accolades ouvrantes et fermantes soit le même.

Voir aussi

sections \f} et \formulas.

\f}

Marque la fin d'une formule qui se trouve dans un environnement spécifique.

Voir aussi

sections \f{ et \formulas.

\htmlonly ['[bloc]']

Démarre un bloc de texte qui sera uniquement inclus dans la documentation HTML générée et tagué avec <htmlonly> dans la sortie XML générée. Le bloc se termine par une commande \endhtmlonly.

Cette commande peut être utilisée pour inclure le code HTML trop complexe pour Doxygen (c'est-à-dire les applets, les scripts java et les balises HTML qui nécessitent des attributs spécifiques).

Normalement, le contenu entre \htmlonly et \endhtmlonly est inséré tel quel. Lorsque vous souhaitez insérer un fragment HTML qui a une portée de bloc comme un tableau ou une liste qui devrait apparaître en dehors de <p> ... </p>, cela peut conduire à un code HTML invalide. Vous pouvez utiliser \htmlonly[block] pour faire en sorte que Doxygen termine le paragraphe en cours et le redémarre après \endhtmlonly.

Note
Les variables d'environnement (comme $(home)) sont résolues dans un bloc HTML uniquement.

Voir aussi

sections \manonly, \latexonly, \rtfonly, \xmlonly, \docbookonly et \htmlinclude.

\image['{'option[,option]'}'] <format> <file> ["caption"] [<sizeindication>=<size>]

Insère une image dans la documentation. Cette commande est spécifique au format, donc si vous souhaitez insérer une image pour plus d'un format, vous devrez répéter cette commande pour chaque format.

Le premier argument spécifie le format de sortie dans lequel l'image doit être intégrée. Actuellement, les valeurs suivantes sont prises en charge : html, latex, docbook, rtf et xml.

Le deuxième argument spécifie le nom de fichier de l'image. Doxygen recherchera des fichiers dans les chemins (ou fichiers) que vous avez spécifiés après la balise IMAGE_PATH. Si l'image est trouvée, elle sera copiée dans le répertoire de sortie correct. Si le nom de l'image contient des espaces, vous devrez mettre des guillemets ("...") autour du nom. Vous pouvez également spécifier une URL absolue au lieu d'un nom de fichier, mais Doxygen ne copie pas l'image ni ne vérifie son existence.

Le troisième argument est facultatif et peut être utilisé pour spécifier la légende affichée sous l'image. Cet argument doit être spécifié sur une seule ligne et entre les guillemets même s'il ne contient aucun espace. Les guillemets sont retirés avant que la légende ne soit affichée.

Le quatrième argument est également facultatif et peut être utilisé pour spécifier la largeur ou la hauteur de l'image. Cela peut être utile pour latex ou la sortie DocBook (c'est-à-dire format = latex ou format = docbook).

Indication de taille :

Le sizeindication peut spécifier la largeur ou la hauteur à utiliser (ou une combinaison). Le spécificateur de taille en latex (par exemple 10cm ou 4in ou une largeur symbolique comme \textwidth).

Actuellement, seules les options inline et anchor sont prises en charge. Si l'option inline est spécifiée, l'image est placée « dans la ligne » ; si une légende est présente, elle est affichée en HTML sous forme d'infobulle (ignorée pour les autres formats). Pour l'option anchor, la syntaxe est la suivante : anchor:<anchorId>.

Voici l'exemple d'un bloc de commentaires : 

/ *! Voici un instantané de ma nouvelle application: 
  * \image html application.jpg 
  * \image latex application.eps "Mon Application" width=10cm 
  * /

Et ceci est un exemple de la façon dont la partie pertinente du fichier de configuration peut être consultée : 

IMAGE_PATH     = my_image_dir

Avertissement
Le format d'image pour HTML est limité à ce que votre navigateur prend en charge. Pour latex,le format d'image doit être pris en charge par la commande latex \includegraphics, c'est-à-dire PostScript Encapsulé (eps), Portable network graphics (png), Joint photographic experts group (jpg / jpeg).

Doxygen ne vérifie pas si l'image est dans le format correct. Vous devez donc vous assurer que c'est le cas !

\latexonly

Commence un bloc de texte qui sera uniquement inclus mot pour mot dans la documentation LaTex générée et étiqueté avec dans la sortie XML générée. Le bloc se termine par une commande \endlatexonly.

Cette commande peut être utilisée pour inclure le code LaTex trop complexe pour Doxygen (c'est-à-dire les images, les formules, les caractères spéciaux). Vous pouvez utiliser la paire \htmlonly et \endhtmlonly pour fournir une alternative HTML appropriée.

Remarque : les variables d'environnement (comme $(home)) sont résolues à l'intérieur d'un bloc LaTex seul.

Voir aussi

sections \rtfonly, \xmlonly, \manonly, \htmlonly, \docbookonly et \latexinclude.

\manonly

Commence un bloc de texte qui sera uniquement inclus mot pour mot dans la documentation MAN générée et étiqueté avec <manonly> dans la sortie XML générée. Le bloc se termine par une commande \endmanonly.

Cette commande peut être utilisée pour inclure du code groff directement dans les pages MAN. Vous pouvez utiliser les paires \htmlonly, \endhtmlonly et \latexonly, \endlatexonly pour fournir des alternatives HTML et LaTex appropriées.

Voir aussi

sections \htmlonly, \xmlonly, \rtfonly, \latexonly, \docbookonly et \maininclude.

\li { item-description }

Cette commande a un argument qui se poursuit jusqu'à la première ligne vide ou jusqu'à ce qu'un autre \li soit rencontré. La commande peut être utilisée pour générer une liste d'arguments simples et non imbriqués. Chaque argument doit commencer par une commande \li.

Exemple :

Dactylographie : 

  \li \c AlignLeft alignement gauche.
  \li \c AlignCenter alignement centré.
  \li \c AlignRight alignement droit.

  Aucun autre type n'est supporté.

entraînera le texte suivant :

  • AlignLeft alignement gauche.
  • AlignCenter alignement centré.
  • AlignRight alignement droit.

Aucun autre type n'est supporté.

Note :

Pour les listes imbriquées, les commandes HTML doivent être utilisées.

Équivalent à \arg.

\n

Force une nouvelle ligne. Équivalent à <br> et inspiré par la fonction printf.

\p <word>

Affiche le paramètre <word> à l'aide d'une police de machine à écrire. Vous pouvez utiliser cette commande pour vous référer aux paramètres de fonction des membres dans le texte en cours d'exécution.

Exemple : 

... les coordonnées \p x et \p y sont utilisées pour ...

Cela se traduira par le texte suivant :

... Les coordonnées X et Y sont utilisées pour ...

Équivalent à \c. Pour avoir plusieurs mots dans la police de machine à écrire, utilisez <tt> plusieurs mots </tt> .

\rtfonly

Démarre un bloc de texte qui sera uniquement inclus dans la documentation RTF générée et tagué avec <rtfonly> dans la sortie XML générée. Le bloc se termine par une commande \endrtfonly.

Cette commande peut être utilisée pour inclure le code RTF trop complexe pour Doxygen.

Remarque : les variables d'environnement (comme $(home)) sont résolues dans un bloc RTF uniquement.

Voir aussi

sections \manonly, \xmlonly, \latexonly, \htmlonly, \docbookonly et \rtfinclude.

\verbatim

Démarre un bloc de texte qui sera inclus mot pour mot dans la documentation. Le bloc doit se terminer par une commande \endverbatim. Toutes les commandes sont désactivées dans un bloc verbatim.

Avertissement
Assurez-vous d'inclure une commande \endverbatim pour chaque commande \verbatim ou l'analyseur sera confus !

Voir aussi

sections \code, \endverbatim et \verbinclude.

\xmlonly

Démarre un bloc de texte qui sera uniquement inclus textuellement dans la sortie XML générée. Le bloc se termine par une commande \endxmlonly.

Cette commande peut être utilisée pour inclure des balises XML personnalisées.

Voir aussi

sections \manonly, \rtfonly, \latexonly, \htmlonly et \docbookonly.

\

Cette commande écrit le caractère backslash (\) à la sortie. La barre oblique inverse doit être échappée dans certains cas parce que Doxygen l'utilise pour détecter les commandes.

\@

Cette commande écrit le signe arobase (@) à la sortie. L'arobase doit être échappé dans certains cas parce que Doxygen l'utilise pour détecter les commandes Javadoc.

\~[LanguageId]

Cette commande permet d'activer/désactiver un filtre spécifique à la langue. Elle peut être utilisée pour mettre de la documentation pour différentes langues dans un bloc de commentaires et utiliser la balise OUTPUT_LANGUAGE pour filtrer uniquement une langue spécifique. Utilisez \~language_id pour activer la sortie dans une langue spécifique uniquement et \~ pour activer la sortie pour toutes les langues (c'est également le mode par défaut).

Exemple :

/* ! \~english This is English \~dutch Dit is Nederlands \~german Dies ist
 Deutsch. \~ sortie pour toutes les langues.
 */

\&

Cette commande écrit le caractère (&) sur la sortie. Ce caractère doit être échappé car il a une signification particulière en HTML.

\$

Cette commande écrit le caractère ($) en sortie. Ce caractère doit être échappé dans certains cas, car il est utilisé pour développer les variables d'environnement.

#

Cette commande écrit le caractère (#) en sortie. Ce caractère doit être échappé dans certains cas, car il est utilisé pour faire référence à des entités documentées.

\<

Cette commande écrit le caractère (<) en sortie. Ce caractère doit être échappé car il a une signification particulière en HTML.

\>

Cette commande écrit le caractère (>) en sortie. Ce caractère doit être échappé car il a une signification particulière en HTML.

\%

Cette commande écrit le caractère % en sortie. Ce caractère doit être échappé dans certains cas, car il est utilisé pour empêcher l'établissement de liens automatiques vers un mot qui est également une classe ou une structure documentée.

\"

Cette commande écrit le caractère " à la sortie. Ce caractère doit être échappé dans certains cas, car il est utilisé pour empêcher les liens automatiques vers un mot qui est également une classe ou une structure documentée.

.

Cette commande écrit un point (.) sur la sortie. Cela peut être utile pour empêcher la fin d'une brève description lorsque JAVADOC_AUTOBRIEF ou QT_AUTOBRIEF est activé ou pour empêcher le démarrage d'une liste numérotée lorsque le point suit un numéro au début d'une ligne.

\?

Cette commande écrit un point d'interrogation (?) sur la sortie. Cela peut être utile pour empêcher la fin d'une brève description lorsque JAVADOC_AUTOBRIEF ou QT_AUTOBRIEF est activé.

!

Cette commande écrit un point d'exclamation ( !) sur la sortie. Cela peut être utile pour éviter de terminer une brève description lorsque JAVADOC_AUTOBRIEF ou QT_AUTOBRIEF est activé.

\=

Cette commande écrit un signe égal (=) sur la sortie. Cette séquence de caractères doit être échappée dans certains cas, car elle est utilisée dans le traitement de l'en-tête Markdown.

\::

Cette commande écrit un double deux-points (: :) en sortie. Cette séquence de caractères doit être échappée dans certains cas, car elle est utilisée pour faire référence à des entités documentées.

|

Cette commande écrit un symbole de pipe (|) sur la sortie. Ce caractère doit être échappé dans certains cas, car il est utilisé pour les tableaux Markdown.

--

Cette commande écrit deux tirets (--) en sortie. Cela permet d'écrire deux tirets consécutifs en sortie au lieu d'un seul tiret (-).

---

Cette commande écrit trois tirets (---) sur la sortie. Cela permet d'écrire trois tirets consécutifs sur la sortie au lieu d'un seul tiret (-).