Sur cette page

QCompleter Class

La classe QCompleter fournit des compléments basés sur un modèle d'élément. Plus d'informations...

En-tête : #include <QCompleter>
CMake : find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(mytarget PRIVATE Qt6::Widgets)
qmake : QT += widgets
Héritages : QObject

Types publics

enum CompletionMode { PopupCompletion, InlineCompletion, UnfilteredPopupCompletion }
enum ModelSorting { UnsortedModel, CaseSensitivelySortedModel, CaseInsensitivelySortedModel }

Propriétés

Fonctions publiques

QCompleter(QObject *parent = nullptr)
QCompleter(QAbstractItemModel *model, QObject *parent = nullptr)
QCompleter(const QStringList &list, QObject *parent = nullptr)
virtual ~QCompleter() override
Qt::CaseSensitivity caseSensitivity() const
int completionColumn() const
int completionCount() const
QCompleter::CompletionMode completionMode() const
QAbstractItemModel *completionModel() const
QString completionPrefix() const
int completionRole() const
QString currentCompletion() const
QModelIndex currentIndex() const
int currentRow() const
Qt::MatchFlags filterMode() const
int maxVisibleItems() const
QAbstractItemModel *model() const
QCompleter::ModelSorting modelSorting() const
virtual QString pathFromIndex(const QModelIndex &index) const
QAbstractItemView *popup() const
void setCaseSensitivity(Qt::CaseSensitivity caseSensitivity)
void setCompletionColumn(int column)
void setCompletionMode(QCompleter::CompletionMode mode)
void setCompletionRole(int role)
bool setCurrentRow(int row)
void setFilterMode(Qt::MatchFlags filterMode)
void setMaxVisibleItems(int maxItems)
void setModel(QAbstractItemModel *model)
void setModelSorting(QCompleter::ModelSorting sorting)
void setPopup(QAbstractItemView *popup)
void setWidget(QWidget *widget)
virtual QStringList splitPath(const QString &path) const
QWidget *widget() const
bool wrapAround() const

Emplacements publics

void complete(const QRect &rect = QRect())
void setCompletionPrefix(const QString &prefix)
void setWrapAround(bool wrap)

Signaux

void activated(const QModelIndex &index)
void activated(const QString &text)
void highlighted(const QModelIndex &index)
void highlighted(const QString &text)

Fonctions protégées réimplémentées

virtual bool event(QEvent *ev) override
virtual bool eventFilter(QObject *o, QEvent *e) override

Description détaillée

Vous pouvez utiliser QCompleter pour fournir des complétions automatiques dans n'importe quel widget Qt, tel que QLineEdit et QComboBox. Lorsque l'utilisateur commence à taper un mot, QCompleter suggère des façons possibles de compléter le mot, en se basant sur une liste de mots. La liste de mots est fournie sous forme de QAbstractItemModel(pour les applications simples, où la liste de mots est statique, vous pouvez passer un QStringList au constructeur de QCompleter).

Utilisation de base

Un QCompleter est utilisé typiquement avec un QLineEdit ou un QComboBox. Par exemple, voici comment fournir des complétions automatiques à partir d'une simple liste de mots dans un QLineEdit:

QStringList wordList;
wordList << "alpha" << "omega" << "omicron" << "zeta";

QLineEdit *lineEdit = new QLineEdit(this);

QCompleter *completer = new QCompleter(wordList, this);
completer->setCaseSensitivity(Qt::CaseInsensitive);
lineEdit->setCompleter(completer);

Un QFileSystemModel peut être utilisé pour fournir une auto-complétion des noms de fichiers. Par exemple, un peut être utilisé pour compléter automatiquement des noms de fichiers :

QCompleter *completer = new QCompleter(this);
completer->setModel(new QFileSystemModel(completer));
lineEdit->setCompleter(completer);

Pour définir le modèle sur lequel QCompleter doit opérer, appelez setModel(). Par défaut, QCompleter essaiera de faire correspondre le completion prefix (c'est-à-dire le mot que l'utilisateur a commencé à taper) avec les données du Qt::EditRole stockées dans la colonne 0 du modèle en tenant compte de la casse. Ceci peut être modifié en utilisant setCompletionRole(), setCompletionColumn(), et setCaseSensitivity().

