QMainWindow

La classe QMainWindow fournit une fenêtre principale pour l'application. Plus d'informations...

#include <QMainWindow>

Voir la position dans l'arbre des classes.

Héritage

Hérite de QWidget.

Description détaillée

La classe QMainWindow fournit une fenêtre principale pour l'application.

Le framework de fenêtre principale de Qt

Une fenêtre principale fournit un cadre (framework) pour la construction de l?interface utilisateur d?une application. Qt dispose de QMainWindow et de ses classes associées pour la gestion de la fenêtre principale. QMainWindow possède sa propre disposition d'éléments (layout) auquel on peut ajouter des barres d?outils QToolBar, des widgets docks QDockWidget, une barre de menus QMenuBar et une barre d?état QStatusBar. Le layout possède une aire centrale qui peut être occupée par n?importe quel type de widget. On peut voir un schéma du layout ci-dessous.

À noter : la création d?une fenêtre principale sans widget central n?est pas prise en charge. On doit avoir un widget central même s?il s?agit juste d?un widget servant à occuper l?espace.

Création des composants de la fenêtre principale

Typiquement, un widget central est un widget Qt standard tel qu?un QTextEdit ou un QGraphicsView. Les widgets personnalisés peuvent aussi être utilisés pour des applications avancées. On peut spécifier le widget central avec setCentralWidget().

Les fenêtres principales peuvent avoir une interface de document simple (SDI) ou multiple (MDI). On crée des applications MDI dans Qt en utilisant un QMdiArea comme widget central.

Nous allons maintenant examiner chacun des autres widgets pouvant être ajoutés à la fenêtre principale. Nous donnerons des exemples sur la façon de les créer et de les ajouter.

Création de menus

Qt implémente les menus dans la classe QMenu, et QMainWindow les conserve dans une barre de menus QMenuBar. Des QAction sont ajoutées aux menus, qui les affichent en tant qu?éléments de menu.

On peut ajouter de nouveaux menus à la barre de menus de la fenêtre principale en appelant menuBar(), qui retourne le QMenuBar pour la fenêtre, puis ajouter un menu avec QMenuBar::addMenu().

QMainWindow est fourni avec une barre de menu par défaut, mais on peut aussi en spécifier une autre avec setMenuBar(). Si on souhaite implémenter une barre de menu personnalisée (c?est-à-dire ne pas utiliser le widget QMenuBar), on peut la spécifier avec setMenuWidget().

