Sur cette page

QCompleter Class

La classe QCompleter propose des suggestions de complétion basées sur un modèle d'élément. En savoir plus...

En-tête : #include <QCompleter>
CMake : find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(mytarget PRIVATE Qt6::Widgets)
qmake : QT += widgets
Hérite de : 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 proposer des suggestions d'autocomplétion dans n'importe quel widget Qt, comme QLineEdit et QComboBox. Lorsque l'utilisateur commence à saisir un mot, QCompleter lui propose des suggestions pour compléter ce mot, en s'appuyant sur une liste de mots. La liste de mots est fournie sous la forme d’un objet ` QAbstractItemModel`. (Pour les applications simples, où la liste de mots est statique, vous pouvez passer un objet ` QStringList ` au constructeur de `QCompleter`.)

Utilisation de base

Un QCompleter est généralement utilisé avec un « QLineEdit » ou un « QComboBox ». Par exemple, voici comment proposer 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 proposer des suggestions automatiques de noms de fichiers. Par exemple :

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 la fonction ` setModel()`. Par défaut, QCompleter tentera de faire correspondre l’ completion prefix e (c’est-à-dire le mot que l’utilisateur a commencé à saisir) aux données ` Qt::EditRole ` stockées dans la colonne 0 du modèle, en tenant compte de la casse. Ce comportement peut être modifié à l’aide des fonctions ` setCompletionRole()`, ` setCompletionColumn()` et ` setCaseSensitivity()`.

Si le modèle est trié selon la colonne et le rôle utilisés pour la complétion, vous pouvez appeler setModelSorting() en passant soit QCompleter::CaseSensitivelySortedModel, soit QCompleter::CaseInsensitivelySortedModel comme argument. Sur les modèles volumineux, cela peut entraîner des améliorations significatives des performances, car QCompleter peut alors utiliser une recherche binaire au lieu d’une recherche linéaire. La recherche binaire ne fonctionne que lorsque filterMode est Qt::MatchStartsWith.

Le modèle peut être de type « list model », « table model » ou « 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.

La méthode completionMode() détermine le mode utilisé pour proposer des suggestions à l’utilisateur.

Parcourir les suggestions

Pour récupérer une seule chaîne candidate, appelez ` setCompletionPrefix()` avec le texte à compléter, puis appelez ` currentCompletion()`. Vous pouvez parcourir la liste des suggestions comme indiqué ci-dessous :

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

completionCount() renvoie le nombre total de complétions pour le préfixe actuel. Il convient d'éviter autant que possible d'utiliser ` completionCount()`, car cette fonction nécessite un balayage de l'ensemble du modèle.

Le modèle de complétion

completionModel() renvoie un modèle sous forme de liste contenant toutes les complétions possibles pour le préfixe de complétion actuel, dans l'ordre où 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 de setCompletionPrefix() actualise automatiquement le modèle de complétion.

Gestion des modèles arborescents

QCompleter peut rechercher des complétions dans des modèles arborescents, en partant du principe que tout élément (ou sous-élément, ou sous-sous-élément) peut être représenté sans ambiguïté sous forme de chaîne de caractères en spécifiant le chemin d’accès à cet élément. La complétion s’effectue alors niveau par niveau.

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

Pour que ce type de complétion fonctionne, QCompleter doit pouvoir 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 chemin d’accès completionPrefix à l’aide de QDir::separator() si le modèle est un QFileSystemModel.

Pour proposer des complétions, QCompleter doit connaître le chemin d’accès à partir d’un index. Cette information est fournie par pathFromIndex(). L’implémentation par défaut de pathFromIndex() renvoie les données de l’ edit role pour les modèles de type « liste » et le chemin d’accès absolu au fichier si le modèle est de type « QFileSystemModel ».

Voir également QAbstractItemModel, QLineEdit, QComboBox et l’exemple Completer.

Documentation sur les types de membres

enum QCompleter::CompletionMode

Cette énumération définit la manière dont les suggestions sont proposées à l'utilisateur.