Si le modèle est trié en fonction de la colonne et du rôle utilisés pour le remplissage, vous pouvez appeler setModelSorting() avec QCompleter::CaseSensitivelySortedModel ou QCompleter::CaseInsensitivelySortedModel comme argument. Sur les grands modèles, cela peut conduire à des améliorations significatives des performances, parce que QCompleter peut alors utiliser la recherche binaire au lieu de la recherche linéaire. La recherche binaire ne fonctionne que lorsque filterMode est Qt::MatchStartsWith.

Le modèle peut être un list model, un table model ou un tree model. La complétion sur les modèles arborescents est légèrement plus complexe et est abordée dans la section Handling Tree Models ci-dessous.

L'option completionMode() détermine le mode utilisé pour fournir des complétions à l'utilisateur.

Itération à travers les complétions

Pour récupérer une seule chaîne candidate, appelez setCompletionPrefix() avec le texte à compléter et appelez currentCompletion(). Vous pouvez parcourir la liste des compléments comme suit :

for(int i = 0;  completer->setCurrentRow(i) ;  i++)    qDebug() << completer->currentCompletion() << " is match number " << i;

completionCount() renvoie le nombre total d'achèvements pour le préfixe actuel. completionCount() doit être évité dans la mesure du possible, car il nécessite un balayage de l'ensemble du modèle.

Le modèle de complétion

completionModel() renvoie un modèle de liste qui contient toutes les complétions possibles pour le préfixe de complétion actuel, dans l'ordre dans lequel elles apparaissent dans le modèle. Ce modèle peut être utilisé pour afficher les complétions actuelles dans une vue personnalisée. L'appel à setCompletionPrefix() rafraîchit automatiquement le modèle de complétion.

Gestion des modèles d'arbre

QCompleter peut rechercher des complétions dans des modèles arborescents, en supposant que tout élément (ou sous-élément ou sous-sous-élément) peut être représenté sans ambiguïté comme une chaîne de caractères en spécifiant le chemin vers l'élément. La complétion est alors effectuée un niveau à la fois.

Prenons l'exemple d'un utilisateur qui saisit le chemin d'accès à un système de fichiers. Le modèle est un QFileSystemModel(hiérarchique). La complétion s'effectue pour chaque élément du chemin d'accès. Par exemple, si le texte courant est C:\Wind, QCompleter peut suggérer Windows pour compléter l'élément courant du chemin. De même, si le texte actuel est C:\Windows\Sy, QCompleter pourrait suggérer System.

Pour que ce type de complétion fonctionne, QCompleter doit être capable de diviser le chemin d'accès en une liste de chaînes de caractères correspondant à chaque niveau. Pour C:\Windows\Sy, il doit être divisé en "C :", "Windows" et "Sy". L'implémentation par défaut de splitPath(), divise le completionPrefix en utilisant QDir::separator() si le modèle est un QFileSystemModel.

Pour fournir des complétions, QCompleter a besoin de connaître le chemin à partir d'un index. Ceci est fourni par pathFromIndex(). L'implémentation par défaut de pathFromIndex(), renvoie les données de edit role pour les modèles de liste et le chemin absolu du fichier si le mode est un QFileSystemModel.

Voir également QAbstractItemModel, QLineEdit, QComboBox, et Exemple de compléteur.

Documentation sur les types de membres

enum QCompleter::CompletionMode

Cette énumération spécifie comment les compléments sont fournis à l'utilisateur.

ConstanteValeurDescription
QCompleter::PopupCompletion0Les compléments actuels sont affichés dans une fenêtre contextuelle.
QCompleter::InlineCompletion2Les compléments apparaissent en ligne (sous forme de texte sélectionné).
QCompleter::UnfilteredPopupCompletion1Toutes les complétions possibles sont affichées dans une fenêtre contextuelle, la suggestion la plus probable étant indiquée comme actuelle.

Voir également setCompletionMode().

enum QCompleter::ModelSorting

Cette énumération spécifie la manière dont les éléments du modèle sont triés.

ConstanteValeurDescription du modèle
QCompleter::UnsortedModel0Le modèle n'est pas trié.
QCompleter::CaseSensitivelySortedModel1Le modèle est trié en tenant compte de la casse.
QCompleter::CaseInsensitivelySortedModel2Le modèle est trié sans tenir compte de la casse.

Voir également setModelSorting().

Documentation sur les propriétés

caseSensitivity : Qt::CaseSensitivity

Cette propriété définit la sensibilité à la casse de la correspondance

La valeur par défaut est Qt::CaseSensitive.

Fonctions d'accès :

Qt::CaseSensitivity caseSensitivity() const
void setCaseSensitivity(Qt::CaseSensitivity caseSensitivity)

