Sur cette page

QTextEdit Class

La classe QTextEdit fournit un widget utilisé pour éditer et afficher du texte simple ou enrichi. Plus d'informations...

En-tête : #include <QTextEdit>
CMake : find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(mytarget PRIVATE Qt6::Widgets)
qmake : QT += widgets
Hérite : QAbstractScrollArea
Hérité par :

QTextBrowser

Types publics

struct ExtraSelection
flags AutoFormatting
enum AutoFormattingFlag { AutoNone, AutoBulletList, AutoAll }
enum LineWrapMode { NoWrap, WidgetWidth, FixedPixelWidth, FixedColumnWidth }

Propriétés

Fonctions publiques

QTextEdit(QWidget *parent = nullptr)
QTextEdit(const QString &text, QWidget *parent = nullptr)
virtual ~QTextEdit()
bool acceptRichText() const
Qt::Alignment alignment() const
QString anchorAt(const QPoint &pos) const
QTextEdit::AutoFormatting autoFormatting() const
bool canPaste() const
QMenu *createStandardContextMenu()
QMenu *createStandardContextMenu(const QPoint &position)
QTextCharFormat currentCharFormat() const
QFont currentFont() const
QTextCursor cursorForPosition(const QPoint &pos) const
QRect cursorRect() const
QRect cursorRect(const QTextCursor &cursor) const
int cursorWidth() const
QTextDocument *document() const
QString documentTitle() const
void ensureCursorVisible()
QList<QTextEdit::ExtraSelection> extraSelections() const
bool find(const QString &exp, QTextDocument::FindFlags options = QTextDocument::FindFlags())
bool find(const QRegularExpression &exp, QTextDocument::FindFlags options = QTextDocument::FindFlags())
QString fontFamily() const
bool fontItalic() const
qreal fontPointSize() const
bool fontUnderline() const
int fontWeight() const
bool isReadOnly() const
bool isUndoRedoEnabled() const
int lineWrapColumnOrWidth() const
QTextEdit::LineWrapMode lineWrapMode() const
virtual QVariant loadResource(int type, const QUrl &name)
void mergeCurrentCharFormat(const QTextCharFormat &modifier)
void moveCursor(QTextCursor::MoveOperation operation, QTextCursor::MoveMode mode = QTextCursor::MoveAnchor)
bool overwriteMode() const
QString placeholderText() const
void print(QPagedPaintDevice *printer) const
void setAcceptRichText(bool accept)
void setAutoFormatting(QTextEdit::AutoFormatting features)
void setCurrentCharFormat(const QTextCharFormat &format)
void setCursorWidth(int width)
void setDocument(QTextDocument *document)
void setDocumentTitle(const QString &title)
void setExtraSelections(const QList<QTextEdit::ExtraSelection> &selections)
void setLineWrapColumnOrWidth(int w)
void setLineWrapMode(QTextEdit::LineWrapMode mode)
void setOverwriteMode(bool overwrite)
void setPlaceholderText(const QString &placeholderText)
void setReadOnly(bool ro)
void setTabChangesFocus(bool b)
void setTabStopDistance(qreal distance)
void setTextCursor(const QTextCursor &cursor)
void setTextInteractionFlags(Qt::TextInteractionFlags flags)
void setUndoRedoEnabled(bool enable)
void setWordWrapMode(QTextOption::WrapMode policy)
bool tabChangesFocus() const
qreal tabStopDistance() const
QColor textBackgroundColor() const
QColor textColor() const
QTextCursor textCursor() const
Qt::TextInteractionFlags textInteractionFlags() const
QString toHtml() const
QString toMarkdown(QTextDocument::MarkdownFeatures features = QTextDocument::MarkdownDialectGitHub) const
QString toPlainText() const
QTextOption::WrapMode wordWrapMode() const

Fonctions publiques réimplémentées

virtual QVariant inputMethodQuery(Qt::InputMethodQuery property) const override

Emplacements publics

void append(const QString &text)
void clear()
void copy()
void cut()
void insertHtml(const QString &text)
void insertPlainText(const QString &text)
void paste()
void redo()
void scrollToAnchor(const QString &name)
void selectAll()
void setAlignment(Qt::Alignment a)
void setCurrentFont(const QFont &f)
void setFontFamily(const QString &fontFamily)
void setFontItalic(bool italic)
void setFontPointSize(qreal s)
void setFontUnderline(bool underline)
void setFontWeight(int weight)
void setHtml(const QString &text)
void setMarkdown(const QString &markdown)
void setPlainText(const QString &text)
void setText(const QString &text)
void setTextBackgroundColor(const QColor &c)
void setTextColor(const QColor &c)
void undo()
void zoomIn(int range = 1)
void zoomOut(int range = 1)

Signaux

void copyAvailable(bool yes)
void currentCharFormatChanged(const QTextCharFormat &f)
void cursorPositionChanged()
void redoAvailable(bool available)
void selectionChanged()
void textChanged()
void undoAvailable(bool available)

Fonctions protégées

virtual bool canInsertFromMimeData(const QMimeData *source) const
virtual QMimeData *createMimeDataFromSelection() const
virtual void insertFromMimeData(const QMimeData *source)

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

virtual void changeEvent(QEvent *e) override
virtual void contextMenuEvent(QContextMenuEvent *event) override
virtual void dragEnterEvent(QDragEnterEvent *e) override
virtual void dragLeaveEvent(QDragLeaveEvent *e) override
virtual void dragMoveEvent(QDragMoveEvent *e) override
virtual void dropEvent(QDropEvent *e) override
virtual void focusInEvent(QFocusEvent *e) override
virtual bool focusNextPrevChild(bool next) override
virtual void focusOutEvent(QFocusEvent *e) override
virtual void inputMethodEvent(QInputMethodEvent *e) override
virtual void keyPressEvent(QKeyEvent *e) override
virtual void keyReleaseEvent(QKeyEvent *e) override
virtual void mouseDoubleClickEvent(QMouseEvent *e) override
virtual void mouseMoveEvent(QMouseEvent *e) override
virtual void mousePressEvent(QMouseEvent *e) override
virtual void mouseReleaseEvent(QMouseEvent *e) override
virtual void paintEvent(QPaintEvent *event) override
virtual void resizeEvent(QResizeEvent *e) override
virtual void scrollContentsBy(int dx, int dy) override
virtual void showEvent(QShowEvent *) override
virtual void wheelEvent(QWheelEvent *e) override

Description détaillée

Introduction et concepts