ConstanteValeurDescription
QCompleter::PopupCompletion0Les suggestions actuelles s’affichent dans une fenêtre contextuelle.
QCompleter::InlineCompletion2Les suggestions apparaissent en ligne (sous forme de texte sélectionné).
QCompleter::UnfilteredPopupCompletion1Toutes les suggestions possibles s'affichent dans une fenêtre contextuelle, la suggestion la plus probable étant indiquée comme « actuelle ».

Voir aussi setCompletionMode().

enum QCompleter::ModelSorting

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

ConstanteValeurDescription
QCompleter::UnsortedModel0Le modèle n'est pas trié.
QCompleter::CaseSensitivelySortedModel1Le modèle est trié en distinguant les majuscules des minuscules.
QCompleter::CaseInsensitivelySortedModel2Le modèle est trié sans distinction de majuscules et minuscules.

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 également completionColumn, completionRole, modelSorting et filterMode.

completionColumn : int

Cette propriété désigne la colonne du modèle dans laquelle la recherche de complétions est effectuée.

Si l'popup() est une QListView, elle est automatiquement configurée 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

comment les suggestions sont proposées à 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 de suggestion utilisé pour proposer des suggestions.

La méthode ` 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é définit le rôle de l'élément à utiliser pour interroger le contenu des éléments à des fins de 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é détermine la manière dont le filtrage est effectué.

Si filterMode est défini sur « 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 vous définissez filterMode sur une valeur autre que « Qt::MatchFlag », un avertissement s’affichera et aucune action ne sera effectuée. De ce fait, l’indicateur « Qt::MatchCaseSensitive » n’a aucun effet. Utilisez la propriété « caseSensitivity » pour contrôler la distinction entre majuscules et minuscules.

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é définit la taille maximale autorisée à l'écran du module de complétion, exprimée en nombre d'éléments

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

Fonctions d’accès :

int maxVisibleItems() const
void setMaxVisibleItems(int maxItems)

modelSorting : ModelSorting

Cette propriété définit l'ordre de tri du modèle

Par défaut, aucune hypothèse n'est formulée concernant l'ordre des éléments du modèle qui fournit les complétions.

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

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

Remarque : les gains de performances décrits ci-dessus ne peuvent pas se produire lorsque l’ caseSensitivity e du « completer » diffère 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étermine si les suggestions s'affichent en boucle lors de la navigation entre les éléments

La valeur par défaut est true.

Fonctions d'accès :

bool wrapAround() const
void setWrapAround(bool wrap)

Documentation sur les fonctions membres

QCompleter::QCompleter(QObject *parent = nullptr)

Crée un objet « completer » à partir de l'parent on fournie.

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

Crée un objet « completer » à partir de l'parent fournie, qui propose des suggestions issues de l'model spécifiée.

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

Crée un objet QCompleter avec l'parent on fournie, qui utilise l'list on spécifiée comme source de complétions possibles.

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

Détruit l'objet « completer ».

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

Ce signal est émis lorsqu'un élément de la méthode ` popup()` est activé par l'utilisateur (en cliquant dessus ou en appuyant sur la touche Entrée). L'index s relatives à cet élément, issues de la méthode ` completionModel()`, sont fournies.

Remarque : ce signal est surchargé. Pour vous 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, consultez la section « Connexion à des signaux surchargés ».

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

Ce signal est émis lorsqu'un élément de la liste « popup() » est activé par l'utilisateur (en cliquant dessus ou en appuyant sur la touche Entrée). L'text de l'élément est fournie.

Remarque : ce signal est surchargé. Pour vous 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, consultez la section « Connexion à des signaux surchargés ».

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

Pour les modes « QCompleter::PopupCompletion » et « QCompletion::UnfilteredPopupCompletion », l'appel de cette fonction affiche la fenêtre contextuelle présentant les complétions actuelles. Par défaut, si « rect » n'est pas spécifié, la fenêtre contextuelle s'affiche au bas du rectangle « widget » (). Si « rect » est spécifié, la fenêtre contextuelle s'affiche sur le bord gauche du rectangle.

En mode « QCompleter::InlineCompletion », le signal highlighted() est déclenché avec la suggestion actuelle.

int QCompleter::completionCount() const

Renvoie le nombre de suggestions pour le préfixe actuel. Pour un modèle non trié contenant un grand nombre d'éléments, cette opération peut s'avérer coûteuse. Utilisez les méthodes setCurrentRow() et currentCompletion() pour parcourir toutes les suggestions.

QAbstractItemModel *QCompleter::completionModel() const

Renvoie le modèle de complétion. 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.

Remarque : la valeur de retour de cette fonction est définie comme étant un « QAbstractItemModel » (modèle de complétion) uniquement à des fins de généralité. Le type réel du modèle renvoyé est une instance d’une sous-classe de « QAbstractProxyModel ».

Voir également completionPrefix et model().

QString QCompleter::currentCompletion() const

Renvoie la chaîne de complétion actuelle. Celle-ci inclut l'completionPrefix. Utilisée conjointement avec setCurrentRow(), cette fonction permet de parcourir toutes les correspondances.

Voir également setCurrentRow() et currentIndex().

QModelIndex QCompleter::currentIndex() const

Renvoie l'index du modèle correspondant à la suggestion actuelle dans la fonction ` completionModel()`.

Voir également 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 émis lorsqu'un élément de la collection ` popup()` est mis en surbrillance par l'utilisateur. Il est également émis si la méthode ` complete()` est appelée avec le paramètre ` completionMode()` défini sur ` QCompleter::InlineCompletion`. L'index ` de l'élément dans la collection ` completionModel()` est fournie.

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 QModelIndex &index) { /* handle highlighted */ });
Pour plus d’exemples et d’approches, voir la section « Connexion à des signaux surchargés ».

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