Voir aussi completionColumn, completionRole, modelSorting, et filterMode.

completionColumn : int

Cette propriété contient la colonne du modèle dans laquelle les compléments sont recherchés.

Si le popup() est un QListView, il est automatiquement configuré pour afficher cette colonne.

Par défaut, la colonne de correspondance est 0.

Fonctions d'accès :

int completionColumn() const
void setCompletionColumn(int column)

Voir également completionRole et caseSensitivity.

completionMode : CompletionMode

la manière dont les compléments sont fournis à l'utilisateur

La valeur par défaut est QCompleter::PopupCompletion.

Fonctions d'accès :

QCompleter::CompletionMode completionMode() const
void setCompletionMode(QCompleter::CompletionMode mode)

completionPrefix : QString

Cette propriété contient le préfixe d'achèvement utilisé pour fournir des achèvements.

L'adresse completionModel() est mise à jour pour refléter la liste des correspondances possibles pour prefix.

Fonctions d'accès :

QString completionPrefix() const
void setCompletionPrefix(const QString &prefix)

completionRole : int

Cette propriété contient le rôle de l'élément à utiliser pour interroger le contenu des éléments en vue d'une correspondance.

Le rôle par défaut est Qt::EditRole.

Fonctions d'accès :

int completionRole() const
void setCompletionRole(int role)

Voir également completionColumn et caseSensitivity.

filterMode : Qt::MatchFlags

Cette propriété contrôle la manière dont le filtrage est effectué.

Si filterMode a pour valeur Qt::MatchStartsWith, seules les entrées commençant par les caractères saisis seront affichées. Qt::MatchContains affichera les entrées contenant les caractères saisis, et Qt::MatchEndsWith celles se terminant par les caractères saisis.

Si la valeur de filterMode est différente de Qt::MatchFlag, un avertissement sera émis et aucune action ne sera effectuée. Pour cette raison, l'indicateur Qt::MatchCaseSensitive n'a aucun effet. Utilisez la propriété caseSensitivity pour contrôler la sensibilité à la casse.

Le mode par défaut est Qt::MatchStartsWith.

Fonctions d'accès :

Qt::MatchFlags filterMode() const
void setFilterMode(Qt::MatchFlags filterMode)

Voir également caseSensitivity.

maxVisibleItems : int

Cette propriété indique la taille maximale autorisée à l'écran du compléteur, mesurée en nombre d'éléments

Par défaut, cette propriété a une valeur de 7.

Fonctions d'accès :

int maxVisibleItems() const
void setMaxVisibleItems(int maxItems)

modelSorting : ModelSorting

Cette propriété définit la manière dont le modèle est trié

Par défaut, aucune hypothèse n'est faite quant à l'ordre des éléments dans le modèle qui fournit les compléments.

Si les données du modèle pour completionColumn() et completionRole() sont triées par ordre croissant, vous pouvez définir cette propriété sur CaseSensitivelySortedModel ou CaseInsensitivelySortedModel. Sur les grands modèles, cela peut entraîner des améliorations significatives des performances, car l'objet compléteur peut alors utiliser un algorithme de recherche binaire au lieu d'un algorithme de recherche linéaire.

L'ordre de tri (c'est-à-dire l'ordre croissant ou décroissant) du modèle est déterminé dynamiquement en inspectant le contenu du modèle.

Remarque : les améliorations de performance décrites ci-dessus ne sont pas possibles lorsque la sensibilité à la casse de l'objet caseSensitivity est différente de celle utilisée par le modèle lors du tri.

Fonctions d'accès :

QCompleter::ModelSorting modelSorting() const
void setModelSorting(QCompleter::ModelSorting sorting)

Voir également setCaseSensitivity() et QCompleter::ModelSorting.

wrapAround : bool

Cette propriété définit le contournement des complétions lors de la navigation dans les éléments

La valeur par défaut est true.

Fonctions d'accès :

bool wrapAround() const
void setWrapAround(bool wrap)

Documentation des fonctions membres

QCompleter::QCompleter(QObject *parent = nullptr)

Construit un objet compléteur avec l'adresse parent.

QCompleter::QCompleter(QAbstractItemModel *model, QObject *parent = nullptr)

Construit un objet compléteur avec l'adresse parent donnée, qui fournit des compléments à partir de l'adresse model spécifiée.

QCompleter::QCompleter(const QStringList &list, QObject *parent = nullptr)