QTextEdit est un visualiseur/éditeur WYSIWYG avancé qui prend en charge le formatage de texte riche à l'aide de balises de style HTML ou du format Markdown. Il est optimisé pour gérer des documents volumineux et pour répondre rapidement aux entrées de l'utilisateur.

QTextEdit travaille sur les paragraphes et les caractères. Un paragraphe est une chaîne formatée qui est enveloppée de mots pour tenir dans la largeur du widget. Par défaut, lors de la lecture d'un texte simple, un saut de ligne correspond à un paragraphe. Un document se compose de zéro ou plusieurs paragraphes. Les mots du paragraphe sont alignés conformément à l'alignement du paragraphe. Les paragraphes sont séparés par des sauts de ligne. Chaque caractère d'un paragraphe a ses propres attributs, par exemple la police et la couleur.

QTextEdit peut afficher des images, des listes et des tableaux. Si le texte est trop volumineux pour être affiché dans la fenêtre de visualisation de l'éditeur de texte, des barres de défilement apparaissent. L'éditeur de texte peut charger des fichiers de texte brut et de texte enrichi. Le texte enrichi peut être décrit à l'aide d'un sous-ensemble de balises HTML 4 ; voir la page Sous-ensemble HTML pris en charge pour plus d'informations.

Si vous avez juste besoin d'afficher un petit morceau de texte enrichi, utilisez QLabel.

La prise en charge du texte enrichi dans Qt Designer est conçue pour fournir un moyen rapide, portable et efficace d'ajouter des fonctions d'aide en ligne raisonnables aux applications, et pour fournir une base pour les éditeurs de texte enrichi. Si vous trouvez le support HTML insuffisant pour vos besoins, vous pouvez envisager l'utilisation de Qt WebKit, qui fournit un widget de navigateur web complet.

La forme du curseur de la souris sur un QTextEdit est Qt::IBeamCursor par défaut. Elle peut être modifiée à l'aide de la propriété curseur de viewport().

Utilisation de QTextEdit comme widget d'affichage

QTextEdit peut afficher un large sous-ensemble HTML, y compris des tableaux et des images.

Le texte peut être défini ou remplacé à l'aide de setHtml() qui supprime tout texte existant et le remplace par le texte transmis lors de l'appel à setHtml(). Si vous appelez setHtml() avec un HTML hérité, puis appelez toHtml(), le texte renvoyé peut avoir un balisage différent, mais s'affichera de la même manière. Le texte entier peut être supprimé avec clear().

Le texte peut également être défini ou remplacé à l'aide de setMarkdown(), et les mêmes mises en garde s'appliquent : si vous appelez ensuite toMarkdown(), le texte renvoyé peut être différent, mais le sens est préservé dans la mesure du possible. Le Markdown avec du HTML intégré peut être analysé, avec les mêmes limitations que setHtml() ; mais toMarkdown() n'écrit que du Markdown "pur", sans HTML intégré.

Le texte lui-même peut être inséré à l'aide de la classe QTextCursor ou des fonctions de commodité insertHtml(), insertPlainText(), append() ou paste(). QTextCursor est également capable d'insérer des objets complexes tels que des tableaux ou des listes dans le document, et s'occupe de créer des sélections et d'appliquer des modifications au texte sélectionné.

Par défaut, l'édition de texte entoure les mots d'espaces blancs pour les faire tenir dans le widget d'édition de texte. La fonction setLineWrapMode() est utilisée pour spécifier le type de retour à la ligne que vous souhaitez, ou NoWrap si vous ne souhaitez pas de retour à la ligne. Appelez setLineWrapMode() pour définir une largeur de pixel fixe FixedPixelWidth, ou une colonne de caractères (par exemple, une colonne de 80) FixedColumnWidth avec les pixels ou les colonnes spécifiés avec setLineWrapColumnOrWidth(). Si vous utilisez le retour à la ligne à la largeur du widget WidgetWidth, vous pouvez spécifier si le retour à la ligne doit se faire sur les espaces blancs ou n'importe où avec setWordWrapMode().

La fonction find() peut être utilisée pour rechercher et sélectionner une chaîne donnée dans le texte.

Si vous souhaitez limiter le nombre total de paragraphes dans un QTextEdit, comme c'est souvent le cas dans une visionneuse de journaux, vous pouvez utiliser la propriété maximumBlockCount de QTextDocument.

Liaisons de touches en lecture seule

Lorsque QTextEdit est utilisé en lecture seule, les raccourcis clavier sont limités à la navigation, et le texte ne peut être sélectionné qu'à l'aide de la souris :

TouchesAction
Vers le hautDéplacement d'une ligne vers le haut.
Vers le basDéplace d'une ligne vers le bas.
GaucheDéplace un caractère vers la gauche.
DroiteDéplace un caractère vers la droite.
PageUpDéplace d'une page (de la fenêtre) vers le haut.
PageDownDéplace d'une page (de la fenêtre) vers le bas.
DébutPermet de revenir au début du texte.
FinPermet d'atteindre la fin du texte.
Alt+MoletteFait défiler la page horizontalement (la roue est celle de la souris).
Ctrl+MolettePermet d'effectuer un zoom sur le texte.
Ctrl+ASélectionne tout le texte.

L'édition de texte peut fournir des méta-informations. Par exemple, la fonction documentTitle() renvoie le texte à l'intérieur des balises HTML <title>.

Remarque : le zoom dans les documents HTML ne fonctionne que si la taille de la police n'est pas fixe.

Utilisation de QTextEdit comme éditeur

Toutes les informations concernant l'utilisation de QTextEdit comme widget d'affichage s'appliquent également ici.

Les attributs du format de caractère actuel sont définis avec setFontItalic(), setFontWeight(), setFontUnderline(), setFontFamily(), setFontPointSize(), setTextColor() et setCurrentFont(). L'alignement du paragraphe en cours est défini par setAlignment().

La sélection de texte est gérée par la classe QTextCursor, qui permet de créer des sélections, d'extraire le contenu du texte ou de supprimer des sélections. Vous pouvez récupérer l'objet correspondant au curseur visible par l'utilisateur à l'aide de la méthode textCursor(). Si vous souhaitez définir une sélection dans QTextEdit, il vous suffit d'en créer une sur un objet QTextCursor et de faire de ce curseur le curseur visible à l'aide de la méthode setTextCursor(). La sélection peut être copiée dans le presse-papiers avec copy(), ou coupée dans le presse-papiers avec cut(). Le texte entier peut être sélectionné à l'aide de selectAll().