Ce signal est émis lorsqu'un élément de la collection ` popup()` est mis en surbrillance par l'utilisateur. Il est également émis si la méthode ` complete()` est appelée avec le paramètre ` completionMode()` défini sur ` QCompleter::InlineCompletion`. L'text ` de l'élément est fourni.

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 la section « Connexion à des signaux surchargés ».

QAbstractItemModel *QCompleter::model() const

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

Voir également setModel() et completionModel().

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

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

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

Voir également ` splitPath()` .

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

Voir aussi setPopup().

bool QCompleter::setCurrentRow(int row)

Définit la ligne courante sur l'row spécifiée. Renvoie « true » en cas de succès ; sinon, renvoie « false ».

Cette fonction peut être utilisée conjointement avec currentCompletion() pour parcourir toutes les complétions possibles.

Voir également currentRow(), currentCompletion() et completionCount().

void QCompleter::setModel(QAbstractItemModel *model)

Définit le modèle qui fournit les suggestions pour model. L’ model peut être un modèle de liste ou un modèle arborescent. Si un modèle a déjà été défini auparavant et que QCompleter lui sert de parent, il est supprimé.

Pour plus de commodité, si model est un QFileSystemModel, QCompleter modifie son caseSensitivity pour le remplacer par Qt::CaseInsensitive sous Windows et par Qt::CaseSensitive sur les autres plateformes.

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

void QCompleter::setPopup(QAbstractItemView *popup)

Définit la fenêtre contextuelle utilisée pour afficher les suggestions sur popup. QCompleter prend en charge la gestion de la vue.

Un ` QListView ` est automatiquement créé lorsque la méthode ` completionMode()` est définie sur ` QCompleter::PopupCompletion ` ou ` QCompleter::UnfilteredPopupCompletion`. La fenêtre contextuelle par défaut affiche la méthode ` completionColumn()`.

Assurez-vous que cette fonction soit appelée avant toute modification des paramètres de la vue. Cela est nécessaire car certaines propriétés de la vue peuvent exiger qu’un modèle y soit défini (par exemple, pour masquer des colonnes dans la vue, il faut qu’un modèle y soit défini).

Voir également popup().

void QCompleter::setWidget(QWidget *widget)

Définit le widget pour lequel des suggestions sont fournies sur 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 suggestions sont fournies pour des widgets personnalisés.

Voir également widget(), setModel() et setPopup().

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

Divise l'path on fournie en chaînes de caractères utilisées pour la mise en correspondance à chaque niveau dans la fonction ` model()`.

L'implémentation par défaut de splitPath() divise un chemin d'accès au système de fichiers en fonction de QDir::separator() lorsque 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 suggestions.

Voir également 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.