Construit un objet QCompleter avec l'adresse parent donnée, qui utilise l'adresse list spécifiée comme source de complétions possibles.

[override virtual noexcept] QCompleter::~QCompleter()

Détruit l'objet compléteur.

[signal] void QCompleter::activated(const QModelIndex &index)

Ce signal est envoyé lorsqu'un élément du site popup() est activé par l'utilisateur. (en cliquant ou en appuyant sur return). L'adresse index de l'élément dans completionModel() est donnée.

Note : Ce signal est surchargé. Pour se connecter à ce signal :

// Connect using qOverload:
connect(completer, qOverload(&QCompleter::activated),
        receiver, &ReceiverClass::slot);

// Or using a lambda:
connect(completer, qOverload(&QCompleter::activated),
        this, [](const QModelIndex &index) { /* handle activated */ });
Pour plus d'exemples et d'approches, voir Connexion aux signaux surchargés.

[signal] void QCompleter::activated(const QString &text)

Ce signal est envoyé lorsqu'un élément du site popup() est activé par l'utilisateur (en cliquant ou en appuyant sur la touche retour). L'adresse text de l'élément est donnée.

Note : Ce signal est surchargé. Pour se connecter à ce signal :

// Connect using qOverload:
connect(completer, qOverload(&QCompleter::activated),
        receiver, &ReceiverClass::slot);

// Or using a lambda:
connect(completer, qOverload(&QCompleter::activated),
        this, [](const QString &text) { /* handle activated */ });
Pour plus d'exemples et d'approches, voir Connexion aux signaux surchargés.

[slot] void QCompleter::complete(const QRect &rect = QRect())

Pour les modes QCompleter::PopupCompletion et QCompletion::UnfilteredPopupCompletion, l'appel à cette fonction permet d'afficher la popup affichant les complétions en cours. Par défaut, si rect n'est pas spécifié, la fenêtre contextuelle est affichée au bas de la page widget(). Si rect est spécifié, la fenêtre contextuelle est affichée sur le bord gauche du rectangle.

Pour le mode QCompleter::InlineCompletion, le signal highlighted() est émis avec l'achèvement en cours.

int QCompleter::completionCount() const

Renvoie le nombre de compléments pour le préfixe actuel. Pour un modèle non trié comportant un grand nombre d'éléments, cette fonction peut s'avérer coûteuse. Utilisez setCurrentRow() et currentCompletion() pour parcourir toutes les complétions.

QAbstractItemModel *QCompleter::completionModel() const

Renvoie le modèle d'achèvement. Le modèle de complétion est un modèle de liste en lecture seule qui contient toutes les correspondances possibles pour le préfixe de complétion actuel. Le modèle de complétion est mis à jour automatiquement pour refléter les complétions actuelles.

Note : La valeur de retour de cette fonction est définie comme étant QAbstractItemModel uniquement pour des raisons de généralité. Ce type de modèle renvoyé est une instance d'une sous-classe de QAbstractProxyModel.

Voir aussi completionPrefix et model().

QString QCompleter::currentCompletion() const

Renvoie la chaîne de complétion actuelle. Cela inclut la chaîne completionPrefix. Lorsqu'elle est utilisée avec setCurrentRow(), elle peut être utilisée pour itérer à travers toutes les correspondances.

Voir aussi setCurrentRow() et currentIndex().

QModelIndex QCompleter::currentIndex() const

Renvoie l'index du modèle de l'achèvement actuel dans le site completionModel().

Voir aussi setCurrentRow(), currentCompletion(), et model().

int QCompleter::currentRow() const

Renvoie la ligne actuelle.

Voir aussi setCurrentRow().

[override virtual protected] bool QCompleter::event(QEvent *ev)

Réimplémente : QObject::event(QEvent *e).

[override virtual protected] bool QCompleter::eventFilter(QObject *o, QEvent *e)

Réimplémente : QObject::eventFilter(QObject *watched, QEvent *event).

[signal] void QCompleter::highlighted(const QModelIndex &index)

Ce signal est envoyé lorsqu'un élément de popup() est mis en évidence par l'utilisateur. Il est également envoyé si complete() est appelé alors que completionMode() a la valeur QCompleter::InlineCompletion. L'élément index dans completionModel() est donné.

Note : Ce signal est surchargé. Pour se connecter à ce signal :

// Connect using qOverload:
connect(completer, qOverload(&QCompleter::highlighted),
        receiver, &ReceiverClass::slot);