Voici un exemple sur la façon de créer des menus :

 void MainWindow::createMenus()
 {
     fileMenu = menuBar()->addMenu(tr("&File"));
     fileMenu->addAction(newAct);
     fileMenu->addAction(openAct);
     fileMenu->addAction(saveAct);

La fonction createPopupMenu() crée des menus contextuels lorsque la fenêtre principale reçoit des événements de menu contextuel. L?implémentation par défaut génère un menu avec des actions cochables provenant des widgets docks et des barres d?outils. Il est possible de réimplémenter createPopupMenu() pour obtenir un menu personnalisé.

Création des barres d?outils

Les barres d?outils sont implémentées dans la classe QToolBar. On peut ajouter une barre d?outils à la fenêtre principale avec addToolBar().

On contrôle la position initiale des barres d?outils en les associant à une Qt::ToolBarArea spécifique. On peut diviser une zone en insérant un séparateur de barres d?outils ? similaire à un saut de ligne dans l?édition de texte ? avec addToolBarBreak() ou insertToolBarBreak(). On peut aussi limiter le placement par l?utilisateur avec QToolBar::setAllowedAreas() et QToolBar::setMovable().

La taille des icônes de la barre d?outils peut être retrouvée avec iconSize(). Les tailles sont dépendantes de la plateforme ; on peut affecter une taille fixe avec setIconSize(). On peut modifier l?apparence de tous les boutons d?outils dans la barre d?outils avec setToolButtonStyle().

Voici un exemple de création de barre d?outils :

 void MainWindow::createToolBars()
 {
     fileToolBar = addToolBar(tr("File"));
     fileToolBar->addAction(newAct);

Création de widgets docks

Les widgets docks sont implémentés dans la classe QDockWidget. Un widget dock est une fenêtre qui peut être encastrée (docked) dans une fenêtre principale. On peut ajouter des widgets docks à une fenêtre principale avec addDockWidget().

Il existe quatre zones données par l?énumération Qt::DockWidgetArea : gauche, droit, haut, bas. On peut spécifier quelle zone de widgets docks doivent occuper les coins où les zones se chevauchent avec setCorner(). Par défaut, chaque zone ne peut contenir qu?une seule ligne (verticale ou horizontale) de widgets docks, mais si on l'autorise avec setDockNestingEnabled(), les widgets docks peuvent être ajoutés dans les deux directions en partageant l'espace de la zone.

Deux widgets docks peuvent aussi être empilés l?un sur l?autre. Une barre d?onglets QTabBar est alors utilisée pour choisir lequel des widgets doit être affiché.

Voici un exemple sur la façon de créer et d?ajouter des widgets docks à une fenêtre principale :

     QDockWidget *dockWidget = new QDockWidget(tr("Dock Widget"), this);
     dockWidget->setAllowedAreas(Qt::LeftDockWidgetArea |
                                 Qt::RightDockWidgetArea);
     dockWidget->setWidget(dockWidgetContents);
     addDockWidget(Qt::LeftDockWidgetArea, dockWidget);

Barre d?état

On peut définir une barre d?état avec setStatusBar(), mais, si elle n'a pas été définie, elle le sera au premier appel de statusBar() (qui retourne la barre d?état de la fenêtre principale). Voir QStatusBar pour plus d?informations sur la façon de l?utiliser.

Le stockage de l'état

QMainWindow peut stocker l'état de sa disposition avec saveState() ; il peut être retrouvé plus tard avec restoreState(). Les informations stockées sont la position et la taille (par rapport à la taille de la fenêtre principale) des barres d'outils et des widgets docks.

Voir aussi QMenuBar, QToolBar, QStatusBar, QDockWidget, Exemple d'application, Exemple de widgets docks, Exemple MDI, Exemple SDI et Exemple de menus.

Type

enum QMainWindow::DockOptionflags QMainWindow::DockOptions

Cette énumération contient des drapeaux qui spécifient le comportement des widgets docks pour la QMainWindow.

Ces options contrôlent uniquement la façon dont les widgets docks peuvent être déposés dans une QMainWindow. Elles ne réorganisent pas les widgets docks pour les rendre conformes aux options spécifiées. Pour cette raison, elles devraient être définies avant que les widgets docks ne soient ajoutés à la fenêtre principale. Les seules exceptions à cela sont les options AnimatedDocks et VerticalTabs qui peuvent être définies à tout moment.

Cette énumération a été introduite ou modifiée dans Qt 4.3.

Le type DockOptions est un typedef pour QFlags<DockOption>. Il stocke une combinaison de OU logiques de valeurs de DockOption.

Propriétés

animated : bool

Cette propriété détermine si la manipulation des widgets docks et des barres d?outils est animée.

Lorsqu?un widget dock ou une barre d?outils sont glissés sur la fenêtre principale, cette dernière ajuste son contenu pour indiquer l?endroit où le widget dock ou la barre d?outils seront stockés s'ils sont déposés. Activer cette propriété implique que le déplacement du contenu de QMainWindow se fait suivant une animation fluide. Désactiver cette propriété implique que le contenu saute instantanément à sa nouvelle position.

Par défaut, cette propriété est activée. Elle peut être désactivée si la fenêtre principale contient des widgets lents à redimensionner ou à repeindre.

Activer cette propriété est équivalent à activer l?option AnimatedDocks en utilisant setDockOptions().

Cette propriété a été introduite dans Qt 4.2.

Fonction d'accès

bool isAnimated () const

void setAnimated ( bool enabled )

dockNestingEnabled : bool

Cette propriété détermine si les widgets docks peuvent être empilés.

Si cette propriété est à false, les zones de dock ne peuvent contenir qu?une seule ligne (horizontale ou verticale) de widgets docks. Si elle est à true, la zone occupée par un widget dock peut être divisée dans les deux directions pour contenir plusieurs widgets docks juxtaposés.

La juxtaposition de widgets docks est nécessaire uniquement pour les applications qui contiennent plusieurs widgets docks. Cela fournit à l?utilisateur une plus grande liberté dans l?organisation de la fenêtre principale. Toutefois, la juxtaposition conduit à un comportement plus complexe (et moins intuitif) lorsqu?un widget dock est glissé sur la fenêtre principale, étant donné qu?il existe plus de façons de placer un widget dock déposé dans la zone de dock.

Définir cette propriété est équivalent à activer l?option AllowNestedDocks en utilisant setDockOptions().

Cette propriété a été introduite dans Qt 4.2.

Fonction d'accès

bool isDockNestingEnabled () const

void setDockNestingEnabled ( bool enabled )

dockOptions : DockOptions

Cette propriété enregistre le comportement de docking de QMainWindow.

La valeur par défaut est AnimatedDocks | AllowTabbedDocks.

Cette propriété a été introduite dans Qt 4.3.

Fonction d'accès

DockOptions dockOptions () const

void setDockOptions ( DockOptions options )

documentMode : bool

Cette propriété détermine si la barre d'onglets des widgets docks est en mode document.

La valeur par défaut est false.

Cette propriété a été introduite dans Qt 4.5.

Fonction d'accès

bool documentMode () const

void setDocumentMode ( bool enabled )

Voir aussi QTabBar::documentMode.

iconSize : QSize

Cette propriété enregistre la taille des icônes de la barre d'outils de cette fenêtre principale.

La valeur par défaut est la taille d'icône de barre d'outils par défaut dans ce style d'IHM. À noter que les icônes utilisées doivent être au moins de cette taille, étant donné que la taille des icônes ne peut qu'être réduite.

Fonction d'accès

QSize iconSize () const

void setIconSize ( const QSize & iconSize )

tabShape : QTabWidget::TabShape

Cette propriété enregistre la forme d'onglet utilisée par les widgets docks avec onglets.

La valeur par défaut est QTabWidget::Rounded.

Cette propriété a été introduite dans Qt 4.5.

Fonction d'accès

QTabWidget::TabShape tabShape () const

void setTabShape ( QTabWidget::TabShape tabShape )

Voir aussi setTabPosition().

toolButtonStyle : Qt::ToolButtonStyle

Cette propriété enregistre le style des boutons de barre d'outils dans cette fenêtre principale.

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

Fonction d'accès

Qt::ToolButtonStyle toolButtonStyle () const

void setToolButtonStyle ( Qt::ToolButtonStyle toolButtonStyle )

unifiedTitleAndToolBarOnMac : bool

Cette propriété détermine si la fenêtre utilise l?apparence de barre de titre et de barre d?outils unifiée sous Mac OS X.

Cette propriété est à false par défaut, et n?a d?effet que sur Mac OS X 10.4 ou supérieur.

Si elle vaut true, la zone de la barre d?outils principale est remplacée par une HIToolbar Carbon ou une NSToolbar Cocoa (selon que Qt a été construit avec Carbon ou Cocoa). Toutes les barres d?outils dans la zone de la barre d?outils principale, et toutes les barres d?outils ajoutées après, y sont déplacées. Cela implique un certain nombre de choses :

• les QToolBar dans cette zone de barre d?outils ne sont pas déplaçables, et on ne peut pas y glisser d?autres barres d?outils ;
• les séparateurs de barres d?outils ne sont pas respectés ni conservés ;
• aucun widget personnalisé dans la barre d?outils ne sera affiché si la barre d?outils devient trop petite (seules les actions seront affichées) ;
• avant Qt 4.5, si on appelle showFullScreen() sur la fenêtre principale, le QToolbar va disparaître étant donné qu?il est considéré comme faisant partie de la barre de titre. Qt 4.5 et supérieur contourne cela en enlevant puis en remettant les barres d?outils dans la barre d?outils habituelle ? et vice-versa ? lors de l?échange.

Fixer cette propriété à false supprime ces restrictions.

L?attribut Qt::WA_MacBrushedMetal est prioritaire sur cette propriété.

Cette propriété a été introduite dans Qt 4.3.

Fonction d'accès

bool unifiedTitleAndToolBarOnMac () const

void setUnifiedTitleAndToolBarOnMac ( bool set )

Fonctions membres

QMainWindow::QMainWindow ( QWidget * parent = 0, Qt::WindowFlags flags = 0 )

Construit un QMainWindow avec le parent donné et les drapeaux flags spécifiés.

QMainWindow définit le drapeau Qt::Window lui-même et sera donc toujours créé en tant que widget de premier niveau.

QMainWindow::~QMainWindow ()

Détruit la fenêtre principale.

void QMainWindow::addDockWidget ( Qt::DockWidgetArea area, QDockWidget * dockwidget )

Ajoute le widget dock dockwidget donné à la zone area spécifiée.

void QMainWindow::addDockWidget ( Qt::DockWidgetArea area, QDockWidget * dockwidget, Qt::Orientation orientation )

Ajoute le widget dock dockwidget donné à la zone area spécifiée, dans la direction spécifiée par orientation.

void QMainWindow::addToolBar ( Qt::ToolBarArea area, QToolBar * toolbar )

Ajoute le widget dock dockwidget donné à la zone area spécifiée. La barre d'outils toolbar est placée à la fin du bloc (la ligne) de barre d'outils courant. Si la fenêtre principale gère déjà toolbar, alors elle sera simplement déplacée dans la zone area.

Voir aussi insertToolBar(), addToolBarBreak() et insertToolBarBreak().

void QMainWindow::addToolBar ( QToolBar * toolbar )

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

Équivalent à l'appel de addToolBar(Qt::TopToolBarArea, toolbar).

QToolBar * QMainWindow::addToolBar ( const QString & title )

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

Crée un objet QToolBar, fixe son titre de fenêtre à title et l'insère dans la zone de barre d'outils principale.

Voir aussi setWindowTitle().

void QMainWindow::addToolBarBreak ( Qt::ToolBarArea area = Qt::TopToolBarArea )

Ajoute un séparateur de barres d'outils à la zone area spécifiée après tous les objets qui y sont présents.

QWidget * QMainWindow::centralWidget () const

Retourne le widget central de la fenêtre principale. Cette fonction retourne zéro si le widget central n'a pas été défini.

Voir aussi setCentralWidget().

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

Réimplémentation de QWidget::contextMenuEvent().

Qt::DockWidgetArea QMainWindow::corner ( Qt::Corner corner ) const

Retourne la zone de widgets docks occupant le coin corner spécifié.

Voir aussi setCorner().

QMenu * QMainWindow::createPopupMenu () [virtual]

Retourne un menu contextuel contenant des entrées cochables pour les barres d?outils et les widgets docks présents dans la fenêtre principale. Si aucune barre d?outils ni widget dock n'est présent, cette fonction retourne un pointeur nul.

Par défaut, cette fonction est appelée par la fenêtre principale lorsque l?utilisateur active un menu contextuel, typiquement en faisant un clic droit sur une barre d?outils ou un widget dock.

Si on souhaite créer un menu contextuel personnalisé, on réimplémente cette fonction pour qu?elle retourne un menu contextuel spécialement créé. L?appelant du menu contextuel devient propriétaire du menu contextuel.

Voir aussi addDockWidget(), addToolBar() et menuBar().

Qt::DockWidgetArea QMainWindow::dockWidgetArea ( QDockWidget * dockwidget ) const

Retourne le Qt::DockWidgetArea pour le widget dock dockwidget. Si dockwidget n'a pas été ajouté à la fenêtre principale, cette fonction retourne Qt::NoDockWidgetArea.

Voir aussi addDockWidget(), splitDockWidget() et Qt::DockWidgetArea.

bool QMainWindow::event ( QEvent * event ) [virtual protected]

Réimplémentation de QObject::event().

void QMainWindow::iconSizeChanged ( const QSize & iconSize ) [signal]

Ce signal est émis lorsque la taille des icônes utilisées dans la fenêtre est modifiée. La nouvelle taille d'icône est fournie par iconSize.

On peut connecter ce signal aux autres composants pour aider l'application à conserver une apparence cohérente.

Voir aussi setIconSize().

void QMainWindow::insertToolBar ( QToolBar * before, QToolBar * toolbar )

Insère la barre d'outils toolbar dans la zone occupée par la barre d'outils before, afin qu'elle apparaisse avant before. Par exemple, dans une opération avec une disposition habituelle de gauche à droite et dans une zone de barres d'outils horizontale, cela signifie que toolbar apparaitra à la gauche de la barre d'outils spécifiée par before

Voir aussi insertToolBarBreak(), addToolBar() et addToolBarBreak().

void QMainWindow::insertToolBarBreak ( QToolBar * before )

Insère un séparateur de barres d'outils avant la barre d'outils spécifiée par before.

QMenuBar * QMainWindow::menuBar () const

Retourne la barre de menus pour la fenêtre principale. Cette fonction crée et retourne une barre de menus vide si la barre de menus n?existe pas.

Si l'on souhaite que toutes les fenêtres d?une application Mac partagent une seule barre de menus, il ne faut pas utiliser cette fonction pour la créer, car la barre de menus créée ici aura pour parent cette QMainWindow. À la place, on doit créer une barre de menus sans parent, que l?on peut alors partager avec toutes les fenêtres Mac. On peut créer une barre de menus sans parent de cette façon :

 QMenuBar *menuBar = new QMenuBar(0);

Voir aussi setMenuBar().

QWidget * QMainWindow::menuWidget () const

Retourne la barre de menus de cette fenêtre principale. Cette fonction retourne zéro si une barre de menus n'a pas encore été construite.

Cette fonction a été introduite dans Qt 4.2.

Voir aussi setMenuWidget().

void QMainWindow::removeDockWidget ( QDockWidget * dockwidget )

Retire le widget dock dockwidget du layout de la fenêtre principale et le cache. À noter que le dockwidget n'est pas supprimé.

void QMainWindow::removeToolBar ( QToolBar * toolbar )

Retire la barre d'outils toolbardu layout de la fenêtre principale et la cache. À noter que la toolbar n?est pas supprimée.

void QMainWindow::removeToolBarBreak ( QToolBar * before )

Retire le séparateur de barres d'outils précédemment inséré avant la barre d'outils spécifiée par before.

bool QMainWindow::restoreDockWidget ( QDockWidget * dockwidget )

Restaure l'état du widget dock dockwidget s'il a été créé après l'appel à restoreState(). Retourne true si l'état a été restauré ; sinon retourne false.

Voir aussi restoreState() et saveState().

bool QMainWindow::restoreState ( const QByteArray & state, int version = 0 )

Restaure l'état state des barres d'outils et des widgets docks de cette fenêtre principale. Le numéro de version est comparé avec celui stocké dans state. S'ils ne correspondent pas, l'état de la fenêtre principale est laissé inchangé et cette fonction retourne false ; sinon, l'état est restauré et cette fonction retourne true.

Pour restaurer la géométrie sauvegardée en utilisant QSettings, on peut utiliser un code similaire à :

 void MainWindow::readSettings()
 {
     QSettings settings("MyCompany", "MyApp");
     restoreGeometry(settings.value("myWidget/geometry").toByteArray());
     restoreState(settings.value("myWidget/windowState").toByteArray());
 }

Voir aussi saveState(), QWidget::saveGeometry(), QWidget::restoreGeometry() et restoreDockWidget().

QByteArray QMainWindow::saveState ( int version = 0 ) const

Sauvegarde l'état courant des barres d?outils et des widgets docks de cette fenêtre principale. Le numéro de version est enregistré avec les autres données.

La propriété objectName est utilisée pour identifier chaque QToolBar et QDockWidget. On doit s'assurer que chaque propriété est unique pour chaque QToolBar et QDockWidget que l'on ajoute à QMainWindow.

Pour restaurer l'état sauvegardé, on passe la valeur de retour et le numéro de version à restoreState().

Pour sauvegarder la géométrie lorsque la fenêtre est fermée, on peut implémenter un événement de fermeture comme ceci :

 void MyMainWindow::closeEvent(QCloseEvent *event)
 {
     QSettings settings("MyCompany", "MyApp");
     settings.setValeur("geometry", saveGeometry());
     settings.setValeur("windowState", saveState());
     QMainWindow::closeEvent(event);
 }

Voir aussi restoreState(), QWidget::saveGeometry() et QWidget::restoreGeometry().

void QMainWindow::setCentralWidget ( QWidget * widget )

Définit le widget donné en tant que widget central de la fenêtre principale.

À noter : QMainWindow devient propriétaire du pointeur widget et le supprimera en temps voulu.

Voir aussi centralWidget().

void QMainWindow::setCorner ( Qt::Corner corner, Qt::DockWidgetArea area )

Spécifie que le coin corner spécifié sera occupé par la zone de widgets docks area.

Voir aussi corner().

void QMainWindow::setMenuBar ( QMenuBar * menuBar )

Définit menuBar comme barre de menus de la fenêtre principale.

À noter : QMainWindow devient propriétaire du pointeur menuBar et le supprimera en temps voulu.

Voir aussi menuBar().

void QMainWindow::setMenuWidget ( QWidget * menuBar )

Définit menuBar comme barre de menus de la fenêtre principale.

QMainWindow devient propriétaire du pointeur menuBar et le supprimera en temps voulu.

Cette fonction a été introduite dans Qt 4.2.

Voir aussi menuWidget().

void QMainWindow::setStatusBar ( QStatusBar * statusbar )

Définit statusBar comme barre d'état de la fenêtre principale.

Définir la barre d'état à 0 la supprimera de la fenêtre principale. À noter que QMainWindow devient propriétaire du pointeur statusBar et le supprimera en temps voulu.

Voir aussi statusBar().

void QMainWindow::setTabPosition ( Qt::DockWidgetAreas areas, QTabWidget::TabPosition tabPosition )

Fixe la position des onglets des zones de widgets docks areas données à la position tabPosition spécifiée. Par défaut, toutes les zones de docks affichent les onglets au bas de la zone.

À noter : l'option de dock VerticalTabs écrase les positions des onglets définies par cette méthode.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi tabPosition() et setTabShape().

void QMainWindow::splitDockWidget ( QDockWidget * first, QDockWidget * second, Qt::Orientation orientation )

Divise l?espace couvert par le widget dock first en deux parties, déplace le widget dock first dans la première partie et déplace le widget dock second dans la deuxième partie.

L?orientation spécifie la façon dont l?espace est divisé : une division Qt::Horizontal place le deuxième widget dock à la droite du premier ; une division Qt:: Vertical place le deuxième widget dock sous le premier.

À noter : si first est actuellement dans une zone de docks avec onglets, second sera ajouté dans un nouvel onglet, et non en tant que voisin de first. Ceci est dû au fait qu?un onglet ne peut contenir qu?un seul widget dock.

À noter : la direction du layout Qt::LayoutDirection influence l?ordre des widgets docks dans les deux parties de la zone divisée. Lorsque la direction du layout est de droite à gauche, le placement des widgets docks sera inversé.

Voir aussi tabifyDockWidget(), addDockWidget() et removeDockWidget().

QStatusBar * QMainWindow::statusBar () const

Retourne la barre d'état de la fenêtre principale. Cette fonction crée et retourne une barre d'état vide si la barre d'état n'existe pas.

Voir aussi setStatusBar().

QTabWidget::TabPosition QMainWindow::tabPosition ( Qt::DockWidgetArea area ) const

Retourne la position des onglets pour la zone area.

À noter : l'option de dock VerticalTabs écrase les positions des onglets définies par cette méthode.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi setTabPosition() et tabShape().

QList<QDockWidget *> QMainWindow::tabifiedDockWidgets ( QDockWidget * dockwidget ) const

Retourne les widgets docks se trouvant dans le même groupe d'onglets que le widget dock dockwidget.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi tabifyDockWidget().

void QMainWindow::tabifyDockWidget ( QDockWidget * first, QDockWidget * second )

Déplace le widget dock second au-dessus du widget dock first, en créant une zone de dock avec onglets dans la fenêtre principale.

Voir aussi tabifiedDockWidgets().

Qt::ToolBarArea QMainWindow::toolBarArea ( QToolBar * toolbar ) const

Retourne la zone Qt::ToolBarArea de la barre d'outils toolbar. Si toolbar n'a pas été ajoutée à la fenêtre principale, cette fonction retourne Qt::NoToolBarArea.

Voir aussi addToolBar(), addToolBarBreak() et Qt::ToolBarArea.

bool QMainWindow::toolBarBreak ( QToolBar * toolbar ) const

Retourne true si un séparateur de barres d'outils est présent avant la barre d'outils toolbar.

Voir aussi addToolBarBreak() et insertToolBarBreak().

void QMainWindow::toolButtonStyleChanged ( Qt::ToolButtonStyle toolButtonStyle ) [signal]

Ce signal est émis lorsque le style utilisé pour la fenêtre est modifié. Le nouveau style est passé dans toolButtonStyle.

On peut connecter ce signal aux autres composants pour aider à l'application à conserver une apparence cohérente.

Voir aussi setToolButtonStyle().

Remerciements

Merci à Lo?c Leguay pour la traduction, ainsi qu'à Ilya Diallo, David Taralla et Claude Leloup pour la relecture !