Lorsque le curseur est déplacé et que les attributs de formatage sous-jacents changent, le signal currentCharFormatChanged() est émis pour refléter les nouveaux attributs à la nouvelle position du curseur.

Le signal textChanged() est émis chaque fois que le texte est modifié (à la suite de setText() ou par l'éditeur lui-même).

QTextEdit contient un objet QTextDocument qui peut être récupéré à l'aide de la méthode document(). Vous pouvez également définir votre propre objet document à l'aide de la méthode setDocument().

QTextDocument QTextEdit fournit une fonction isModified() qui renvoie un message vrai si le texte a été modifié depuis son chargement ou depuis le dernier appel à setModified avec false comme argument. En outre, il fournit des méthodes pour annuler et rétablir les modifications.

Glisser-déposer

QTextEdit prend également en charge le comportement personnalisé du glisser-déposer. Par défaut, QTextEdit insère du texte brut, du HTML et du texte enrichi lorsque l'utilisateur dépose des données de ces types MIME dans un document. Réimplémentez canInsertFromMimeData() et insertFromMimeData() pour ajouter la prise en charge de types MIME supplémentaires.

Par exemple, pour permettre à l'utilisateur de glisser-déposer une image sur un QTextEdit, vous pourriez implémenter ces fonctions de la manière suivante :

bool TextEdit::canInsertFromMimeData( const QMimeData *source ) const
{
    if (source->hasImage())
        return true;
    else
        return QTextEdit::canInsertFromMimeData(source);
}

Nous ajoutons la prise en charge des types MIME d'image en renvoyant true. Pour tous les autres types MIME, nous utilisons l'implémentation par défaut.

void TextEdit::insertFromMimeData( const QMimeData *source )
{
    if (source->hasImage())
    {
        QImage image = qvariant_cast<QImage>(source->imageData());
        QTextCursor cursor = this->textCursor();
        QTextDocument *document = this->document();
        document->addResource(QTextDocument::ImageResource, QUrl("image"), image);
        cursor.insertImage("image");
    }
}

Nous décompressons l'image à partir de QVariant détenue par la source MIME et nous l'insérons dans le document en tant que ressource.

Modification des liaisons de clés

La liste des liaisons de touches qui sont implémentées pour l'édition :

TouchesAction
Espace arrièreSupprime le caractère situé à gauche du curseur.
SuppressionSupprime le caractère à droite du curseur.
Ctrl+CCopie le texte sélectionné dans le presse-papiers.
Ctrl+InsérerCopie le texte sélectionné dans le presse-papiers.
Ctrl+KSupprime jusqu'à la fin de la ligne.
Ctrl+VColle le texte du presse-papiers dans l'édition de texte.
Maj+InsérerColle le texte du presse-papiers dans l'édition de texte.
Ctrl+XSupprime le texte sélectionné et le copie dans le presse-papiers.
Maj+SupprimerSupprime le texte sélectionné et le copie dans le presse-papiers.
Ctrl+ZAnnule la dernière opération.
Ctrl+YRefait la dernière opération.
GaucheDéplace le curseur d'un caractère vers la gauche.
Ctrl+GaucheDéplace le curseur d'un mot vers la gauche.
DroiteDéplace le curseur d'un caractère vers la droite.
Ctrl+DroiteDéplace le curseur d'un mot vers la droite.
Vers le hautDéplace le curseur d'une ligne vers le haut.
Vers le basDéplace le curseur d'une ligne vers le bas.
PageHautDéplace le curseur d'une page vers le haut.
PageDownDéplace le curseur d'une page vers le bas.
AccueilDéplace le curseur au début de la ligne.
Ctrl+DébutDéplace le curseur au début du texte.
FinDéplace le curseur à la fin de la ligne.
Ctrl+FinDéplace le curseur à la fin du texte.
Alt+MoletteFait défiler la page horizontalement (la roue est celle de la souris).

Pour sélectionner (marquer) du texte, maintenez la touche Shift enfoncée tout en appuyant sur l'une des touches de déplacement, par exemple, Shift+Droit sélectionnera le caractère à droite, et Shift+Ctrl+Droit sélectionnera le mot à droite, etc.

Voir aussi QTextDocument, QTextCursor, Exemple de surligneur de syntaxe, et Traitement de texte enrichi.

Documentation des types de membres

enum QTextEdit::AutoFormattingFlag
flags QTextEdit::AutoFormatting

ConstanteValeurDescription
QTextEdit::AutoNone0Ne pas effectuer de formatage automatique.
QTextEdit::AutoBulletList0x00000001Créer automatiquement des listes à puces (par exemple, lorsque l'utilisateur saisit un astérisque ('*') dans la colonne la plus à gauche ou appuie sur Entrée dans un élément de liste existant).
QTextEdit::AutoAll0xffffffffAppliquer toutes les mises en forme automatiques. Actuellement, seules les listes à puces automatiques sont prises en charge.

Le type AutoFormatting est un typedef pour QFlags<AutoFormattingFlag>. Il stocke une combinaison OU de valeurs AutoFormattingFlag.

enum QTextEdit::LineWrapMode

ConstanteValeur
QTextEdit::NoWrap0
QTextEdit::WidgetWidth1
QTextEdit::FixedPixelWidth2
QTextEdit::FixedColumnWidth3

Documentation sur les propriétés

acceptRichText : bool

Cette propriété indique si l'éditeur de texte accepte les insertions de texte enrichi par l'utilisateur

Lorsque cette propriété a la valeur "false", l'éditeur de texte n'accepte que du texte brut de la part de l'utilisateur. Par exemple, par le biais du presse-papiers ou d'un glisser-déposer.

La valeur par défaut de cette propriété est true.

Fonctions d'accès :

bool acceptRichText() const
void setAcceptRichText(bool accept)

autoFormatting : AutoFormatting

Cette propriété contient l'ensemble des fonctions de formatage automatique activées

La valeur peut être n'importe quelle combinaison des valeurs de l'énumération AutoFormattingFlag. La valeur par défaut est AutoNone. Choisissez AutoAll pour activer toutes les fonctions de formatage automatique.

Actuellement, la seule fonctionnalité de formatage automatique fournie est AutoBulletList; les futures versions de Qt pourront en offrir d'autres.

Fonctions d'accès :

QTextEdit::AutoFormatting autoFormatting() const
void setAutoFormatting(QTextEdit::AutoFormatting features)

cursorWidth : int

Cette propriété spécifie la largeur du curseur en pixels. La valeur par défaut est 1.

Fonctions d'accès :

int cursorWidth() const
void setCursorWidth(int width)

document : QTextDocument*

Cette propriété contient le document sous-jacent de l'éditeur de texte.

Remarque : l'éditeur ne devient propriétaire du document que s'il est l'objet parent du document. L'objet parent du document fourni reste le propriétaire de l'objet. Si le document précédemment attribué est un enfant de l'éditeur, il sera supprimé.

Fonctions d'accès :

QTextDocument *document() const
void setDocument(QTextDocument *document)

documentTitle : QString

Cette propriété contient le titre du document analysé à partir du texte.

Par défaut, pour un document vide nouvellement créé, cette propriété contient une chaîne vide.

Fonctions d'accès :

QString documentTitle() const
void setDocumentTitle(const QString &title)

html : QString

Cette propriété fournit une interface HTML au texte de l'édition de texte.

toHtml() renvoie le texte de l'édition de texte au format HTML.

setHtml() modifie le texte de l'édition de texte. Tout texte précédent est supprimé et l'historique d'annulation et de rétablissement est effacé. Le texte saisi est interprété comme un texte riche au format html. currentCharFormat() est également réinitialisé, sauf si textCursor() se trouve déjà au début du document.

Remarque : il incombe à l'appelant de s'assurer que le texte est correctement décodé lorsqu'une page QString contenant du HTML est créée et transmise à setHtml().

Par défaut, pour un document vide nouvellement créé, cette propriété contient un texte décrivant un document HTML 4.0 sans corps de texte.

Fonctions d'accès :

QString toHtml() const
void setHtml(const QString &text)

Signal du notificateur :

void textChanged()

Voir aussi Supported HTML Subset et plainText.

lineWrapColumnOrWidth : int

Cette propriété indique la position (en pixels ou en colonnes, selon le mode d'habillage) à laquelle le texte sera habillé

Si le mode d'habillage est FixedPixelWidth, la valeur est le nombre de pixels à partir du bord gauche de l'édition de texte à laquelle le texte doit être habillé. Si le mode d'habillage est FixedColumnWidth, la valeur est le numéro de la colonne (en colonnes de caractères) à partir du bord gauche de l'édition de texte à laquelle le texte doit être habillé.

Par défaut, cette propriété contient une valeur de 0.

Fonctions d'accès :

int lineWrapColumnOrWidth() const
void setLineWrapColumnOrWidth(int w)

Voir également lineWrapMode.

lineWrapMode : LineWrapMode

Cette propriété définit le mode de retour à la ligne

Le mode par défaut est WidgetWidth, ce qui signifie que les mots sont enveloppés sur le bord droit de l'édition de texte. Le retour à la ligne s'effectue au niveau des espaces blancs, en conservant les mots entiers intacts. Si vous souhaitez que le retour à la ligne se fasse à l'intérieur des mots, utilisez setWordWrapMode(). Si vous définissez un mode d'habillage de FixedPixelWidth ou FixedColumnWidth, vous devez également appeler setLineWrapColumnOrWidth() avec la largeur souhaitée.

Fonctions d'accès :

QTextEdit::LineWrapMode lineWrapMode() const
void setLineWrapMode(QTextEdit::LineWrapMode mode)

Voir également lineWrapColumnOrWidth.

markdown : QString

Cette propriété fournit une interface Markdown au texte de l'édition de texte.

toMarkdown() renvoie le texte de l'édition de texte en tant que Markdown "pur", sans aucun formatage HTML intégré. Certaines fonctionnalités prises en charge par QTextDocument (telles que l'utilisation de couleurs spécifiques et de polices nommées) ne peuvent pas être exprimées en Markdown "pur" et seront donc omises.

setMarkdown() modifie le texte de l'édition de texte. Tout texte précédent est supprimé et l'historique undo/redo est effacé. Le texte saisi est interprété comme un texte riche au format Markdown.

L'analyse du HTML inclus dans la chaîne markdown est gérée de la même manière que dans setHtml; cependant, le formatage Markdown à l'intérieur des blocs HTML n'est pas pris en charge.

Certaines fonctionnalités de l'analyseur peuvent être activées ou désactivées via l'argument features:

ConstanteDescription
MarkdownNoHTMLToute balise HTML dans le texte Markdown sera rejetée.
MarkdownDialectCommonMarkL'analyseur syntaxique ne supporte que les fonctionnalités standardisées par CommonMark
MarkdownDialectGitHubL'analyseur syntaxique supporte le dialecte GitHub

La valeur par défaut est MarkdownDialectGitHub.

Fonctions d'accès :

QString toMarkdown(QTextDocument::MarkdownFeatures features = QTextDocument::MarkdownDialectGitHub) const
void setMarkdown(const QString &markdown)

Signal Notifier :

void textChanged()

Voir aussi plainText, html, QTextDocument::toMarkdown(), et QTextDocument::setMarkdown().

overwriteMode : bool

Cette propriété indique si le texte saisi par l'utilisateur écrasera le texte existant

Comme de nombreux éditeurs de texte, le widget de l'éditeur de texte peut être configuré pour insérer ou remplacer le texte existant par le nouveau texte saisi par l'utilisateur.

Si cette propriété vaut true, le texte existant est écrasé, caractère par caractère, par le nouveau texte ; sinon, le texte est inséré à la position du curseur, déplaçant le texte existant.

Par défaut, cette propriété vaut false (le nouveau texte n'écrase pas le texte existant).

Fonctions d'accès :

bool overwriteMode() const
void setOverwriteMode(bool overwrite)

placeholderText : QString

Cette propriété contient le texte d'insertion de l'éditeur

La définition de cette propriété permet à l'éditeur d'afficher un texte d'insertion grisé tant que le document() est vide.

Par défaut, cette propriété contient une chaîne vide.

Fonctions d'accès :

QString placeholderText() const
void setPlaceholderText(const QString &placeholderText)

Voir également document().

plainText : QString

Cette propriété contient le contenu de l'éditeur de texte sous forme de texte brut.

Le contenu précédent est supprimé et l'historique d'annulation et de rétablissement est réinitialisé lorsque la propriété est définie. currentCharFormat() est également réinitialisé, sauf si textCursor() se trouve déjà au début du document.

Si l'édition de texte a un autre type de contenu, il ne sera pas remplacé par du texte brut si vous appelez toPlainText(). La seule exception à cette règle est l'espace insécable, nbsp ;, qui sera converti en espace standard.

Par défaut, pour un éditeur sans contenu, cette propriété contient une chaîne vide.

Fonctions d'accès :

QString toPlainText() const
void setPlainText(const QString &text)

Voir aussi html.

readOnly : bool

Cette propriété indique si l'édition de texte est en lecture seule

Dans une édition de texte en lecture seule, l'utilisateur ne peut que naviguer dans le texte et le sélectionner ; il n'est pas possible de modifier le texte.

La valeur par défaut de cette propriété est false.

Fonctions d'accès :

bool isReadOnly() const
void setReadOnly(bool ro)

tabChangesFocus : bool

Cette propriété détermine si Tab change de focus ou est accepté comme entrée

Dans certains cas, l'édition de texte ne doit pas permettre à l'utilisateur de saisir des tabulateurs ou de modifier l'indentation à l'aide de la touche Tab, car cela rompt la chaîne de focalisation. La valeur par défaut est false.

Fonctions d'accès :

bool tabChangesFocus() const
void setTabChangesFocus(bool b)

tabStopDistance : qreal

Cette propriété indique la distance du taquet de tabulation en pixels

Par défaut, cette propriété contient une valeur de 80 pixels.

Ne pas fixer une valeur inférieure à horizontalAdvance() du caractère QChar::VisualTabCharacter, sinon le caractère tabulation sera dessiné de manière incomplète.

Fonctions d'accès :

qreal tabStopDistance() const
void setTabStopDistance(qreal distance)

Voir aussi QTextOption::ShowTabsAndSpaces et QTextDocument::defaultTextOption.

textInteractionFlags : Qt::TextInteractionFlags

Spécifie comment le widget doit interagir avec les entrées de l'utilisateur.

La valeur par défaut dépend du fait que le site QTextEdit est en lecture seule ou modifiable, et qu'il s'agit d'un site QTextBrowser ou non.

Fonctions d'accès :

Qt::TextInteractionFlags textInteractionFlags() const
void setTextInteractionFlags(Qt::TextInteractionFlags flags)

undoRedoEnabled : bool

Cette propriété indique si les fonctions d'annulation et de rétablissement sont activées.

Les utilisateurs ne peuvent annuler ou refaire des actions que si cette propriété est vraie et si une action peut être annulée (ou refaite).

Fonctions d'accès :

bool isUndoRedoEnabled() const
void setUndoRedoEnabled(bool enable)

wordWrapMode : QTextOption::WrapMode

Cette propriété définit le mode utilisé par QTextEdit pour envelopper le texte par des mots

Par défaut, cette propriété est définie sur QTextOption::WrapAtWordBoundaryOrAnywhere.

Fonctions d'accès :

QTextOption::WrapMode wordWrapMode() const
void setWordWrapMode(QTextOption::WrapMode policy)

Voir également QTextOption::WrapMode.

Documentation sur les fonctions membres

[explicit] QTextEdit::QTextEdit(QWidget *parent = nullptr)

Construit un QTextEdit vide avec le parent parent.

[explicit] QTextEdit::QTextEdit(const QString &text, QWidget *parent = nullptr)

Construit un QTextEdit avec le parent parent. L'éditeur de texte affichera le texte text. Le texte est interprété comme du html.

[virtual noexcept] QTextEdit::~QTextEdit()

Destructeur.

Qt::Alignment QTextEdit::alignment() const

Renvoie l'alignement du paragraphe actuel.

Voir aussi setAlignment().

QString QTextEdit::anchorAt(const QPoint &pos) const

Renvoie la référence de l'ancre à la position pos, ou une chaîne vide si aucune ancre n'existe à cet endroit.

[slot] void QTextEdit::append(const QString &text)

Ajoute un nouveau paragraphe avec text à la fin de l'édition de texte.

Remarque : le nouveau paragraphe ajouté aura le même format de caractère et de bloc que le paragraphe actuel, déterminé par la position du curseur.

Voir également currentCharFormat() et QTextCursor::blockFormat().

[virtual protected] bool QTextEdit::canInsertFromMimeData(const QMimeData *source) const

Cette fonction renvoie true si le contenu de l'objet de données MIME, spécifié par source, peut être décodé et inséré dans le document. Elle est appelée par exemple lorsque, au cours d'une opération de glisser-déposer, la souris entre dans ce widget et qu'il est nécessaire de déterminer s'il est possible d'accepter l'opération de glisser-déposer.

Réimplémentez cette fonction pour permettre la prise en charge du glisser-déposer pour d'autres types MIME.

bool QTextEdit::canPaste() const

Indique si le texte peut être collé depuis le presse-papiers dans la zone de texte.

[override virtual protected] void QTextEdit::changeEvent(QEvent *e)

Réimplémente : QFrame::changeEvent(QEvent *ev).

[slot] void QTextEdit::clear()

Supprime tout le texte de l'édition de texte.

Notes : L'historique annuler/refaire est également effacé :

  • L'historique annuler/refaire est également effacé.
  • currentCharFormat() est réinitialisé, sauf si textCursor() se trouve déjà au début du document.

Voir également cut(), setPlainText() et setHtml().

[override virtual protected] void QTextEdit::contextMenuEvent(QContextMenuEvent *event)

Réimplémente : QAbstractScrollArea::contextMenuEvent(QContextMenuEvent *e).

Affiche le menu contextuel standard créé avec createStandardContextMenu().

Si vous ne souhaitez pas que l'éditeur de texte dispose d'un menu contextuel, vous pouvez définir sa valeur contextMenuPolicy sur Qt::NoContextMenu. Si vous souhaitez personnaliser le menu contextuel, réimplémentez cette fonction. Si vous souhaitez étendre le menu contextuel standard, réimplémentez cette fonction, appelez createStandardContextMenu() et étendez le menu renvoyé.

Les informations relatives à l'événement sont transmises dans l'objet event.

void MyTextEdit::contextMenuEvent(QContextMenuEvent *event)
{
    QMenu *menu = createStandardContextMenu();
    menu->addAction(tr("My Menu Item"));
    //...
    menu->exec(event->globalPos());
    delete menu;
}

[slot] void QTextEdit::copy()

Copie le texte sélectionné dans le presse-papiers.

Voir aussi copyAvailable().

[signal] void QTextEdit::copyAvailable(bool yes)

Ce signal est émis lorsque du texte est sélectionné ou désélectionné dans l'édition de texte.

Lorsqu'un texte est sélectionné, ce signal est émis lorsque yes vaut true. Si aucun texte n'a été sélectionné ou si le texte sélectionné est désélectionné, ce signal est émis avec yes à false.

Si yes est vrai, copy() peut être utilisé pour copier la sélection dans le presse-papiers. Si yes est faux, copy() ne fait rien.

Voir aussi selectionChanged().

[virtual protected] QMimeData *QTextEdit::createMimeDataFromSelection() const

Cette fonction renvoie un nouvel objet de données MIME représentant le contenu de la sélection actuelle de l'éditeur de texte. Elle est appelée lorsque la sélection doit être encapsulée dans un nouvel objet QMimeData; par exemple, lorsqu'une opération de glisser-déposer est lancée ou lorsque des données sont copiées dans le presse-papiers.

Si vous réimplémentez cette fonction, notez que la propriété de l'objet QMimeData renvoyé est transmise à l'appelant. La sélection peut être récupérée à l'aide de la fonction textCursor().

QMenu *QTextEdit::createStandardContextMenu()

Cette fonction crée le menu contextuel standard qui s'affiche lorsque l'utilisateur clique sur le texte à éditer avec le bouton droit de la souris. Elle est appelée à partir du gestionnaire par défaut contextMenuEvent(). La propriété du menu contextuel est transférée à l'appelant.

Nous vous recommandons d'utiliser plutôt la version createStandardContextMenu(QPoint) qui activera les actions sensibles à l'endroit où l'utilisateur a cliqué.

QMenu *QTextEdit::createStandardContextMenu(const QPoint &position)

Cette fonction crée le menu contextuel standard qui s'affiche lorsque l'utilisateur clique sur le texte à éditer avec le bouton droit de la souris. Elle est appelée à partir du gestionnaire par défaut contextMenuEvent() et prend l'adresse position dans les coordonnées du document où le clic de la souris a eu lieu. Cela permet d'effectuer des actions sensibles à l'endroit où l'utilisateur a cliqué. La propriété du menu contextuel est transférée à l'appelant.

QTextCharFormat QTextEdit::currentCharFormat() const

Renvoie le format de caractères utilisé lors de l'insertion d'un nouveau texte.

Voir aussi setCurrentCharFormat().

[signal] void QTextEdit::currentCharFormatChanged(const QTextCharFormat &f)

Ce signal est émis si le format de caractère actuel a changé, par exemple en raison d'un changement de la position du curseur.

Le nouveau format est f.

Voir aussi setCurrentCharFormat().

QFont QTextEdit::currentFont() const

Renvoie la police du format actuel.

Voir aussi setCurrentFont(), setFontFamily(), et setFontPointSize().

QTextCursor QTextEdit::cursorForPosition(const QPoint &pos) const

renvoie une adresse QTextCursor à la position pos (dans les coordonnées de la fenêtre).

[signal] void QTextEdit::cursorPositionChanged()

Ce signal est émis lorsque la position du curseur a changé.

QRect QTextEdit::cursorRect() const

renvoie un rectangle (en coordonnées d'affichage) qui inclut le curseur de l'édition de texte.

QRect QTextEdit::cursorRect(const QTextCursor &cursor) const

renvoie un rectangle (en coordonnées de la fenêtre) qui inclut le site cursor.

[slot] void QTextEdit::cut()

Copie le texte sélectionné dans le presse-papiers et le supprime de l'édition de texte.

S'il n'y a pas de texte sélectionné, rien ne se passe.

Voir aussi copy() et paste().

[override virtual protected] void QTextEdit::dragEnterEvent(QDragEnterEvent *e)

Réimplémente : QAbstractScrollArea::dragEnterEvent(QDragEnterEvent *event).

[override virtual protected] void QTextEdit::dragLeaveEvent(QDragLeaveEvent *e)

Réimplémente : QAbstractScrollArea::dragLeaveEvent(QDragLeaveEvent *event).

[override virtual protected] void QTextEdit::dragMoveEvent(QDragMoveEvent *e)

Réimplémente : QAbstractScrollArea::dragMoveEvent(QDragMoveEvent *event).

[override virtual protected] void QTextEdit::dropEvent(QDropEvent *e)

Réimplémente : QAbstractScrollArea::dropEvent(QDropEvent *event).

void QTextEdit::ensureCursorVisible()

S'assure que le curseur est visible en faisant défiler l'édition de texte si nécessaire.

QList<QTextEdit::ExtraSelection> QTextEdit::extraSelections() const

Renvoie les sélections supplémentaires précédemment définies.

Voir aussi setExtraSelections().

bool QTextEdit::find(const QString &exp, QTextDocument::FindFlags options = QTextDocument::FindFlags())

Trouve la prochaine occurrence de la chaîne de caractères exp, en utilisant la chaîne de caractères options. Renvoie true si exp a été trouvé et change le curseur pour sélectionner la correspondance ; sinon, renvoie false.

bool QTextEdit::find(const QRegularExpression &exp, QTextDocument::FindFlags options = QTextDocument::FindFlags())

Recherche l'occurrence suivante, correspondant à l'expression régulière exp, en utilisant l'adresse options.

Renvoie true si une correspondance a été trouvée et change le curseur pour sélectionner la correspondance ; sinon, renvoie false.

Attention : Pour des raisons historiques, l'option de sensibilité à la casse définie sur exp est ignorée. Au lieu de cela, options est utilisé pour déterminer si la recherche est sensible à la casse ou non.

Il s'agit d'une fonction surchargée.

[override virtual protected] void QTextEdit::focusInEvent(QFocusEvent *e)

Réimplémente : QWidget::focusInEvent(QFocusEvent *event).

[override virtual protected] bool QTextEdit::focusNextPrevChild(bool next)

Réimplémente : QWidget::focusNextPrevChild(bool next).

[override virtual protected] void QTextEdit::focusOutEvent(QFocusEvent *e)

Réimplémente : QWidget::focusOutEvent(QFocusEvent *event).

QString QTextEdit::fontFamily() const

Renvoie la famille de polices du format actuel.

Voir aussi setFontFamily(), setCurrentFont(), et setFontPointSize().

bool QTextEdit::fontItalic() const

Renvoie true si la police du format actuel est italique, sinon renvoie false.

Voir aussi setFontItalic().

qreal QTextEdit::fontPointSize() const

Renvoie la taille des points de la police du format actuel.

Voir aussi setFontFamily(), setCurrentFont(), et setFontPointSize().

bool QTextEdit::fontUnderline() const

Renvoie true si la police du format actuel est soulignée, sinon renvoie false.

Voir aussi setFontUnderline().

int QTextEdit::fontWeight() const

Renvoie le poids de la police du format actuel.

Voir aussi setFontWeight(), setCurrentFont(), setFontPointSize(), et QFont::Weight.

[override virtual protected] void QTextEdit::inputMethodEvent(QInputMethodEvent *e)

Réimplémente : QWidget::inputMethodEvent(QInputMethodEvent *event).

[override virtual] QVariant QTextEdit::inputMethodQuery(Qt::InputMethodQuery property) const

Réimplémente : QWidget::inputMethodQuery(Qt::InputMethodQuery query) const.

[virtual protected] void QTextEdit::insertFromMimeData(const QMimeData *source)

Cette fonction insère le contenu de l'objet de données MIME, spécifié par source, dans l'édition de texte à la position actuelle du curseur. Elle est appelée chaque fois qu'un texte est inséré à la suite d'une opération de collage dans le presse-papiers, ou lorsque l'éditeur de texte accepte des données provenant d'une opération de glisser-déposer.

Réimplémentez cette fonction pour permettre la prise en charge du glisser-déposer pour d'autres types MIME.

[slot] void QTextEdit::insertHtml(const QString &text)

Slot de commodité qui insère text qui est supposé être de formatage html à la position actuelle du curseur.

Elle est équivalente à :

edit->textCursor().insertHtml(fragment);

Remarque : lorsque cette fonction est utilisée avec une feuille de style, celle-ci ne s'applique qu'au bloc actuel du document. Pour appliquer une feuille de style à l'ensemble du document, utilisez plutôt QTextDocument::setDefaultStyleSheet().

[slot] void QTextEdit::insertPlainText(const QString &text)

Slot de commodité qui insère text à la position actuelle du curseur.

Il est équivalent à

edit->textCursor().insertText(text);

[override virtual protected] void QTextEdit::keyPressEvent(QKeyEvent *e)

Réimplémente : QAbstractScrollArea::keyPressEvent(QKeyEvent *e).

[override virtual protected] void QTextEdit::keyReleaseEvent(QKeyEvent *e)

Réimplémente : QWidget::keyReleaseEvent(QKeyEvent *event).

[virtual invokable] QVariant QTextEdit::loadResource(int type, const QUrl &name)

Charge la ressource spécifiée par les données type et name.

Cette fonction est une extension de QTextDocument::loadResource().

Note : Cette fonction peut être invoquée via le système de méta-objets et à partir de QML. Voir Q_INVOKABLE.

Voir aussi QTextDocument::loadResource().

void QTextEdit::mergeCurrentCharFormat(const QTextCharFormat &modifier)

Fusionne les propriétés spécifiées dans modifier dans le format de caractère actuel en appelant QTextCursor::mergeCharFormat sur le curseur de l'éditeur. Si l'éditeur a une sélection, les propriétés de modifier sont directement appliquées à la sélection.

Voir aussi QTextCursor::mergeCharFormat().

[override virtual protected] void QTextEdit::mouseDoubleClickEvent(QMouseEvent *e)

Réimplémente : QAbstractScrollArea::mouseDoubleClickEvent(QMouseEvent *e).

[override virtual protected] void QTextEdit::mouseMoveEvent(QMouseEvent *e)

Réimplémente : QAbstractScrollArea::mouseMoveEvent(QMouseEvent *e).

[override virtual protected] void QTextEdit::mousePressEvent(QMouseEvent *e)

Réimplémente : QAbstractScrollArea::mousePressEvent(QMouseEvent *e).

[override virtual protected] void QTextEdit::mouseReleaseEvent(QMouseEvent *e)

Réimplémente : QAbstractScrollArea::mouseReleaseEvent(QMouseEvent *e).

void QTextEdit::moveCursor(QTextCursor::MoveOperation operation, QTextCursor::MoveMode mode = QTextCursor::MoveAnchor)

Déplace le curseur en exécutant la commande operation.

Si mode est QTextCursor::KeepAnchor, le curseur sélectionne le texte sur lequel il se déplace. C'est le même effet que l'utilisateur obtient lorsqu'il maintient la touche Shift enfoncée et qu'il déplace le curseur à l'aide des touches du curseur.

Voir aussi QTextCursor::movePosition().

[override virtual protected] void QTextEdit::paintEvent(QPaintEvent *event)

Réimplémente : QAbstractScrollArea::paintEvent(QPaintEvent *event).

Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe pour recevoir les événements de peinture transmis à event. Il n'est généralement pas nécessaire de réimplémenter cette fonction dans une sous-classe de QTextEdit.

Remarque : si vous créez une fonction QPainter, elle doit fonctionner sur viewport().

Attention : Le document texte sous-jacent ne doit pas être modifié à partir d'une réimplémentation de cette fonction.

[slot] void QTextEdit::paste()

Colle le texte du presse-papiers dans l'édition de texte à la position actuelle du curseur.

S'il n'y a pas de texte dans le presse-papiers, rien ne se passe.

Pour modifier le comportement de cette fonction, c'est-à-dire pour modifier ce que QTextEdit peut coller et comment il est collé, réimplémentez les fonctions virtuelles canInsertFromMimeData() et insertFromMimeData().

Voir également cut() et copy().

void QTextEdit::print(QPagedPaintDevice *printer) const

Fonction de commodité pour imprimer le document de l'éditeur de texte à l'adresse printer. Cela équivaut à appeler directement la méthode d'impression sur le document, sauf que cette fonction prend également en charge QPrinter::Selection en tant que plage d'impression.

Voir aussi QTextDocument::print().

[slot] void QTextEdit::redo()

Refait la dernière opération.

S'il n'y a pas d'opération à refaire, c'est-à-dire s'il n'y a pas d'étape à refaire dans l'historique undo/redo, rien ne se passe.

Voir également undo().

[signal] void QTextEdit::redoAvailable(bool available)

Ce signal est émis lorsque les opérations de rétablissement deviennent disponibles (available est vrai) ou indisponibles (available est faux).

[override virtual protected] void QTextEdit::resizeEvent(QResizeEvent *e)

Réimplémente : QAbstractScrollArea::resizeEvent(QResizeEvent *event).

[override virtual protected] void QTextEdit::scrollContentsBy(int dx, int dy)

Réimplémente : QAbstractScrollArea::scrollContentsBy(int dx, int dy).

[slot] void QTextEdit::scrollToAnchor(const QString &name)

Fait défiler l'édition de texte de manière à ce que l'ancre correspondant à l'adresse name soit visible ; ne fait rien si l'adresse name est vide, si elle est déjà visible ou si elle n'a pas été trouvée.

[slot] void QTextEdit::selectAll()

Sélectionne tout le texte.

Voir aussi copy(), cut() et textCursor().

[signal] void QTextEdit::selectionChanged()

Ce signal est émis lorsque la sélection change.

Voir également copyAvailable().

[slot] void QTextEdit::setAlignment(Qt::Alignment a)

Définit l'alignement du paragraphe actuel sur a. Les alignements valides sont Qt::AlignLeft, Qt::AlignRight, Qt::AlignJustify et Qt::AlignCenter (qui est centré horizontalement).

Voir aussi alignment().

void QTextEdit::setCurrentCharFormat(const QTextCharFormat &format)

Définit le format de caractères à utiliser lors de l'insertion d'un nouveau texte à format en appelant QTextCursor::setCharFormat() sur le curseur de l'éditeur. Si l'éditeur dispose d'une sélection, le format de caractères est directement appliqué à la sélection.

Voir aussi currentCharFormat().

[slot] void QTextEdit::setCurrentFont(const QFont &f)

Définit la police du format actuel à f.

Voir aussi currentFont(), setFontPointSize() et setFontFamily().

void QTextEdit::setExtraSelections(const QList<QTextEdit::ExtraSelection> &selections)

Cette fonction permet de marquer temporairement certaines régions du document avec une couleur donnée, spécifiée sous selections. Cela peut être utile, par exemple, dans un éditeur de programmation pour marquer toute une ligne de texte avec une couleur de fond donnée afin d'indiquer l'existence d'un point d'arrêt.

Voir également QTextEdit::ExtraSelection et extraSelections().

[slot] void QTextEdit::setFontFamily(const QString &fontFamily)

Définit la famille de polices du format actuel à fontFamily.

Voir aussi fontFamily() et setCurrentFont().

[slot] void QTextEdit::setFontItalic(bool italic)

Si italic est vrai, le format actuel est mis en italique ; sinon, le format actuel est mis en non-italique.

Voir aussi fontItalic().

[slot] void QTextEdit::setFontPointSize(qreal s)

Fixe la taille des points du format actuel à s.

Notez que si s est nul ou négatif, le comportement de cette fonction n'est pas défini.

Voir aussi fontPointSize(), setCurrentFont() et setFontFamily().

[slot] void QTextEdit::setFontUnderline(bool underline)

Si underline est vrai, le format actuel est souligné ; sinon, le format actuel est non souligné.

Voir aussi fontUnderline().

[slot] void QTextEdit::setFontWeight(int weight)

Définit le poids de la police du format actuel à la valeur donnée weight, la valeur utilisée étant comprise dans l'intervalle défini par l'énumération QFont::Weight.

Voir aussi fontWeight(), setCurrentFont(), et setFontFamily().

[slot] void QTextEdit::setPlainText(const QString &text)

Modifie le texte de l'édition de texte en le remplaçant par la chaîne text. Tout texte précédent est supprimé.

Notes :

  • text est interprété comme du texte brut.
  • L'historique annuler/refaire est également effacé.
  • currentCharFormat() est réinitialisé, sauf si textCursor() se trouve déjà au début du document.

Note : Fonction de définition de la propriété plainText.

Voir également toPlainText().

[slot] void QTextEdit::setText(const QString &text)

Définit le format de l'éditeur de texte text. Le texte peut être du texte brut ou du HTML et l'éditeur de texte essaiera de deviner le bon format.

Utilisez directement setHtml() ou setPlainText() pour éviter que l'éditeur de texte ne devine le format.

Voir aussi toPlainText() et toHtml().

[slot] void QTextEdit::setTextBackgroundColor(const QColor &c)

Définit la couleur d'arrière-plan du texte du format actuel à c.

Voir aussi textBackgroundColor().

[slot] void QTextEdit::setTextColor(const QColor &c)

Définit la couleur du texte du format actuel à c.

Voir aussi textColor().

void QTextEdit::setTextCursor(const QTextCursor &cursor)

Définit la valeur visible de cursor.

Voir aussi textCursor().

[override virtual protected] void QTextEdit::showEvent(QShowEvent *)

Réimplémente : QWidget::showEvent(QShowEvent *event).

QColor QTextEdit::textBackgroundColor() const

Renvoie la couleur d'arrière-plan du texte dans le format actuel.

Voir aussi setTextBackgroundColor().

[signal] void QTextEdit::textChanged()

Ce signal est émis chaque fois que le contenu du document est modifié, par exemple lorsque du texte est inséré ou supprimé, ou lorsque le formatage est appliqué.

Note : Signal de notification pour les propriétés html et markdown.

QColor QTextEdit::textColor() const

Renvoie la couleur du texte du format actuel.

Voir aussi setTextColor().

QTextCursor QTextEdit::textCursor() const

Renvoie une copie de QTextCursor qui représente le curseur actuellement visible. Notez que les modifications apportées au curseur retourné n'affectent pas le curseur de QTextEdit; utilisez setTextCursor() pour mettre à jour le curseur visible.

Voir aussi setTextCursor().

QString QTextEdit::toPlainText() const

QString QTextEdit::toPlainText() const

Renvoie le texte de l'édition de texte en texte brut.

Note : Fonction d'obtention pour la propriété plainText.

Voir également QTextEdit::setPlainText().

[slot] void QTextEdit::undo()

Annule la dernière opération.

S'il n'y a pas d'opération à annuler, c'est-à-dire s'il n'y a pas d'étape d'annulation dans l'historique d'annulation/de rétablissement, rien ne se produit.

Voir également redo().

[signal] void QTextEdit::undoAvailable(bool available)

Ce signal est émis lorsque les opérations d'annulation deviennent disponibles (available est vrai) ou indisponibles (available est faux).

[override virtual protected] void QTextEdit::wheelEvent(QWheelEvent *e)

Réimplémente : QAbstractScrollArea::wheelEvent(QWheelEvent *e).

[slot] void QTextEdit::zoomIn(int range = 1)

Effectue un zoom sur le texte en augmentant la taille de la police de base range points et en recalculant toutes les tailles de police pour qu'elles correspondent à la nouvelle taille. Cette opération ne modifie pas la taille des images.

Voir également zoomOut().

[slot] void QTextEdit::zoomOut(int range = 1)

Effectue un zoom arrière sur le texte en réduisant la taille de la police de base range points et en recalculant toutes les tailles de police pour qu'elles correspondent à la nouvelle taille. Cette opération ne modifie pas la taille des images.

Voir également zoomIn().

© 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.