// Or using a lambda:
connect(completer, qOverload(&QCompleter::highlighted),
        this, [](const QModelIndex &index) { /* handle highlighted */ });
Pour plus d'exemples et d'approches, voir Connexion aux signaux surchargés.

[signal] void QCompleter::highlighted(const QString &text)

Ce signal est envoyé lorsqu'un élément de popup() est mis en évidence par l'utilisateur. Il est également envoyé si complete() est appelé alors que completionMode() a la valeur QCompleter::InlineCompletion. La valeur text de l'élément est donnée.

Remarque : ce signal est surchargé. Pour se connecter à ce signal :

// Connect using qOverload:
connect(completer, qOverload(&QCompleter::highlighted),
        receiver, &ReceiverClass::slot);

// Or using a lambda:
connect(completer, qOverload(&QCompleter::highlighted),
        this, [](const QString &text) { /* handle highlighted */ });
Pour plus d'exemples et d'approches, voir Connexion aux signaux surchargés.

QAbstractItemModel *QCompleter::model() const

Retourne le modèle qui fournit les chaînes de complétion.

Voir aussi setModel() et completionModel().

[virtual] QString QCompleter::pathFromIndex(const QModelIndex &index) const

Renvoie le chemin d'accès pour l'adresse index donnée. L'objet compléteur l'utilise pour obtenir le texte de complétion à partir du modèle sous-jacent.

L'implémentation par défaut renvoie l'adresse edit role de l'élément pour les modèles de liste. Elle renvoie le chemin d'accès absolu au fichier si le modèle est un QFileSystemModel.

Voir également splitPath().

Renvoie la fenêtre contextuelle utilisée pour afficher les complétions.

Voir aussi setPopup().

bool QCompleter::setCurrentRow(int row)

Définit la ligne actuelle à l'adresse row spécifiée. Renvoie true en cas de succès, sinon false.

Cette fonction peut être utilisée avec currentCompletion() pour itérer à travers toutes les complétions possibles.

Voir aussi currentRow(), currentCompletion() et completionCount().

void QCompleter::setModel(QAbstractItemModel *model)

Définit le modèle qui fournit des compléments à model. model peut être un modèle de liste ou un modèle d'arbre. Si un modèle a déjà été défini précédemment et qu'il a pour parent QCompleter, il est supprimé.

Par commodité, si model est un QFileSystemModel, QCompleter remplace son caseSensitivity par Qt::CaseInsensitive sous Windows et Qt::CaseSensitive sur les autres plates-formes.

Voir également completionModel(), modelSorting, et Handling Tree Models.

void QCompleter::setPopup(QAbstractItemView *popup)

Définit la fenêtre contextuelle utilisée pour afficher les compléments à popup. QCompleter prend la propriété de la vue.

Une fenêtre QListView est automatiquement créée lorsque completionMode() est défini sur QCompleter::PopupCompletion ou QCompleter::UnfilteredPopupCompletion. La fenêtre contextuelle par défaut affiche completionColumn().

Assurez-vous que cette fonction est appelée avant que les paramètres de la vue ne soient modifiés. Cela est nécessaire car les propriétés de la vue peuvent exiger qu'un modèle ait été défini sur la vue (par exemple, le masquage de colonnes dans la vue exige qu'un modèle soit défini sur la vue).

Voir aussi popup().

void QCompleter::setWidget(QWidget *widget)

Définit le widget pour lequel des compléments sont fournis à widget. Cette fonction est automatiquement appelée lorsqu'un QCompleter est défini sur un QLineEdit à l'aide de QLineEdit::setCompleter() ou sur un QComboBox à l'aide de QComboBox::setCompleter(). Le widget doit être défini explicitement lorsque des compléments sont fournis pour des widgets personnalisés.

Voir aussi widget(), setModel() et setPopup().

[virtual] QStringList QCompleter::splitPath(const QString &path) const

Fractionne l'adresse path donnée en chaînes de caractères qui sont utilisées pour établir des correspondances à chaque niveau de l'adresse model().

L'implémentation par défaut de splitPath() divise un chemin de système de fichiers basé sur QDir::separator() lorsque le sourceModel() est un QFileSystemModel.

Lorsqu'elle est utilisée avec des modèles de liste, le premier élément de la liste renvoyée est utilisé pour la correspondance.

Voir également pathFromIndex() et Handling Tree Models.

QWidget *QCompleter::widget() const

Renvoie le widget pour lequel l'objet completer fournit des compléments.

Voir aussi setWidget().

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.